@multiplayer-app/ai-agent-node 0.1.0-beta.5 → 0.1.0-beta.50

package/dist/esm/processors/ChatProcessor.js

@@ -1,26 +1,118 @@
-import { AgentStatus, AgentToolCallStatus, ChatType, MessageRole, SortOrder, StreamChunkType } from '@multiplayer-app/ai-agent-types';
-import { socketService } from '../services';
-import { kafkaService } from '../services';
-import { AIHelper } from '../helpers';
-import { AgentProcessEventType, agentStore } from '../store';
+import { AgentStatus, AgentToolCallStatus, ChatType, MessageRole, SortOrder, StreamChunkType, ActivityOperationName, AgentToolType } from '@multiplayer-app/ai-agent-types';
+import { z } from 'zod';
+import { AIHelper, FileHelper } from '../helpers';
+import { AgentProcessEventType } from '../store';
 import { ContextLimiter } from '../helpers';
-import { config } from '../config';
-import { PassThrough, pipeline } from 'stream';
-import { promisify } from 'util';
+import { PassThrough } from 'stream';
 import { logger } from '../libs/logger';
-const pipelineAsync = promisify(pipeline);
+import { ConfigStore } from '../store';
 export class ChatProcessor {
+    aiHelper;
     chatRepository;
     messageRepository;
     artifactStore;
-    constructor(chatRepository, messageRepository, artifactStore) {
-        this.chatRepository = chatRepository;
-        this.messageRepository = messageRepository;
-        this.artifactStore = artifactStore;
+    activityRepository;
+    agentConfigRepository;
+    config;
+    socketService;
+    agentStore;
+    debug;
+    constructor(params) {
+        this.chatRepository = params.chatRepository;
+        this.messageRepository = params.messageRepository;
+        this.artifactStore = params.artifactStore;
+        this.config = params.config;
+        this.socketService = params.socketService;
+        this.agentStore = params.agentStore;
+        this.activityRepository = params.activityRepository;
+        this.agentConfigRepository = params.agentConfigRepository;
+        const fileHelper = new FileHelper(params.s3Lib, this.config);
+        this.aiHelper = new AIHelper(fileHelper, this.config);
+        this.debug = this.config.debug;
     }
     getTemporaryTitle(contextKey) {
         return `${contextKey} session ${new Date().toISOString()}`;
     }
+    isTemporaryTitle(title) {
+        // Matches pattern: "{contextKey} session {ISO_DATE_STRING}"
+        // Example: "default session 2026-01-23T10:30:45.123Z"
+        // toISOString() always includes milliseconds, so we require them
+        const pattern = /^.+ session \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/;
+        return pattern.test(title);
+    }
+    isPlainObject(value) {
+        return !!value && typeof value === 'object' && !Array.isArray(value);
+    }
+    mergeMissingUsageFields(target, source) {
+        for (const [key, sourceValue] of Object.entries(source)) {
+            const targetValue = target[key];
+            if (targetValue === undefined) {
+                target[key] = sourceValue;
+                continue;
+            }
+            if (this.isPlainObject(targetValue) && this.isPlainObject(sourceValue)) {
+                this.mergeMissingUsageFields(targetValue, sourceValue);
+            }
+        }
+    }
+    extractCostUsageFields(source) {
+        const extracted = {};
+        for (const [key, value] of Object.entries(source)) {
+            const normalizedKey = key.toLowerCase();
+            if (normalizedKey.includes('cost')) {
+                extracted[key] = value;
+                continue;
+            }
+            if (this.isPlainObject(value)) {
+                const nestedCostFields = this.extractCostUsageFields(value);
+                if (Object.keys(nestedCostFields).length > 0) {
+                    extracted[key] = nestedCostFields;
+                }
+            }
+        }
+        return extracted;
+    }
+    mergeUsageWithProviderMetadata(stepUsage, providerMetadata) {
+        const mergedUsage = this.isPlainObject(stepUsage) ? { ...stepUsage } : {};
+        let hasProviderUsage = false;
+        if (this.isPlainObject(providerMetadata)) {
+            for (const providerEntry of Object.values(providerMetadata)) {
+                if (!this.isPlainObject(providerEntry) || !this.isPlainObject(providerEntry.usage)) {
+                    continue;
+                }
+                const providerCostUsage = this.extractCostUsageFields(providerEntry.usage);
+                if (Object.keys(providerCostUsage).length === 0) {
+                    continue;
+                }
+                hasProviderUsage = true;
+                this.mergeMissingUsageFields(mergedUsage, providerCostUsage);
+            }
+        }
+        if (this.isPlainObject(stepUsage)) {
+            return mergedUsage;
+        }
+        if (hasProviderUsage) {
+            return mergedUsage;
+        }
+        return stepUsage;
+    }
+    async validateToolCallInput(params) {
+        const agentOptions = await this.aiHelper.getAgentOptions({
+            agentName: params.agentName,
+        });
+        const tool = agentOptions.tools?.[params.toolName] ?? undefined;
+        const schema = tool?.inputSchema;
+        if (!schema) {
+            throw new Error(`Tool "${params.toolName}" schema not found`);
+        }
+        if (!(schema instanceof z.ZodType)) {
+            throw new Error(`Tool "${params.toolName}" inputSchema must be a Zod schema`);
+        }
+        const result = schema.safeParse(params.input);
+        if (!result.success) {
+            throw new Error(`Invalid tool input for "${params.toolName}": ${result.error.message}`);
+        }
+    }
     async listChats(params) {
         // Build filter object from params
         const filter = {};
@@ -30,33 +122,56 @@ export class ChatProcessor {
         if (params?.contextKey) {
             filter.contextKey = params.contextKey;
         }
-        // Build query options for sort and limit with defaults
+        // Build query options for sort and limit with defaults.
         const options = {
             sort: {
                 field: params?.sortField ?? 'updatedAt',
                 order: params?.sortOrder ?? SortOrder.Desc
             },
+            skip: params?.skip,
             limit: params?.limit
         };
-        // Use aggregation to fetch chats with related messages
-        return this.chatRepository.findWithMessages(filter, options);
+        const [total, data] = await Promise.all([
+            this.chatRepository.count(filter),
+            this.chatRepository.find(filter, options)
+        ]);
+        return {
+            cursor: {
+                ...(params?.skip != null ? { skip: params.skip } : {}),
+                ...(params?.limit != null ? { limit: params.limit } : {}),
+                total
+            },
+            data
+        };
     }
     async getChat(chatId) {
         const chat = await this.chatRepository.findById(chatId);
         if (!chat) {
             throw new Error('Chat not found');
         }
-        const messages = await this.messageRepository.findByChatId(chatId);
-        return {
-            ...chat,
-            messages
-        };
+        return chat;
+    }
+    /**
+     * Get messages for a chat with optional cursor pagination.
+     * When limit is omitted, returns all messages (backward compatible).
+     * Messages are returned in chronological order (oldest → newest).
+     */
+    async getMessages(chatId, options) {
+        const chat = await this.chatRepository.findById(chatId);
+        if (!chat) {
+            throw new Error('Chat not found');
+        }
+        return this.messageRepository.findByChatIdPaginated(chatId, options);
     }
     async deleteChat(chatId) {
         const deleted = await this.chatRepository.delete(chatId);
         if (!deleted) {
             throw new Error('Chat not found');
         }
+        await Promise.all([
+            this.messageRepository.deleteByChatId(chatId),
+            this.activityRepository.deleteByGroupId(chatId), // todo: discuss if this is needed
+        ]);
         this.artifactStore.deleteArtifacts(chatId);
     }
     async upsertAndGetChat(payload, excludeSocketId) {
@@ -92,7 +207,7 @@ export class ChatProcessor {
         if (!content) {
             return this.getTemporaryTitle(payload.contextKey);
         }
-        return AIHelper.generateTitleForMessage(payload.contextKey, [{
+        return this.aiHelper.generateTitleForMessage(payload.contextKey, [{
                 role: MessageRole.User,
                 content: content
             }]);
@@ -108,7 +223,7 @@ export class ChatProcessor {
             toolCalls: []
         });
         if (chat.userId) {
-            socketService.emitMessageUpdate(chat.userId, message, excludeSocketId);
+            this.socketService.emitMessageUpdate(chat.userId, message, excludeSocketId);
         }
         return message;
     }
@@ -125,12 +240,7 @@ export class ChatProcessor {
             metadata,
             ...(payload.model ? { model: payload.model } : {})
         });
-        await kafkaService.sendChatTitleGenerationEvent(chat.id);
-        const initialChatResponse = {
-            ...chat,
-            messages: []
-        };
-        socketService.emitChatUpdate(targetUserId, initialChatResponse, excludeSocketId);
+        this.socketService.emitChatUpdate(targetUserId, chat, excludeSocketId);
         return chat;
     }
     /**
@@ -185,33 +295,75 @@ 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 });
-        socketService.emitMessageUpdate(chat.userId, updatedMessage, params.excludeSocketId);
+        this.socketService.emitMessageUpdate(chat.userId, updatedMessage, params.excludeSocketId);
         if (params.systemMessage) {
             //todo discuss support for system messages
             //await this.createMessage(chat, MessageRole.System, params.systemMessage, undefined, params.excludeSocketId);
         }
         return { ok: true };
     }
+    /**
+     * 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');
+        }
+        const chat = await this.chatRepository.findById(params.chatId);
+        if (!chat) {
+            throw new Error('Chat not found');
+        }
+        if (params.userId && chat.userId !== params.userId) {
+            throw new Error('Chat does not belong to this user');
+        }
+        const message = await this.messageRepository.findById(params.messageId);
+        if (!message || message.chat !== params.chatId) {
+            throw new Error('Message not found or does not belong to this chat');
+        }
+        const targetToolCall = (message.toolCalls ?? []).find((tc) => tc.id === params.toolCallId);
+        if (!targetToolCall) {
+            throw new Error('Tool call not found in message');
+        }
+        if (params.input !== undefined) {
+            await this.validateToolCallInput({
+                agentName: message.agentName,
+                toolName: targetToolCall.name,
+                input: params.input,
+            });
+        }
+        const updatedMessage = await this.messageRepository.updateToolCall(params.messageId, params.toolCallId, {
+            ...(params.input !== undefined ? { input: params.input } : {}),
+            ...(params.output !== undefined ? { output: params.output } : {}),
+            ...(params.status !== undefined ? { status: params.status } : {}),
+        });
+        if (!updatedMessage) {
+            throw new Error('Tool call not found in message');
+        }
+        const now = new Date().toISOString();
+        await this.chatRepository.update(chat.id, { updatedAt: now });
+        this.socketService.emitMessageUpdate(chat.userId, updatedMessage, params.excludeSocketId);
+        return updatedMessage;
+    }
     async streamMessageStep(params) {
         const { chat, assistantMessage, existingMessages, signal, excludeSocketId, agentOptions } = params;
         if (signal.aborted) {
             return;
         }
-        const result = await AIHelper.streamAssistantResponse(existingMessages, signal, agentOptions);
+        const result = await this.aiHelper.streamAssistantResponse(existingMessages, signal, agentOptions);
         try {
             for await (const chunk of result.fullStream) {
                 if (chunk.type === 'error') {
-                    await agentStore.shareAgentProcessEvent(chat.id, { type: AgentProcessEventType.Error, data: chunk.error });
+                    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 });
                     continue;
                 }
                 if (chunk.type === 'abort') {
-                    await agentStore.shareAgentProcessEvent(chat.id, { type: AgentProcessEventType.Aborted, data: undefined });
+                    await this.agentStore.shareAgentProcessEvent(chat.id, { type: AgentProcessEventType.Aborted, data: undefined });
                     await this.chatRepository.update(chat.id, { status: AgentStatus.Aborted });
                     await this.messageRepository.update(assistantMessage.id, assistantMessage);
-                    socketService.emitMessageUpdate(chat.userId, assistantMessage, excludeSocketId);
+                    this.socketService.emitMessageUpdate(chat.userId, assistantMessage, excludeSocketId);
                     continue;
                 }
                 if (chunk.type === 'finish') {
@@ -229,37 +381,39 @@ export class ChatProcessor {
                     }
                     await this.messageRepository.update(assistantMessage.id, { ...assistantMessage });
                     if (chunk.finishReason === 'stop') {
-                        if (assistantMessage.toolCalls?.some(toolCall => toolCall.requiresConfirmation && toolCall.approvalId && !toolCall.output)) {
-                            await this.chatRepository.update(chat.id, { status: AgentStatus.WaitingForUserAction });
-                        }
-                        else if (!assistantMessage.content && assistantMessage.toolCalls?.length && assistantMessage.toolCalls[assistantMessage.toolCalls?.length - 1].output) {
-                            // handle tool-calls stop, openrouter provider does not return valid type
-                            await agentStore.shareAgentProcessEvent(chat.id, { type: AgentProcessEventType.Update, data: assistantMessage });
-                            await this.streamMessageStep(params);
-                            continue;
-                        }
-                        else {
-                            await this.chatRepository.update(chat.id, { status: AgentStatus.Finished });
+                        await this.chatRepository.update(chat.id, { status: AgentStatus.Finished });
+                        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({
+                                    chat,
+                                    stepResult,
+                                    name: ActivityOperationName.TITLE_GENERATION,
+                                    sourceId: chat.id,
+                                    sourceType: 'Chat',
+                                    tenants: params.tenants || {},
+                                });
+                            });
+                            await this.chatRepository.update(chat.id, { title });
+                            this.socketService.emitChatUpdate(chat.userId, { ...chat, title });
                         }
-                        await agentStore.shareAgentProcessEvent(chat.id, { type: AgentProcessEventType.Finished, data: assistantMessage });
-                        continue;
                     }
                     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 });
-                            await agentStore.shareAgentProcessEvent(chat.id, { type: AgentProcessEventType.Finished, data: assistantMessage });
-                        }
-                        else {
-                            await agentStore.shareAgentProcessEvent(chat.id, {
-                                type: AgentProcessEventType.Update,
-                                data: assistantMessage
-                            });
-                            await this.streamMessageStep(params);
+                            await this.agentStore.shareAgentProcessEvent(chat.id, { type: AgentProcessEventType.Finished, data: assistantMessage });
+                            continue;
                         }
-                        continue;
                     }
                     //todo: Handle other finish reasons // length, content, error, other, undefined
-                    await agentStore.shareAgentProcessEvent(chat.id, { type: AgentProcessEventType.Finished, data: assistantMessage });
+                    await this.agentStore.shareAgentProcessEvent(chat.id, { type: AgentProcessEventType.Finished, data: assistantMessage });
+                    if (assistantMessage.activity) {
+                        const groupedMeta = await this.activityRepository.getGroupedMetadataByParentId(assistantMessage.activity);
+                        await this.activityRepository.updateMetadata(assistantMessage.activity, {
+                            usage: groupedMeta,
+                            finishReason: chunk.finishReason,
+                            responseTimestamp: new Date().toISOString(),
+                        });
+                    }
                     continue;
                 }
                 if (chunk.type === 'text-delta') {
@@ -268,8 +422,8 @@ export class ChatProcessor {
                         ...assistantMessage,
                         content: assistantMessage.content
                     };
-                    socketService.emitMessageUpdate(chat.userId, updatedMessage, excludeSocketId);
-                    await agentStore.shareAgentProcessEvent(chat.id, { type: AgentProcessEventType.Update, data: updatedMessage });
+                    this.socketService.emitMessageUpdate(chat.userId, updatedMessage, excludeSocketId);
+                    await this.agentStore.shareAgentProcessEvent(chat.id, { type: AgentProcessEventType.Update, data: updatedMessage });
                     await this.messageRepository.update(assistantMessage.id, { content: assistantMessage.content });
                     continue;
                 }
@@ -284,7 +438,7 @@ export class ChatProcessor {
                     });
                     continue;
                 }
-                if (chunk.type === 'tool-call') { //Todo possible place to handle user-approval
+                if (chunk.type === 'tool-call') {
                     const toolCall = assistantMessage.toolCalls?.find(toolCall => toolCall.id === chunk.toolCallId);
                     if (toolCall) {
                         toolCall.status = AgentToolCallStatus.Running;
@@ -296,7 +450,7 @@ export class ChatProcessor {
                     const toolCall = assistantMessage.toolCalls?.find(toolCall => toolCall.id === chunk.toolCallId);
                     if (toolCall) {
                         toolCall.status = AgentToolCallStatus.Failed;
-                        toolCall.error = JSON.stringify(chunk.error);
+                        toolCall.error = chunk.error.message || JSON.stringify(chunk.error);
                     }
                     continue;
                 }
@@ -305,13 +459,16 @@ export class ChatProcessor {
                     if (toolCall) {
                         toolCall.requiresConfirmation = true;
                         toolCall.approvalId = chunk.approvalId;
+                        if (toolCall.name === AgentToolType.REQUEST_CLARIFICATION) {
+                            toolCall.requiresUserAction = true;
+                        }
                     }
                     continue;
                 }
                 if (chunk.type === 'tool-result') {
                     const toolCall = assistantMessage.toolCalls?.find(toolCall => toolCall.id === chunk.toolCallId);
                     if (toolCall) {
-                        if (chunk.output.requiresApproval) {
+                        if (chunk.output?.requiresApproval) {
                             toolCall.requiresConfirmation = true;
                             continue;
                         }
@@ -324,9 +481,9 @@ export class ChatProcessor {
                     if (!assistantMessage.reasoning)
                         assistantMessage.reasoning = '';
                     assistantMessage.reasoning += chunk.text;
-                    socketService.emitMessageUpdate(chat.userId, assistantMessage, excludeSocketId);
+                    this.socketService.emitMessageUpdate(chat.userId, assistantMessage, excludeSocketId);
                     await this.messageRepository.update(assistantMessage.id, { reasoning: assistantMessage.reasoning });
-                    await agentStore.shareAgentProcessEvent(chat.id, { type: AgentProcessEventType.Update, data: assistantMessage });
+                    await this.agentStore.shareAgentProcessEvent(chat.id, { type: AgentProcessEventType.Update, data: assistantMessage });
                     continue;
                 }
             }
@@ -335,7 +492,7 @@ export class ChatProcessor {
             if (streamError instanceof Error && streamError.name === 'AbortError') {
                 return;
             }
-            await agentStore.shareAgentProcessEvent(chat.id, { type: AgentProcessEventType.Error, data: streamError });
+            await this.agentStore.shareAgentProcessEvent(chat.id, { type: AgentProcessEventType.Error, data: streamError });
             throw streamError;
         }
     }
@@ -347,7 +504,7 @@ export class ChatProcessor {
         if (!assistantMessage || assistantMessage.chat !== chat.id) {
             throw new Error(`Assistant message with id ${payload.messageId} not found`);
         }
-        const agentOptions = await AIHelper.getAgentOptions({
+        const agentOptions = await this.aiHelper.getAgentOptions({
             agentName: assistantMessage.agentName,
             context: payload.context
         });
@@ -360,14 +517,20 @@ export class ChatProcessor {
             };
         }
         toolCall.approved = payload.approved;
-        toolCall.reason = payload.reason;
+        toolCall.userResponse = payload.userResponse;
         if (!toolCall.approved) {
             toolCall.output = {
                 type: 'execution-denied',
-                reason: toolCall.reason
+                reason: toolCall.userResponse
             };
             toolCall.status = AgentToolCallStatus.Failed;
         }
+        else if (toolCall.requiresUserAction) {
+            toolCall.output = {
+                userResponse: toolCall.userResponse
+            };
+            toolCall.status = AgentToolCallStatus.Succeeded;
+        }
         else {
             const executeFunction = agentOptions.tools?.[toolCall.name]?.execute;
             if (executeFunction) {
@@ -400,32 +563,105 @@ export class ChatProcessor {
     }
     async processNewUserMessage(chat, payload, prevMessages, excludeSocketId) {
         const userMessage = await this.createMessage(chat, MessageRole.User, { content: payload.content, agentName: undefined }, payload.attachments);
-        await agentStore.shareAgentProcessEvent(chat.id, { type: AgentProcessEventType.Update, data: userMessage });
-        const agentOptions = await AIHelper.getAgentOptions({
+        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,
+            groupId: chat.id,
+            name: ActivityOperationName.MESSAGE_PROCESSING,
+            tenants: payload.tenants ?? {},
+            sourceId: userMessage.id,
+            sourceType: 'AgentMessage',
+            metadata: {
+                contextKey: chat.contextKey,
+                modelId: this.aiHelper.getLanguageModelId(chat.model),
+            },
+        });
+        const agentOptions = await this.aiHelper.getAgentOptions({
             contextKey: chat.contextKey,
-            messages: await AIHelper.convertMessages([...prevMessages, userMessage], true),
+            messages: [...prevMessages, userMessage],
             context: payload.context,
             agentName: undefined,
             modelId: chat.model,
+        }, {
+            onStepFinish: async (stepResult) => {
+                await this.storeStepActivity({
+                    chat,
+                    parentId: parentActivity.id,
+                    stepResult,
+                    name: ActivityOperationName.AGENT_SELECTION,
+                    sourceId: userMessage.id,
+                    sourceType: 'AgentMessage',
+                    tenants: payload.tenants || {},
+                });
+            }
+        });
+        const updatedAssistantMessage = await this.messageRepository.update(assistantMessage.id, {
+            agentName: agentOptions.name,
+            activity: parentActivity.id
         });
-        const assistantMessage = await this.createMessage(chat, MessageRole.Assistant, { content: ' ', agentName: agentOptions.name }, undefined, excludeSocketId);
-        assistantMessage.content = '';
+        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 {
             userMessage,
             assistantMessage,
             agentOptions,
         };
     }
+    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,
+                groupId: params.chat.id,
+                name: params.name,
+                tenants: params.tenants || {},
+                sourceId: params.sourceId,
+                sourceType: params.sourceType,
+                metadata: {
+                    finishReason: stepResult.finishReason,
+                    usage: mergedUsage,
+                    responseTimestamp: stepResult.response.timestamp,
+                    modelId: stepResult.response.modelId,
+                    messages: this.debug ? stepResult.request?.body?.messages : undefined,
+                },
+                parentId: params.parentId,
+            });
+        }
+        catch (error) {
+            logger.error({ error, chatId: params.chat.id, parentId: params.parentId }, 'Failed to store step activity');
+        }
+    }
     async streamMessage(chat, payload, excludeSocketId, onAgentStart) {
         try {
-            const abortController = agentStore.registerAgentProcess(chat.id);
+            const abortController = this.agentStore.registerAgentProcess(chat.id);
             onAgentStart?.();
             let assistantMessage;
             let agentOptions;
             const existingMessages = await this.messageRepository.findByChatId(chat.id);
             // Limit context to prevent exceeding token limits
             const limitedMessages = ContextLimiter.limitContext(existingMessages, {
-                maxMessages: config.ai.maxContextMessages,
+                maxMessages: this.config.ai.maxContextMessages,
                 keepFirstUserMessage: true,
                 keepSystemMessages: true,
             });
@@ -447,6 +683,19 @@ export class ChatProcessor {
                 agentOptions = result.agentOptions;
                 limitedMessages.push(result.userMessage);
             }
+            agentOptions.onStepFinish = (stepResult) => {
+                return this.storeStepActivity({
+                    chat,
+                    parentId: assistantMessage.activity,
+                    stepResult,
+                    name: ActivityOperationName.STEP_FINISHED,
+                    sourceId: assistantMessage.id,
+                    sourceType: 'AgentMessage',
+                    tenants: payload.tenants || {},
+                });
+            };
+            const userPreferences = await this.agentConfigRepository.findByUserIdAndAgentName(chat.userId, agentOptions.name);
+            agentOptions.activeTools = this.getAvailableTools(agentOptions, userPreferences);
             await this.streamMessageStep({
                 chat,
                 existingMessages: limitedMessages,
@@ -454,12 +703,28 @@ export class ChatProcessor {
                 agentOptions,
                 excludeSocketId: excludeSocketId,
                 signal: abortController.signal,
+                tenants: payload.tenants || {},
             });
         }
         catch (error) {
             throw error;
         }
     }
+    getAvailableTools(agentOptions, userPreferences) {
+        const toolNames = Object.keys(agentOptions.tools || {});
+        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;
+            if (tool.disabledByDefault) {
+                availableToolsMap[toolTitle] = false;
+            }
+            if (tool.userConfigurable && userPreferences?.tools?.[toolTitle] !== undefined) {
+                availableToolsMap[toolTitle] = userPreferences.tools[toolTitle];
+            }
+        });
+        return Object.keys(availableToolsMap).filter(key => availableToolsMap[key]);
+    }
     listArtifacts(chatId) {
         return this.artifactStore.listArtifacts(chatId);
     }
@@ -490,7 +755,7 @@ export class ChatProcessor {
                 return null;
         }
     }
-    getMessageStream(chatId) {
+    getMessageStream(chatId, signal) {
         const stream = new PassThrough();
         let ended = false;
         const endStream = (error) => {
@@ -511,13 +776,15 @@ export class ChatProcessor {
             }
         };
         const pushChunk = (chunk) => {
-            if (ended || stream.destroyed || stream.writableEnded)
+            if (ended || stream.destroyed || stream.writableEnded || signal?.aborted)
                 return;
             stream.write(`data: ${JSON.stringify(chunk)}\n\n`);
         };
         const listener = (event) => {
-            if (ended)
+            if (signal?.aborted) {
+                endStream();
                 return;
+            }
             try {
                 const chunk = this.eventToChunk(event);
                 if (chunk) {
@@ -527,7 +794,6 @@ export class ChatProcessor {
                     event.type === AgentProcessEventType.Error ||
                     event.type === AgentProcessEventType.Aborted) {
                     endStream();
-                    agentStore.removeListener(chatId, listener);
                 }
             }
             catch (err) {
@@ -536,21 +802,18 @@ export class ChatProcessor {
                     error: err instanceof Error ? err.message : 'Unknown error occurred',
                 });
                 endStream(err);
-                agentStore.removeListener(chatId, listener);
             }
         };
-        // Cleanup on consumer side closing
         const closeHandler = () => {
-            agentStore.removeListener(chatId, listener);
+            this.agentStore.removeListener(chatId, listener);
         };
         const errorHandler = (err) => {
-            logger.error({ err }, 'Readable stream error');
-            agentStore.removeListener(chatId, listener);
+            signal?.removeEventListener('abort', endStream);
             endStream(err);
         };
         stream.on('close', closeHandler);
         stream.on('error', errorHandler);
-        const listenerAttached = agentStore.addListener(chatId, listener);
+        const listenerAttached = this.agentStore.addListener(chatId, listener);
         if (!listenerAttached) {
             // Remove stream listeners if listener attachment failed to prevent memory leak
             stream.removeListener('close', closeHandler);
@@ -559,50 +822,27 @@ export class ChatProcessor {
         }
         return stream;
     }
-    async createMessageStream(payload, excludeSocketId) {
+    async createMessageStream(payload, excludeSocketId, signal) {
         const stream = new PassThrough();
-        (async () => {
-            try {
-                const chat = await this.upsertAndGetChat(payload, excludeSocketId);
-                // Send chat metadata first
-                if (!('chatId' in payload) && !('messageId' in payload) && chat) {
-                    stream.write(`data: ${JSON.stringify({
-                        type: StreamChunkType.Chat,
-                        chatId: chat.id,
-                        chat,
-                    })}\n\n`);
-                }
-                await this.streamMessage(chat, payload, excludeSocketId, async () => {
-                    if (stream.destroyed || stream.writableEnded) {
-                        return;
-                    }
-                    const messageStream = this.getMessageStream(chat.id);
-                    // If client disconnects, destroy inner stream
-                    stream.on('close', () => {
-                        if (!messageStream.destroyed) {
-                            messageStream.destroy();
-                        }
-                    });
-                    await pipelineAsync(messageStream, stream);
-                });
-            }
-            catch (error) {
-                logger.error({ error }, 'createMessageStream failed');
-                if (!stream.destroyed && !stream.writableEnded) {
-                    stream.write(`data: ${JSON.stringify({
-                        type: StreamChunkType.Error,
-                        error: error instanceof Error ? error.message : 'Unknown error occurred',
-                    })}\n\n`);
-                    stream.write('data: [DONE]\n\n');
-                    stream.end();
-                }
-            }
-        })().catch((err) => {
-            logger.error({ err }, 'Unhandled stream task error');
-            if (!stream.destroyed)
-                stream.destroy(err);
+        this.runMessageStream(stream, payload, excludeSocketId, signal)
+            .catch(err => {
+            logger.error({ err }, 'Stream task failed');
         });
         return stream;
     }
+    async runMessageStream(stream, payload, excludeSocketId, signal) {
+        const chat = await this.upsertAndGetChat(payload, excludeSocketId);
+        if (!('chatId' in payload) && !('messageId' in payload) && chat) {
+            stream.write(`data: ${JSON.stringify({
+                type: StreamChunkType.Chat,
+                chatId: chat.id,
+                chat,
+            })}\n\n`);
+        }
+        await this.streamMessage(chat, payload, excludeSocketId, () => {
+            const messageStream = this.getMessageStream(chat.id, signal);
+            messageStream.pipe(stream);
+        });
+    }
 }
 //# sourceMappingURL=ChatProcessor.js.map