@multiplayer-app/ai-agent-node 0.1.0-beta.75 → 0.1.0-beta.77

package/dist/esm/processors/ChatProcessor.js

@@ -17,6 +17,9 @@ export class ChatProcessor {
     socketService;
     agentStore;
     debug;
+    getChatUserId(chat) {
+        return chat.tenants?.userId;
+    }
     constructor(params) {
         this.chatRepository = params.chatRepository;
         this.messageRepository = params.messageRepository;
@@ -50,14 +53,34 @@ export class ChatProcessor {
         }
         return payload.tenants ?? {};
     }
+    getParticipantIds(chat) {
+        const primary = chat.userId ?? this.getChatUserId(chat);
+        return Array.from(new Set([primary, ...(chat.participantIds ?? [])].filter(Boolean)));
+    }
+    hasChatAccess(chat, userId) {
+        if (!userId)
+            return true;
+        return this.getParticipantIds(chat).includes(userId);
+    }
+    emitChatToParticipants(chat, chatToEmit, excludeSocketId) {
+        for (const userId of this.getParticipantIds(chatToEmit.participantIds ? chatToEmit : chat)) {
+            this.socketService.emitChatUpdate(userId, chatToEmit, excludeSocketId);
+        }
+    }
+    emitMessageToParticipants(chat, message, excludeSocketId) {
+        for (const userId of this.getParticipantIds(chat)) {
+            this.socketService.emitMessageUpdate(userId, message, excludeSocketId);
+        }
+    }
     async updateChatAndEmit(chat, update, excludeSocketId) {
         await this.chatRepository.update(chat.id, update);
         const updatedChat = await this.chatRepository.findById(chat.id);
         const chatToEmit = updatedChat ?? { ...chat, ...update };
-        this.socketService.emitChatUpdate(chat.userId, chatToEmit, excludeSocketId);
+        this.emitChatToParticipants(chat, chatToEmit, excludeSocketId);
         return chatToEmit;
     }
     async startSubagentProcess(params) {
+        const parentUserId = params.parentChat.userId ?? this.getChatUserId(params.parentChat) ?? 'guest';
         const childChat = await this.chatRepository.create({
             title: `${params.subAgentConfig.name} subagent`,
             type: ChatType.Agent,
@@ -67,7 +90,8 @@ export class ChatProcessor {
             parentMessageId: params.parentMessage.id,
             parentToolCallId: params.parentToolCallId,
             contextKey: params.parentChat.contextKey,
-            userId: params.parentChat.userId,
+            userId: parentUserId,
+            tenants: { ...params.parentChat.tenants },
             model: params.subAgentConfig.defaultModel || params.parentChat.model,
         });
         try {
@@ -82,10 +106,10 @@ export class ChatProcessor {
                     toolCalls: params.parentMessage.toolCalls,
                 });
                 if (updatedParentMessage) {
-                    this.socketService.emitMessageUpdate(params.parentChat.userId, updatedParentMessage);
+                    this.emitMessageToParticipants(params.parentChat, updatedParentMessage);
                 }
             }
-            this.socketService.emitChatUpdate(params.parentChat.userId, childChat);
+            this.emitChatToParticipants(params.parentChat, childChat);
             const executionTenants = this.getExecutionTenants(params);
             const abortController = this.agentStore.registerSubAgentProcess(childChat.id, params.parentChat.id);
             const userMessage = await this.createMessage(childChat, MessageRole.User, {
@@ -101,7 +125,7 @@ export class ChatProcessor {
                 agentName: params.subAgentConfig.name
             });
             const parentActivity = await this.activityRepository.create({
-                ownerId: params.parentChat.userId,
+                ownerId: parentUserId,
                 groupId: params.parentChat.id,
                 name: ActivityOperationName.SUBAGENT,
                 tenants: executionTenants,
@@ -138,7 +162,7 @@ export class ChatProcessor {
                     tenants: executionTenants,
                 });
             };
-            const userPreferences = await this.agentConfigRepository.findByUserIdAndAgentName(childChat.userId, agentOptions.name);
+            const userPreferences = await this.agentConfigRepository.findByUserIdAndAgentName(parentUserId, agentOptions.name);
             agentOptions.activeTools = this.getAvailableTools(agentOptions, userPreferences);
             await this.streamMessageStep({
                 chat: childChat,
@@ -239,11 +263,15 @@ export class ChatProcessor {
             sessionKind: AgentSessionKind.ROOT
         };
         if (params?.userId) {
+            // Chats visible to this user: owner, tenant owner, or participant (multi-user).
             filter.userId = params.userId;
         }
         if (params?.contextKey) {
             filter.contextKey = params.contextKey;
         }
+        if (params?.multiUser !== undefined) {
+            filter.multiUser = params.multiUser;
+        }
         // Build query options for sort and limit with defaults.
         const options = {
             sort: {
@@ -330,17 +358,12 @@ export class ChatProcessor {
         return descendants;
     }
     async upsertAndGetChat(payload, excludeSocketId) {
-        const targetUserId = payload.userId ?? 'guest';
         let chat = null;
         if (payload.chatId) {
             chat = await this.chatRepository.findById(payload.chatId);
             if (!chat) {
                 throw new Error('Chat not found');
             }
-            // Ensure chat is associated with the caller's userId
-            if (chat.userId && chat.userId !== targetUserId) {
-                throw new Error('Chat does not belong to this user');
-            }
         }
         if (!chat) {
             chat = await this.createChat(payload, excludeSocketId);
@@ -373,19 +396,22 @@ export class ChatProcessor {
             role,
             content: messageData.content,
             agentName: messageData.agentName,
+            sender: messageData.sender,
+            mentions: messageData.mentions ?? [],
+            annotations: messageData.annotations,
             attachments: attachments ?? [],
             reasoning: "",
             toolCalls: []
         });
-        if (chat.userId) {
-            this.socketService.emitMessageUpdate(chat.userId, message, excludeSocketId);
-        }
+        this.emitMessageToParticipants(chat, message, excludeSocketId);
         return message;
     }
     async createChat(payload, excludeSocketId) {
-        const targetUserId = payload.userId ?? 'guest';
+        const targetUserId = payload.userId ?? payload.tenants?.userId ?? 'guest';
         const contextKey = 'contextKey' in payload ? payload.contextKey : 'default';
         const metadata = 'metadata' in payload ? payload.metadata : {};
+        const requestedParticipantIds = 'participantIds' in payload && Array.isArray(payload.participantIds) ? payload.participantIds : [];
+        const participantIds = Array.from(new Set([targetUserId, ...requestedParticipantIds].filter(Boolean)));
         const chat = await this.chatRepository.create({
             title: this.getTemporaryTitle(contextKey),
             type: ChatType.Chat,
@@ -393,10 +419,15 @@ export class ChatProcessor {
             sessionKind: AgentSessionKind.ROOT,
             contextKey,
             userId: targetUserId,
+            tenants: {
+                ...(payload.tenants ?? {}),
+                userId: targetUserId,
+            },
+            participantIds,
             metadata,
             ...(payload.model ? { model: payload.model } : {})
         });
-        this.socketService.emitChatUpdate(targetUserId, chat, excludeSocketId);
+        this.emitChatToParticipants(chat, chat, excludeSocketId);
         return chat;
     }
     /**
@@ -451,7 +482,7 @@ export class ChatProcessor {
         await this.messageRepository.update(message.id, { toolCalls });
         // Bump chat updatedAt so listChats ordering reflects the action.
         await this.chatRepository.update(chat.id, { updatedAt: now });
-        this.socketService.emitMessageUpdate(chat.userId, updatedMessage, params.excludeSocketId);
+        this.emitMessageToParticipants(chat, updatedMessage, params.excludeSocketId);
         if (params.systemMessage) {
             //todo discuss support for system messages
             //await this.createMessage(chat, MessageRole.System, params.systemMessage, undefined, params.excludeSocketId);
@@ -472,7 +503,7 @@ export class ChatProcessor {
         if (!chat) {
             throw new Error('Chat not found');
         }
-        if (params.userId && chat.userId !== params.userId) {
+        if (params.userId && !this.hasChatAccess(chat, params.userId)) {
             throw new Error('Chat does not belong to this user');
         }
         const message = await this.messageRepository.findById(params.messageId);
@@ -501,7 +532,7 @@ export class ChatProcessor {
         }
         const now = new Date().toISOString();
         await this.chatRepository.update(chat.id, { updatedAt: now });
-        this.socketService.emitMessageUpdate(chat.userId, updatedMessage, params.excludeSocketId);
+        this.emitMessageToParticipants(chat, updatedMessage, params.excludeSocketId);
         return updatedMessage;
     }
     async storeSubagentResponse(params) {
@@ -558,7 +589,7 @@ export class ChatProcessor {
                 tenants: executionTenants,
             });
         };
-        const userPreferences = await this.agentConfigRepository.findByUserIdAndAgentName(chat.userId, agentOptions.name);
+        const userPreferences = await this.agentConfigRepository.findByUserIdAndAgentName(this.getChatUserId(chat) ?? chat.userId ?? 'guest', agentOptions.name);
         agentOptions.activeTools = this.getAvailableTools(agentOptions, userPreferences);
         await this.streamMessageStep({
             chat,
@@ -575,7 +606,7 @@ export class ChatProcessor {
         const { chat, assistantMessage, existingMessages, signal, excludeSocketId, agentOptions } = params;
         const persistAndBroadcastToolCalls = async () => {
             await this.messageRepository.update(assistantMessage.id, { toolCalls: assistantMessage.toolCalls ?? [] });
-            this.socketService.emitMessageUpdate(chat.userId, assistantMessage, excludeSocketId);
+            this.emitMessageToParticipants(chat, assistantMessage, excludeSocketId);
             await this.agentStore.shareAgentProcessEvent(chat.id, { type: AgentProcessEventType.Update, data: assistantMessage });
         };
         if (signal.aborted) {
@@ -607,7 +638,7 @@ export class ChatProcessor {
                     await this.agentStore.shareAgentProcessEvent(chat.id, { type: AgentProcessEventType.Aborted, data: undefined });
                     await this.updateChatAndEmit(chat, { status: AgentStatus.Aborted }, excludeSocketId);
                     await this.messageRepository.update(assistantMessage.id, assistantMessage);
-                    this.socketService.emitMessageUpdate(chat.userId, assistantMessage, excludeSocketId);
+                    this.emitMessageToParticipants(chat, assistantMessage, excludeSocketId);
                     continue;
                 }
                 if (chunk.type === 'finish') {
@@ -624,7 +655,7 @@ export class ChatProcessor {
                             ((totalUsage.promptTokens ?? 0) + (totalUsage.completionTokens ?? 0));
                     }
                     await this.messageRepository.update(assistantMessage.id, { ...assistantMessage });
-                    this.socketService.emitMessageUpdate(chat.userId, assistantMessage, excludeSocketId);
+                    this.emitMessageToParticipants(chat, assistantMessage, excludeSocketId);
                     if (chunk.finishReason === 'stop') {
                         let nextChat = await this.updateChatAndEmit(chat, { status: AgentStatus.Finished }, excludeSocketId);
                         if (chat.title && this.isTemporaryTitle(chat.title)) {
@@ -702,7 +733,7 @@ export class ChatProcessor {
                         ...assistantMessage,
                         content: assistantMessage.content
                     };
-                    this.socketService.emitMessageUpdate(chat.userId, updatedMessage, excludeSocketId);
+                    this.emitMessageToParticipants(chat, updatedMessage, excludeSocketId);
                     await this.agentStore.shareAgentProcessEvent(chat.id, { type: AgentProcessEventType.Update, data: updatedMessage });
                     await this.messageRepository.update(assistantMessage.id, { content: assistantMessage.content });
                     continue;
@@ -788,7 +819,7 @@ export class ChatProcessor {
                     if (!assistantMessage.reasoning)
                         assistantMessage.reasoning = '';
                     assistantMessage.reasoning += chunk.text;
-                    this.socketService.emitMessageUpdate(chat.userId, assistantMessage, excludeSocketId);
+                    this.emitMessageToParticipants(chat, assistantMessage, excludeSocketId);
                     await this.messageRepository.update(assistantMessage.id, { reasoning: assistantMessage.reasoning });
                     await this.agentStore.shareAgentProcessEvent(chat.id, { type: AgentProcessEventType.Update, data: assistantMessage });
                     continue;
@@ -871,11 +902,12 @@ export class ChatProcessor {
     }
     async processNewUserMessage(chat, payload, prevMessages, excludeSocketId) {
         const executionTenants = this.getExecutionTenants(payload);
+        const chatUserId = this.getChatUserId(chat) ?? 'guest';
         const userMessage = await this.createMessage(chat, MessageRole.User, { content: payload.content, agentName: undefined }, payload.attachments);
         await this.agentStore.shareAgentProcessEvent(chat.id, { type: AgentProcessEventType.Update, data: userMessage });
         let assistantMessage = await this.createMessage(chat, MessageRole.Assistant, { content: '', agentName: undefined }, undefined, excludeSocketId);
         const parentActivity = await this.activityRepository.create({
-            ownerId: chat.userId,
+            ownerId: chatUserId,
             groupId: chat.id,
             name: ActivityOperationName.MESSAGE_PROCESSING,
             tenants: executionTenants,
@@ -937,12 +969,235 @@ export class ChatProcessor {
             agentOptions,
         };
     }
+    getAgentNamesForContext(contextKey) {
+        try {
+            return ConfigStore.getInstance().getAgentsForContext(contextKey).map((config) => config.name);
+        }
+        catch {
+            return [];
+        }
+    }
+    normalizeMentionName(value) {
+        return value.trim().replace(/^@/, '').toLowerCase();
+    }
+    extractMentionNames(content) {
+        const mentions = content.matchAll(/(^|[\s([{])@([a-zA-Z0-9_.-]+)/g);
+        return Array.from(mentions, (match) => match[2]).filter(Boolean);
+    }
+    getExplicitAgentMention(params) {
+        const agentNames = this.getAgentNamesForContext(params.contextKey);
+        const normalizedAgentNames = new Map(agentNames.map((name) => [this.normalizeMentionName(name), name]));
+        for (const mention of params.mentions ?? []) {
+            if (mention.type !== 'agent')
+                continue;
+            const normalized = this.normalizeMentionName(mention.name);
+            return { mentioned: true, agentName: normalizedAgentNames.get(normalized) };
+        }
+        for (const name of this.extractMentionNames(params.content)) {
+            const normalized = this.normalizeMentionName(name);
+            if (normalized === 'agent') {
+                return { mentioned: true };
+            }
+            const agentName = normalizedAgentNames.get(normalized);
+            if (agentName) {
+                return { mentioned: true, agentName };
+            }
+        }
+        return { mentioned: false };
+    }
+    hasNonAgentMention(params) {
+        const agentNames = this.getAgentNamesForContext(params.contextKey);
+        const normalizedAgentNames = new Set(['agent', ...agentNames.map((name) => this.normalizeMentionName(name))]);
+        if ((params.mentions ?? []).some((mention) => mention.type === 'user')) {
+            return true;
+        }
+        return this.extractMentionNames(params.content).some((name) => {
+            const normalized = this.normalizeMentionName(name);
+            return !normalizedAgentNames.has(normalized);
+        });
+    }
+    renderMessageForDecision(message) {
+        const sender = message.sender?.displayName || message.sender?.id || message.agentName || message.role;
+        return `${sender}: ${message.content}`;
+    }
+    async analyzeAgentShouldRespond(params) {
+        try {
+            const recentMessages = [...params.previousMessages.slice(-8), params.userMessage]
+                .map((message) => this.renderMessageForDecision(message))
+                .join('\n');
+            const response = await this.aiHelper.getAssistantResponse([
+                {
+                    role: MessageRole.User,
+                    content: `Conversation:\n${recentMessages}\n\nShould the AI agent respond to the latest message?`
+                }
+            ], {
+                system: [
+                    'You decide whether an AI agent should reply in a multi-user chat.',
+                    'Reply with exactly YES or NO.',
+                    'YES only when the latest message asks for help, requests agent action, or is clearly addressed to the AI.',
+                    'NO when the latest message is human-to-human chatter, status, acknowledgement, or otherwise does not need the AI.'
+                ].join('\n'),
+                temperature: 0,
+                maxOutputTokens: 5,
+                model: params.chat.model,
+                executionContext: params.executionContext
+            });
+            return /^yes\b/i.test(response.trim());
+        }
+        catch (error) {
+            logger.warn({ error, chatId: params.chat.id }, 'Agent response decision failed');
+            return false;
+        }
+    }
+    async shouldRunAgentForMultiUserMessage(params) {
+        const firstUserMessage = !params.previousMessages.some((message) => message.role === MessageRole.User);
+        if (firstUserMessage) {
+            return { shouldRun: true };
+        }
+        const explicitAgent = this.getExplicitAgentMention({
+            content: params.payload.content,
+            mentions: params.payload.mentions,
+            contextKey: params.chat.contextKey,
+        });
+        if (explicitAgent.mentioned) {
+            return { shouldRun: true, agentName: explicitAgent.agentName };
+        }
+        if (this.hasNonAgentMention({
+            content: params.payload.content,
+            mentions: params.payload.mentions,
+            contextKey: params.chat.contextKey,
+        })) {
+            return { shouldRun: false };
+        }
+        const shouldRun = await this.analyzeAgentShouldRespond({
+            chat: params.chat,
+            previousMessages: params.previousMessages,
+            userMessage: params.userMessage,
+            executionContext: params.payload.executionContext,
+        });
+        return { shouldRun };
+    }
+    async prepareAgentResponseForUserMessage(chat, payload, prevMessages, userMessage, excludeSocketId, agentName) {
+        const executionTenants = this.getExecutionTenants(payload);
+        let assistantMessage = await this.createMessage(chat, MessageRole.Assistant, {
+            content: '',
+            agentName: agentName,
+            sender: {
+                id: agentName ?? 'agent',
+                type: 'agent',
+                displayName: agentName ?? 'Agent',
+            }
+        }, undefined, excludeSocketId);
+        const ownerId = payload.userId ?? chat.userId ?? this.getChatUserId(chat) ?? 'guest';
+        const parentActivity = await this.activityRepository.create({
+            ownerId,
+            groupId: chat.id,
+            name: ActivityOperationName.MESSAGE_PROCESSING,
+            tenants: executionTenants,
+            sourceId: userMessage.id,
+            sourceType: 'AgentMessage',
+            metadata: {
+                contextKey: chat.contextKey,
+                modelId: this.aiHelper.getLanguageModelId(chat.model),
+            },
+        });
+        const agentOptions = await this.aiHelper.getAgentOptions(agentName
+            ? {
+                agentName,
+                modelId: chat.model,
+                context: payload.context,
+                executionContext: payload.executionContext,
+            }
+            : {
+                contextKey: chat.contextKey,
+                messages: [...prevMessages, userMessage],
+                context: payload.context,
+                agentName: undefined,
+                modelId: chat.model,
+                executionContext: payload.executionContext,
+            }, {
+            onStepFinish: async (stepResult) => {
+                await this.storeStepActivity({
+                    chat,
+                    parentId: parentActivity.id,
+                    stepResult,
+                    name: ActivityOperationName.AGENT_SELECTION,
+                    sourceId: userMessage.id,
+                    sourceType: 'AgentMessage',
+                    tenants: executionTenants,
+                });
+            }
+        });
+        const updatedAssistantMessage = await this.messageRepository.update(assistantMessage.id, {
+            agentName: agentOptions.name,
+            activity: parentActivity.id,
+            sender: {
+                id: agentOptions.name,
+                type: 'agent',
+                displayName: agentOptions.name,
+            }
+        });
+        await this.activityRepository.update(parentActivity.id, {
+            metadata: {
+                ...parentActivity.metadata,
+                agentOptions: {
+                    name: agentOptions.name,
+                    modelId: this.aiHelper.getLanguageModelId(agentOptions.model),
+                    temperature: agentOptions.temperature,
+                    maxOutputTokens: agentOptions.maxOutputTokens,
+                    topP: agentOptions.topP,
+                    topK: agentOptions.topK,
+                    presencePenalty: agentOptions.presencePenalty,
+                    frequencyPenalty: agentOptions.frequencyPenalty,
+                    stopSequences: agentOptions.stopSequences,
+                    seed: agentOptions.seed,
+                },
+            },
+        });
+        if (!updatedAssistantMessage) {
+            throw new Error(`Assistant message with id ${assistantMessage.id} not found after update`);
+        }
+        assistantMessage = updatedAssistantMessage;
+        return {
+            assistantMessage,
+            agentOptions,
+            executionTenants,
+        };
+    }
+    async streamAgentResponseForUserMessage(params) {
+        const { assistantMessage, agentOptions, executionTenants } = await this.prepareAgentResponseForUserMessage(params.chat, params.payload, params.previousMessages, params.userMessage, params.excludeSocketId, params.agentName);
+        const messagesForAgent = [...params.previousMessages, params.userMessage];
+        agentOptions.onStepFinish = (stepResult) => {
+            return this.storeStepActivity({
+                chat: params.chat,
+                parentId: assistantMessage.activity,
+                stepResult,
+                name: ActivityOperationName.STEP_FINISHED,
+                sourceId: assistantMessage.id,
+                sourceType: 'AgentMessage',
+                tenants: executionTenants,
+            });
+        };
+        const userPreferences = await this.agentConfigRepository.findByUserIdAndAgentName(params.payload.userId ?? params.chat.userId ?? this.getChatUserId(params.chat) ?? 'guest', agentOptions.name);
+        agentOptions.activeTools = this.getAvailableTools(agentOptions, userPreferences);
+        await this.streamMessageStep({
+            chat: params.chat,
+            existingMessages: messagesForAgent,
+            assistantMessage,
+            agentOptions,
+            excludeSocketId: params.excludeSocketId,
+            signal: params.signal,
+            tenants: executionTenants,
+            executionContext: params.payload.executionContext,
+            context: params.payload.context,
+        });
+    }
     async storeStepActivity(params) {
         try {
             const stepResult = params.stepResult;
             const mergedUsage = this.mergeUsageWithProviderMetadata(stepResult.usage, stepResult.providerMetadata);
             const activity = await this.activityRepository.create({
-                ownerId: params.chat.userId,
+                ownerId: this.getChatUserId(params.chat) ?? 'guest',
                 groupId: params.chat.id,
                 name: params.name,
                 tenants: params.tenants || {},
@@ -1005,7 +1260,7 @@ export class ChatProcessor {
                     tenants: executionTenants,
                 });
             };
-            const userPreferences = await this.agentConfigRepository.findByUserIdAndAgentName(chat.userId, agentOptions.name);
+            const userPreferences = await this.agentConfigRepository.findByUserIdAndAgentName(this.getChatUserId(chat) ?? 'guest', agentOptions.name);
             agentOptions.activeTools = this.getAvailableTools(agentOptions, userPreferences);
             await this.streamMessageStep({
                 chat,
@@ -1135,6 +1390,86 @@ export class ChatProcessor {
         }
         return stream;
     }
+    async upsertAndGetMultiUserChat(payload, excludeSocketId) {
+        const targetUserId = payload.userId ?? 'guest';
+        let chat = null;
+        let isNewChat = false;
+        if (payload.chatId) {
+            chat = await this.chatRepository.findById(payload.chatId);
+            if (!chat) {
+                throw new Error('Chat not found');
+            }
+            if (!this.hasChatAccess(chat, targetUserId)) {
+                throw new Error('Chat does not belong to this user');
+            }
+            const participantIds = Array.from(new Set([
+                ...this.getParticipantIds(chat),
+                ...(payload.participantIds ?? []),
+                targetUserId,
+            ].filter(Boolean)));
+            const updates = {};
+            if (participantIds.length !== this.getParticipantIds(chat).length) {
+                updates.participantIds = participantIds;
+            }
+            if ('model' in payload) {
+                updates.model = payload.model || undefined;
+            }
+            if (Object.keys(updates).length > 0) {
+                chat = await this.updateChatAndEmit(chat, updates, excludeSocketId);
+            }
+        }
+        if (!chat) {
+            chat = await this.createChat(payload, excludeSocketId);
+            isNewChat = true;
+        }
+        return { chat, isNewChat };
+    }
+    async postMultiUserMessage(payload, excludeSocketId) {
+        const { chat } = await this.upsertAndGetMultiUserChat(payload, excludeSocketId);
+        const existingMessages = await this.messageRepository.findByChatId(chat.id);
+        const sender = {
+            id: payload.userId ?? 'guest',
+            type: 'user',
+            ...(payload.senderDisplayName ? { displayName: payload.senderDisplayName } : {}),
+            ...(payload.senderAvatarUrl ? { avatarUrl: payload.senderAvatarUrl } : {}),
+        };
+        const userMessage = await this.createMessage(chat, MessageRole.User, {
+            content: payload.content,
+            agentName: undefined,
+            sender,
+            mentions: payload.mentions ?? [],
+        }, payload.attachments, excludeSocketId);
+        const decision = await this.shouldRunAgentForMultiUserMessage({
+            chat,
+            previousMessages: existingMessages,
+            userMessage,
+            payload,
+        });
+        if (!decision.shouldRun) {
+            const updatedChat = await this.updateChatAndEmit(chat, { status: AgentStatus.Finished }, excludeSocketId);
+            return { chat: updatedChat, message: userMessage, agentTriggered: false };
+        }
+        const updatedChat = await this.updateChatAndEmit(chat, { status: AgentStatus.Streaming }, undefined);
+        const abortController = this.agentStore.registerAgentProcess(chat.id);
+        const limitedMessages = ContextLimiter.limitContext(existingMessages, {
+            maxMessages: this.config.ai.maxContextMessages,
+            keepFirstUserMessage: true,
+            keepSystemMessages: true,
+        });
+        void this.streamAgentResponseForUserMessage({
+            chat,
+            payload,
+            previousMessages: limitedMessages,
+            userMessage,
+            excludeSocketId: undefined,
+            signal: abortController.signal,
+            agentName: decision.agentName,
+        }).catch(async (error) => {
+            logger.error({ error, chatId: chat.id }, 'Multi-user background agent flow failed');
+            await this.updateChatAndEmit(chat, { status: AgentStatus.Error }, undefined);
+        });
+        return { chat: updatedChat, message: userMessage, agentTriggered: true };
+    }
     async createMessageStream(payload, excludeSocketId, signal) {
         const stream = new PassThrough();
         this.runMessageStream(stream, payload, excludeSocketId, signal)