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

package/dist/cjs/processors/ChatProcessor.cjs

@@ -3,12 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ChatProcessor = void 0;
 const ai_agent_types_1 = require("@multiplayer-app/ai-agent-types");
 const zod_1 = require("zod");
-const helpers_1 = require("../helpers/index.cjs");
 const store_1 = require("../store/index.cjs");
-const helpers_2 = require("../helpers/index.cjs");
+const helpers_1 = require("../helpers/index.cjs");
 const stream_1 = require("stream");
 const logger_1 = require("../libs/logger/index.cjs");
-const store_2 = require("../store/index.cjs");
+const ai_agent_types_2 = require("@multiplayer-app/ai-agent-types");
+const utils_1 = require("../utils/utils.cjs");
 class ChatProcessor {
     constructor(params) {
         this.chatRepository = params.chatRepository;
@@ -43,6 +43,117 @@ 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: ai_agent_types_1.ChatType.Agent,
+            status: ai_agent_types_1.AgentStatus.Streaming,
+            sessionKind: ai_agent_types_2.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, ai_agent_types_1.MessageRole.User, {
+                content: JSON.stringify(params.input),
+                agentName: undefined
+            });
+            await this.agentStore.shareAgentProcessEvent(childChat.id, {
+                type: store_1.AgentProcessEventType.Update,
+                data: userMessage
+            });
+            let assistantMessage = await this.createMessage(childChat, ai_agent_types_1.MessageRole.Assistant, {
+                content: '',
+                agentName: params.subAgentConfig.name
+            });
+            const parentActivity = await this.activityRepository.create({
+                ownerId: params.parentChat.userId,
+                groupId: params.parentChat.id,
+                name: ai_agent_types_1.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: ai_agent_types_1.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];
@@ -114,8 +225,12 @@ 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: ai_agent_types_2.AgentSessionKind.ROOT
+        };
         if (params?.userId) {
             filter.userId = params.userId;
         }
@@ -164,15 +279,48 @@ 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';
@@ -235,6 +383,7 @@ class ChatProcessor {
             title: this.getTemporaryTitle(contextKey),
             type: ai_agent_types_1.ChatType.Chat,
             status: ai_agent_types_1.AgentStatus.Streaming,
+            sessionKind: ai_agent_types_2.AgentSessionKind.ROOT,
             contextKey,
             userId: targetUserId,
             metadata,
@@ -306,8 +455,11 @@ 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) {
@@ -335,6 +487,7 @@ 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');
@@ -344,8 +497,80 @@ 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 = ai_agent_types_1.AgentToolCallStatus.Failed;
+        }
+        else {
+            toolCall.output = content;
+            toolCall.status = ai_agent_types_1.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 = helpers_1.ContextLimiter.limitContext(existingMessages, {
+            maxMessages: this.config.ai.maxContextMessages,
+            keepFirstUserMessage: true,
+            keepSystemMessages: true,
+        });
+        agentOptions.onStepFinish = (stepResult) => {
+            return this.storeStepActivity({
+                chat,
+                parentId: assistantMessage.activity,
+                stepResult,
+                name: ai_agent_types_1.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: store_1.AgentProcessEventType.Update, data: assistantMessage });
+        };
         if (signal.aborted) {
             return;
         }
@@ -359,12 +584,21 @@ class ChatProcessor {
                     await this.agentStore.shareAgentProcessEvent(chat.id, { type: store_1.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: ai_agent_types_1.AgentStatus.Error });
+                    await this.updateChatAndEmit(chat, { status: ai_agent_types_1.AgentStatus.Error }, excludeSocketId);
+                    if (chat.sessionKind === ai_agent_types_2.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: store_1.AgentProcessEventType.Aborted, data: undefined });
-                    await this.chatRepository.update(chat.id, { status: ai_agent_types_1.AgentStatus.Aborted });
+                    await this.updateChatAndEmit(chat, { status: ai_agent_types_1.AgentStatus.Aborted }, excludeSocketId);
                     await this.messageRepository.update(assistantMessage.id, assistantMessage);
                     this.socketService.emitMessageUpdate(chat.userId, assistantMessage, excludeSocketId);
                     continue;
@@ -383,8 +617,9 @@ 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: ai_agent_types_1.AgentStatus.Finished });
+                        let nextChat = await this.updateChatAndEmit(chat, { status: ai_agent_types_1.AgentStatus.Finished }, excludeSocketId);
                         if (chat.title && this.isTemporaryTitle(chat.title)) {
                             const title = await this.aiHelper.generateTitleForMessage(chat.contextKey, existingMessages.filter(m => m.role === ai_agent_types_1.MessageRole.User), (stepResult) => {
                                 return this.storeStepActivity({
@@ -396,16 +631,51 @@ 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 === ai_agent_types_2.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: ai_agent_types_1.AgentStatus.WaitingForUserAction });
+                        const toolCall = assistantMessage.toolCalls?.find(toolCall => toolCall.output === undefined && toolCall.status === ai_agent_types_1.AgentToolCallStatus.Running);
+                        if (!toolCall) {
                             await this.agentStore.shareAgentProcessEvent(chat.id, { type: store_1.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 = store_1.ConfigStore.getInstance().getToolConfig(assistantMessage.agentName || '', toolCall.name);
+                        if (toolCall.requiresConfirmation && toolCall.approvalId) {
+                            await this.updateChatAndEmit(chat, { status: ai_agent_types_1.AgentStatus.WaitingForUserAction }, excludeSocketId);
+                            await this.agentStore.shareAgentProcessEvent(chat.id, { type: store_1.AgentProcessEventType.Finished, data: assistantMessage });
+                        }
+                        else if (toolConfig && toolConfig.type === ai_agent_types_1.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_1.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: store_1.AgentProcessEventType.Finished, data: assistantMessage });
@@ -433,20 +703,43 @@ class ChatProcessor {
                 if (chunk.type === 'tool-input-start') {
                     if (!assistantMessage.toolCalls)
                         assistantMessage.toolCalls = [];
-                    assistantMessage.toolCalls.push({
-                        id: chunk.id,
-                        name: chunk.toolName,
-                        status: ai_agent_types_1.AgentToolCallStatus.Pending,
-                        input: {},
-                    });
+                    const existingToolCall = assistantMessage.toolCalls.find((toolCall) => toolCall.id === chunk.id);
+                    if (existingToolCall) {
+                        existingToolCall.name = chunk.toolName;
+                        if (!existingToolCall.status) {
+                            existingToolCall.status = ai_agent_types_1.AgentToolCallStatus.Pending;
+                        }
+                        existingToolCall.input = existingToolCall.input ?? {};
+                    }
+                    else {
+                        assistantMessage.toolCalls.push({
+                            id: chunk.id,
+                            name: chunk.toolName,
+                            status: ai_agent_types_1.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: ai_agent_types_1.AgentToolCallStatus.Running,
+                            input: chunk.input,
+                        };
+                        assistantMessage.toolCalls.push(toolCall);
+                    }
+                    else {
                         toolCall.status = ai_agent_types_1.AgentToolCallStatus.Running;
                         toolCall.input = chunk.input;
                     }
+                    await persistAndBroadcastToolCalls();
                     continue;
                 }
                 if (chunk.type === 'tool-error') {
@@ -454,29 +747,33 @@ class ChatProcessor {
                     if (toolCall) {
                         toolCall.status = ai_agent_types_1.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 = store_1.ConfigStore.getInstance().getToolConfig(assistantMessage.agentName || '', toolCall.name);
+                        if (toolConfig && toolConfig.type === ai_agent_types_1.AgentToolType.SUBAGENT) {
+                            // TODO: allow needsApproval flow for the subagents too
+                            continue;
+                        }
                         toolCall.requiresConfirmation = true;
                         toolCall.approvalId = chunk.approvalId;
                         if (toolCall.name === ai_agent_types_1.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 = ai_agent_types_1.AgentToolCallStatus.Succeeded;
                         toolCall.output = chunk.output;
+                        await persistAndBroadcastToolCalls();
                     }
                     continue;
                 }
@@ -667,7 +964,7 @@ class ChatProcessor {
             let agentOptions;
             const existingMessages = await this.messageRepository.findByChatId(chat.id);
             // Limit context to prevent exceeding token limits
-            const limitedMessages = helpers_2.ContextLimiter.limitContext(existingMessages, {
+            const limitedMessages = helpers_1.ContextLimiter.limitContext(existingMessages, {
                 maxMessages: this.config.ai.maxContextMessages,
                 keepFirstUserMessage: true,
                 keepSystemMessages: true,
@@ -712,6 +1009,7 @@ class ChatProcessor {
                 signal: abortController.signal,
                 tenants: executionTenants,
                 executionContext: payload.executionContext,
+                context: payload.context,
             });
         }
         catch (error) {
@@ -721,9 +1019,9 @@ class ChatProcessor {
     getAvailableTools(agentOptions, userPreferences) {
         const toolNames = Object.keys(agentOptions.tools || {});
         const availableToolsMap = Object.fromEntries(toolNames.map(key => [key, true]));
-        const agentsConfiguration = store_2.ConfigStore.getInstance().getAgentConfigByName(agentOptions.name);
+        const agentsConfiguration = store_1.ConfigStore.getInstance().getAgentConfigByName(agentOptions.name);
         agentsConfiguration.tools.forEach((tool) => {
-            const toolTitle = tool.data?.title || tool.type;
+            const toolTitle = (0, utils_1.getAgentToolName)(tool);
             if (tool.disabledByDefault) {
                 availableToolsMap[toolTitle] = false;
             }