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

package/dist/esm/processors/ChatProcessor.js

@@ -1,11 +1,11 @@
-import { AgentStatus, AgentToolCallStatus, ChatType, MessageRole, SortOrder, StreamChunkType, ActivityOperationName, AgentToolType } from '@multiplayer-app/ai-agent-types';
+import { ActivityOperationName, AgentStatus, AgentToolCallStatus, AgentToolType, ChatType, MessageRole, SortOrder, StreamChunkType } from '@multiplayer-app/ai-agent-types';
 import { z } from 'zod';
-import { AIHelper, FileHelper } from '../helpers';
-import { AgentProcessEventType } from '../store';
-import { ContextLimiter } from '../helpers';
+import { AgentProcessEventType, ConfigStore } from '../store';
+import { AIHelper, ContextLimiter, FileHelper } from '../helpers';
 import { PassThrough } from 'stream';
 import { logger } from '../libs/logger';
-import { ConfigStore } from '../store';
+import { AgentSessionKind } from "@multiplayer-app/ai-agent-types";
+import { getAgentToolName } from "../utils/utils";
 export class ChatProcessor {
     aiHelper;
     chatRepository;
@@ -50,6 +50,117 @@ export class ChatProcessor {
         }
         return payload.tenants ?? {};
     }
+    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);
+        return chatToEmit;
+    }
+    async startSubagentProcess(params) {
+        const childChat = await this.chatRepository.create({
+            title: `${params.subAgentConfig.name} subagent`,
+            type: ChatType.Agent,
+            status: AgentStatus.Streaming,
+            sessionKind: AgentSessionKind.SUBAGENT,
+            parentChatId: params.parentChat.id,
+            parentMessageId: params.parentMessage.id,
+            parentToolCallId: params.parentToolCallId,
+            contextKey: params.parentChat.contextKey,
+            userId: params.parentChat.userId,
+            model: params.subAgentConfig.defaultModel || params.parentChat.model,
+        });
+        try {
+            const parentToolCall = params.parentMessage.toolCalls?.find((toolCall) => toolCall.id === params.parentToolCallId);
+            if (parentToolCall) {
+                parentToolCall.input = {
+                    ...(parentToolCall.input ?? {}),
+                    subagentChatId: childChat.id,
+                };
+                parentToolCall.subagentChatId = childChat.id;
+                const updatedParentMessage = await this.messageRepository.update(params.parentMessage.id, {
+                    toolCalls: params.parentMessage.toolCalls,
+                });
+                if (updatedParentMessage) {
+                    this.socketService.emitMessageUpdate(params.parentChat.userId, updatedParentMessage);
+                }
+            }
+            this.socketService.emitChatUpdate(params.parentChat.userId, childChat);
+            const executionTenants = this.getExecutionTenants(params);
+            const abortController = this.agentStore.registerSubAgentProcess(childChat.id, params.parentChat.id);
+            const userMessage = await this.createMessage(childChat, MessageRole.User, {
+                content: JSON.stringify(params.input),
+                agentName: undefined
+            });
+            await this.agentStore.shareAgentProcessEvent(childChat.id, {
+                type: AgentProcessEventType.Update,
+                data: userMessage
+            });
+            let assistantMessage = await this.createMessage(childChat, MessageRole.Assistant, {
+                content: '',
+                agentName: params.subAgentConfig.name
+            });
+            const parentActivity = await this.activityRepository.create({
+                ownerId: params.parentChat.userId,
+                groupId: params.parentChat.id,
+                name: ActivityOperationName.SUBAGENT,
+                tenants: executionTenants,
+                sourceId: assistantMessage.id,
+                sourceType: 'AgentMessage',
+                metadata: {
+                    modelId: this.aiHelper.getLanguageModelId(childChat.model),
+                    agentOptions: {
+                        name: params.subAgentConfig.name,
+                        modelId: this.aiHelper.getLanguageModelId(params.subAgentConfig.defaultModel),
+                        temperature: params.subAgentConfig.temperature,
+                        maxOutputTokens: params.subAgentConfig.maxOutputTokens,
+                        topP: params.subAgentConfig.topP,
+                        topK: params.subAgentConfig.topK,
+                        presencePenalty: params.subAgentConfig.presencePenalty,
+                        frequencyPenalty: params.subAgentConfig.frequencyPenalty,
+                        stopSequences: params.subAgentConfig.stopSequences,
+                        seed: params.subAgentConfig.seed,
+                    },
+                },
+            });
+            const updatedAssistantMessage = await this.messageRepository.update(assistantMessage.id, {
+                activity: parentActivity.id
+            });
+            const agentOptions = this.aiHelper.getAgentOptionsFromConfig(params.subAgentConfig, params.context);
+            agentOptions.onStepFinish = (stepResult) => {
+                return this.storeStepActivity({
+                    chat: params.parentChat,
+                    parentId: assistantMessage.activity,
+                    stepResult,
+                    name: ActivityOperationName.STEP_FINISHED,
+                    sourceId: assistantMessage.id,
+                    sourceType: 'AgentMessage',
+                    tenants: executionTenants,
+                });
+            };
+            const userPreferences = await this.agentConfigRepository.findByUserIdAndAgentName(childChat.userId, agentOptions.name);
+            agentOptions.activeTools = this.getAvailableTools(agentOptions, userPreferences);
+            await this.streamMessageStep({
+                chat: childChat,
+                existingMessages: [userMessage, updatedAssistantMessage],
+                assistantMessage: updatedAssistantMessage,
+                agentOptions,
+                signal: abortController.signal,
+                tenants: executionTenants,
+                executionContext: params.executionContext,
+                context: params.context,
+            });
+        }
+        catch (error) {
+            await this.storeSubagentResponse({
+                subagentChat: childChat,
+                content: undefined,
+                error: error,
+                context: params.context,
+                executionContext: params.executionContext,
+            });
+        }
+    }
     mergeMissingUsageFields(target, source) {
         for (const [key, sourceValue] of Object.entries(source)) {
             const targetValue = target[key];
@@ -121,8 +232,12 @@ export class ChatProcessor {
         }
     }
     async listChats(params) {
-        // Build filter object from params
-        const filter = {};
+        // Build filter object from params. Always exclude subagent chats:
+        // the repository translates ROOT into `sessionKind !== SUBAGENT`, which
+        // also includes legacy chats where the field is unset.
+        const filter = {
+            sessionKind: AgentSessionKind.ROOT
+        };
         if (params?.userId) {
             filter.userId = params.userId;
         }
@@ -171,15 +286,48 @@ export class ChatProcessor {
         return this.messageRepository.findByChatIdPaginated(chatId, options);
     }
     async deleteChat(chatId) {
+        // Collect all subagent descendants BEFORE removing the parent, otherwise the
+        // `parentChatId` link is severed and we'd orphan the subtree. Subagents can
+        // themselves spawn subagents, so traversal must be recursive.
+        const descendantIds = await this.collectDescendantChatIds(chatId);
         const deleted = await this.chatRepository.delete(chatId);
         if (!deleted) {
             throw new Error('Chat not found');
         }
+        // Delete descendant chat rows in parallel. Use `Promise.allSettled` so a
+        // missing/already-deleted descendant doesn't abort cleanup of the rest.
+        if (descendantIds.length > 0) {
+            await Promise.allSettled(descendantIds.map(id => this.chatRepository.delete(id)));
+        }
+        const allIds = [chatId, ...descendantIds];
         await Promise.all([
-            this.messageRepository.deleteByChatId(chatId),
-            this.activityRepository.deleteByGroupId(chatId), // todo: discuss if this is needed
+            ...allIds.map(id => this.messageRepository.deleteByChatId(id)),
+            ...allIds.map(id => this.activityRepository.deleteByGroupId(id)),
         ]);
-        this.artifactStore.deleteArtifacts(chatId);
+        for (const id of allIds) {
+            this.artifactStore.deleteArtifacts(id);
+        }
+    }
+    /**
+     * Walk the subagent tree rooted at `rootChatId` and return every descendant
+     * chat id (excluding the root itself). BFS, with parallel fan-out per level
+     * so deeply nested trees don't serialize one DB roundtrip per depth.
+     */
+    async collectDescendantChatIds(rootChatId) {
+        const descendants = [];
+        let frontier = [rootChatId];
+        while (frontier.length > 0) {
+            const childLists = await Promise.all(frontier.map(id => this.chatRepository.find({ parentChatId: id })));
+            const nextFrontier = [];
+            for (const list of childLists) {
+                for (const child of list) {
+                    descendants.push(child.id);
+                    nextFrontier.push(child.id);
+                }
+            }
+            frontier = nextFrontier;
+        }
+        return descendants;
     }
     async upsertAndGetChat(payload, excludeSocketId) {
         const targetUserId = payload.userId ?? 'guest';
@@ -242,6 +390,7 @@ export class ChatProcessor {
             title: this.getTemporaryTitle(contextKey),
             type: ChatType.Chat,
             status: AgentStatus.Streaming,
+            sessionKind: AgentSessionKind.ROOT,
             contextKey,
             userId: targetUserId,
             metadata,
@@ -313,8 +462,11 @@ export class ChatProcessor {
      * Update selected fields (input/output/status) on a specific tool call.
      */
     async updateToolCall(params) {
-        if (params.input === undefined && params.output === undefined && params.status === undefined) {
-            throw new Error('At least one of input, output, or status must be provided');
+        if (params.input === undefined &&
+            params.output === undefined &&
+            params.status === undefined &&
+            params.subagentChatId === undefined) {
+            throw new Error('At least one tool call update field must be provided');
         }
         const chat = await this.chatRepository.findById(params.chatId);
         if (!chat) {
@@ -342,6 +494,7 @@ export class ChatProcessor {
             ...(params.input !== undefined ? { input: params.input } : {}),
             ...(params.output !== undefined ? { output: params.output } : {}),
             ...(params.status !== undefined ? { status: params.status } : {}),
+            ...(params.subagentChatId !== undefined ? { subagentChatId: params.subagentChatId } : {}),
         });
         if (!updatedMessage) {
             throw new Error('Tool call not found in message');
@@ -351,8 +504,80 @@ export class ChatProcessor {
         this.socketService.emitMessageUpdate(chat.userId, updatedMessage, params.excludeSocketId);
         return updatedMessage;
     }
+    async storeSubagentResponse(params) {
+        const { subagentChat, content, error, context, executionContext } = params;
+        if (!subagentChat.parentChatId || !subagentChat.parentMessageId) {
+            throw new Error(`Parent chat or message not found for subagent ${subagentChat.id}`);
+        }
+        const chat = await this.chatRepository.findById(subagentChat.parentChatId);
+        if (!chat) {
+            throw new Error(`Parent chat not found for subagent ${subagentChat.id}`);
+        }
+        const assistantMessage = await this.messageRepository.findById(subagentChat.parentMessageId);
+        if (!assistantMessage || assistantMessage.chat !== subagentChat.parentChatId) {
+            throw new Error(`Assistant message with id ${subagentChat.parentMessageId} not found`);
+        }
+        const toolCall = assistantMessage.toolCalls?.find(tc => tc.id === subagentChat.parentToolCallId);
+        if (!toolCall) {
+            throw new Error(`Tool call with id ${subagentChat.parentToolCallId} not found`);
+        }
+        if (error) {
+            toolCall.output = {
+                type: 'error',
+                message: error,
+            };
+            toolCall.status = AgentToolCallStatus.Failed;
+        }
+        else {
+            toolCall.output = content;
+            toolCall.status = AgentToolCallStatus.Succeeded;
+        }
+        await this.messageRepository.update(assistantMessage.id, assistantMessage);
+        const agentOptions = await this.aiHelper.getAgentOptions({
+            agentName: assistantMessage.agentName,
+            context: context,
+            executionContext: executionContext,
+        });
+        const executionTenants = this.getExecutionTenants(params);
+        const abortController = this.agentStore.registerAgentProcess(chat.id);
+        const existingMessages = await this.messageRepository.findByChatId(chat.id);
+        // Limit context to prevent exceeding token limits
+        const limitedMessages = ContextLimiter.limitContext(existingMessages, {
+            maxMessages: this.config.ai.maxContextMessages,
+            keepFirstUserMessage: true,
+            keepSystemMessages: true,
+        });
+        agentOptions.onStepFinish = (stepResult) => {
+            return this.storeStepActivity({
+                chat,
+                parentId: assistantMessage.activity,
+                stepResult,
+                name: ActivityOperationName.STEP_FINISHED,
+                sourceId: assistantMessage.id,
+                sourceType: 'AgentMessage',
+                tenants: executionTenants,
+            });
+        };
+        const userPreferences = await this.agentConfigRepository.findByUserIdAndAgentName(chat.userId, agentOptions.name);
+        agentOptions.activeTools = this.getAvailableTools(agentOptions, userPreferences);
+        await this.streamMessageStep({
+            chat,
+            existingMessages: limitedMessages,
+            assistantMessage,
+            agentOptions,
+            signal: abortController.signal,
+            tenants: executionTenants,
+            executionContext,
+            context,
+        });
+    }
     async streamMessageStep(params) {
         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);
+            await this.agentStore.shareAgentProcessEvent(chat.id, { type: AgentProcessEventType.Update, data: assistantMessage });
+        };
         if (signal.aborted) {
             return;
         }
@@ -366,12 +591,21 @@ export class ChatProcessor {
                     await this.agentStore.shareAgentProcessEvent(chat.id, { type: AgentProcessEventType.Error, data: chunk.error });
                     assistantMessage.content = chunk.error.message || 'Sorry, I cannot process you request due to the error';
                     await this.messageRepository.update(assistantMessage.id, assistantMessage);
-                    await this.chatRepository.update(chat.id, { status: AgentStatus.Error });
+                    await this.updateChatAndEmit(chat, { status: AgentStatus.Error }, excludeSocketId);
+                    if (chat.sessionKind === AgentSessionKind.SUBAGENT) {
+                        await this.storeSubagentResponse({
+                            subagentChat: chat,
+                            content: undefined,
+                            error: chunk.error,
+                            context: params.context,
+                            executionContext: params.executionContext,
+                        });
+                    }
                     continue;
                 }
                 if (chunk.type === 'abort') {
                     await this.agentStore.shareAgentProcessEvent(chat.id, { type: AgentProcessEventType.Aborted, data: undefined });
-                    await this.chatRepository.update(chat.id, { status: AgentStatus.Aborted });
+                    await this.updateChatAndEmit(chat, { status: AgentStatus.Aborted }, excludeSocketId);
                     await this.messageRepository.update(assistantMessage.id, assistantMessage);
                     this.socketService.emitMessageUpdate(chat.userId, assistantMessage, excludeSocketId);
                     continue;
@@ -390,8 +624,9 @@ export class ChatProcessor {
                             ((totalUsage.promptTokens ?? 0) + (totalUsage.completionTokens ?? 0));
                     }
                     await this.messageRepository.update(assistantMessage.id, { ...assistantMessage });
+                    this.socketService.emitMessageUpdate(chat.userId, assistantMessage, excludeSocketId);
                     if (chunk.finishReason === 'stop') {
-                        await this.chatRepository.update(chat.id, { status: AgentStatus.Finished });
+                        let nextChat = await this.updateChatAndEmit(chat, { status: AgentStatus.Finished }, excludeSocketId);
                         if (chat.title && this.isTemporaryTitle(chat.title)) {
                             const title = await this.aiHelper.generateTitleForMessage(chat.contextKey, existingMessages.filter(m => m.role === MessageRole.User), (stepResult) => {
                                 return this.storeStepActivity({
@@ -403,16 +638,51 @@ export class ChatProcessor {
                                     tenants: params.tenants || {},
                                 });
                             }, params.executionContext);
-                            await this.chatRepository.update(chat.id, { title });
-                            this.socketService.emitChatUpdate(chat.userId, { ...chat, title });
+                            nextChat = await this.updateChatAndEmit(nextChat, { title }, excludeSocketId);
+                        }
+                        if (chat.sessionKind === AgentSessionKind.SUBAGENT) {
+                            await this.storeSubagentResponse({
+                                subagentChat: chat,
+                                content: assistantMessage.content,
+                                error: undefined,
+                                context: params.context,
+                                executionContext: params.executionContext,
+                            });
                         }
                     }
                     if (chunk.finishReason === 'tool-calls') {
-                        if (assistantMessage.toolCalls?.some(toolCall => toolCall.requiresConfirmation && toolCall.approvalId && !toolCall.output)) {
-                            await this.chatRepository.update(chat.id, { status: AgentStatus.WaitingForUserAction });
+                        const toolCall = assistantMessage.toolCalls?.find(toolCall => toolCall.output === undefined && toolCall.status === AgentToolCallStatus.Running);
+                        if (!toolCall) {
                             await this.agentStore.shareAgentProcessEvent(chat.id, { type: AgentProcessEventType.Finished, data: assistantMessage });
+                            await this.storeSubagentResponse({
+                                subagentChat: chat,
+                                content: JSON.stringify(assistantMessage.toolCalls),
+                                error: undefined,
+                                context: params.context,
+                                executionContext: params.executionContext,
+                            });
                             continue;
                         }
+                        const toolConfig = ConfigStore.getInstance().getToolConfig(assistantMessage.agentName || '', toolCall.name);
+                        if (toolCall.requiresConfirmation && toolCall.approvalId) {
+                            await this.updateChatAndEmit(chat, { status: AgentStatus.WaitingForUserAction }, excludeSocketId);
+                            await this.agentStore.shareAgentProcessEvent(chat.id, { type: AgentProcessEventType.Finished, data: assistantMessage });
+                        }
+                        else if (toolConfig && toolConfig.type === AgentToolType.SUBAGENT) {
+                            void this.startSubagentProcess({
+                                parentChat: chat,
+                                parentMessage: assistantMessage,
+                                parentToolCallId: toolCall.id,
+                                toolName: toolCall.name,
+                                input: toolCall.input,
+                                subAgentConfig: toolConfig.data.subAgent,
+                                context: params.context,
+                                executionContext: params.executionContext,
+                            }).catch(error => {
+                                logger.error(error);
+                                //todo: store error in response
+                            });
+                        }
                     }
                     //todo: Handle other finish reasons // length, content, error, other, undefined
                     await this.agentStore.shareAgentProcessEvent(chat.id, { type: AgentProcessEventType.Finished, data: assistantMessage });
@@ -440,20 +710,43 @@ export class ChatProcessor {
                 if (chunk.type === 'tool-input-start') {
                     if (!assistantMessage.toolCalls)
                         assistantMessage.toolCalls = [];
-                    assistantMessage.toolCalls.push({
-                        id: chunk.id,
-                        name: chunk.toolName,
-                        status: AgentToolCallStatus.Pending,
-                        input: {},
-                    });
+                    const existingToolCall = assistantMessage.toolCalls.find((toolCall) => toolCall.id === chunk.id);
+                    if (existingToolCall) {
+                        existingToolCall.name = chunk.toolName;
+                        if (!existingToolCall.status) {
+                            existingToolCall.status = AgentToolCallStatus.Pending;
+                        }
+                        existingToolCall.input = existingToolCall.input ?? {};
+                    }
+                    else {
+                        assistantMessage.toolCalls.push({
+                            id: chunk.id,
+                            name: chunk.toolName,
+                            status: AgentToolCallStatus.Pending,
+                            input: {},
+                        });
+                    }
+                    await persistAndBroadcastToolCalls();
                     continue;
                 }
                 if (chunk.type === 'tool-call') {
-                    const toolCall = assistantMessage.toolCalls?.find(toolCall => toolCall.id === chunk.toolCallId);
-                    if (toolCall) {
+                    if (!assistantMessage.toolCalls)
+                        assistantMessage.toolCalls = [];
+                    let toolCall = assistantMessage.toolCalls.find(toolCall => toolCall.id === chunk.toolCallId);
+                    if (!toolCall) {
+                        toolCall = {
+                            id: chunk.toolCallId,
+                            name: chunk.toolName,
+                            status: AgentToolCallStatus.Running,
+                            input: chunk.input,
+                        };
+                        assistantMessage.toolCalls.push(toolCall);
+                    }
+                    else {
                         toolCall.status = AgentToolCallStatus.Running;
                         toolCall.input = chunk.input;
                     }
+                    await persistAndBroadcastToolCalls();
                     continue;
                 }
                 if (chunk.type === 'tool-error') {
@@ -461,29 +754,33 @@ export class ChatProcessor {
                     if (toolCall) {
                         toolCall.status = AgentToolCallStatus.Failed;
                         toolCall.error = chunk.error.message || JSON.stringify(chunk.error);
+                        await persistAndBroadcastToolCalls();
                     }
                     continue;
                 }
                 if (chunk.type === 'tool-approval-request') {
                     const toolCall = assistantMessage.toolCalls?.find(toolCall => toolCall.id === chunk.toolCall.toolCallId);
                     if (toolCall) {
+                        const toolConfig = ConfigStore.getInstance().getToolConfig(assistantMessage.agentName || '', toolCall.name);
+                        if (toolConfig && toolConfig.type === AgentToolType.SUBAGENT) {
+                            // TODO: allow needsApproval flow for the subagents too
+                            continue;
+                        }
                         toolCall.requiresConfirmation = true;
                         toolCall.approvalId = chunk.approvalId;
                         if (toolCall.name === AgentToolType.REQUEST_CLARIFICATION) {
                             toolCall.requiresUserAction = true;
                         }
+                        await persistAndBroadcastToolCalls();
                     }
                     continue;
                 }
                 if (chunk.type === 'tool-result') {
                     const toolCall = assistantMessage.toolCalls?.find(toolCall => toolCall.id === chunk.toolCallId);
                     if (toolCall) {
-                        if (chunk.output?.requiresApproval) {
-                            toolCall.requiresConfirmation = true;
-                            continue;
-                        }
                         toolCall.status = AgentToolCallStatus.Succeeded;
                         toolCall.output = chunk.output;
+                        await persistAndBroadcastToolCalls();
                     }
                     continue;
                 }
@@ -719,6 +1016,7 @@ export class ChatProcessor {
                 signal: abortController.signal,
                 tenants: executionTenants,
                 executionContext: payload.executionContext,
+                context: payload.context,
             });
         }
         catch (error) {
@@ -730,7 +1028,7 @@ export class ChatProcessor {
         const availableToolsMap = Object.fromEntries(toolNames.map(key => [key, true]));
         const agentsConfiguration = ConfigStore.getInstance().getAgentConfigByName(agentOptions.name);
         agentsConfiguration.tools.forEach((tool) => {
-            const toolTitle = tool.data?.title || tool.type;
+            const toolTitle = getAgentToolName(tool);
             if (tool.disabledByDefault) {
                 availableToolsMap[toolTitle] = false;
             }