n8n 2.4.4 → 2.5.1

package/dist/modules/chat-hub/chat-hub.service.js

@@ -17,7 +17,10 @@ const db_1 = require("@n8n/db");
 const di_1 = require("@n8n/di");
 const n8n_core_1 = require("n8n-core");
 const n8n_workflow_1 = require("n8n-workflow");
+const uuid_1 = require("uuid");
 const active_executions_1 = require("../../active-executions");
+const chat_execution_manager_1 = require("../../chat/chat-execution-manager");
+const execution_not_found_error_1 = require("../../errors/execution-not-found-error");
 const bad_request_error_1 = require("../../errors/response-errors/bad-request.error");
 const not_found_error_1 = require("../../errors/response-errors/not-found.error");
 const execution_service_1 = require("../../executions/execution.service");
@@ -34,12 +37,14 @@ const chat_hub_types_1 = require("./chat-hub.types");
 const chat_message_repository_1 = require("./chat-message.repository");
 const chat_session_repository_1 = require("./chat-session.repository");
 const stream_capturer_1 = require("./stream-capturer");
+const utils_1 = require("../../chat/utils");
 let ChatHubService = class ChatHubService {
-    constructor(logger, errorReporter, executionService, executionRepository, workflowExecutionService, workflowFinderService, workflowRepository, activeExecutions, sessionRepository, messageRepository, chatHubAgentService, chatHubCredentialsService, chatHubWorkflowService, chatHubModelsService, chatHubSettingsService, chatHubAttachmentService, instanceSettings, globalConfig) {
+    constructor(logger, errorReporter, executionService, executionRepository, executionManager, workflowExecutionService, workflowFinderService, workflowRepository, activeExecutions, sessionRepository, messageRepository, chatHubAgentService, chatHubCredentialsService, chatHubWorkflowService, chatHubModelsService, chatHubSettingsService, chatHubAttachmentService, instanceSettings, globalConfig) {
         this.logger = logger;
         this.errorReporter = errorReporter;
         this.executionService = executionService;
         this.executionRepository = executionRepository;
+        this.executionManager = executionManager;
         this.workflowExecutionService = workflowExecutionService;
         this.workflowFinderService = workflowFinderService;
         this.workflowRepository = workflowRepository;
@@ -92,11 +97,9 @@ let ChatHubService = class ChatHubService {
         const tz = timeZone ?? this.globalConfig.generic.timezone;
         const credentialId = this.getModelCredential(model, credentials);
         let processedAttachments = [];
-        let executionData;
-        let workflowData;
-        let responseMode;
+        let workflow;
         try {
-            const result = await this.messageRepository.manager.transaction(async (trx) => {
+            workflow = await this.messageRepository.manager.transaction(async (trx) => {
                 let session = await this.getChatSession(user, sessionId, trx);
                 session ??= await this.createChatSession(user, sessionId, model, credentialId, tools, payload.agentName, trx);
                 await this.ensurePreviousMessage(previousMessageId, sessionId, trx);
@@ -106,9 +109,6 @@ let ChatHubService = class ChatHubService {
                 await this.saveHumanMessage(payload, processedAttachments, user, previousMessageId, model, undefined, trx);
                 return await this.prepareReplyWorkflow(user, sessionId, credentials, model, history, message, tools, processedAttachments, tz, trx);
             });
-            executionData = result.executionData;
-            workflowData = result.workflowData;
-            responseMode = result.responseMode;
         }
         catch (error) {
             if (processedAttachments.length > 0) {
@@ -121,17 +121,41 @@ let ChatHubService = class ChatHubService {
             }
             throw error;
         }
-        await this.executeChatWorkflowWithCleanup(res, user, workflowData, executionData, sessionId, messageId, model, null, responseMode);
-        if (previousMessageId === null) {
-            await this.generateSessionTitle(user, sessionId, message, processedAttachments, credentials, model).catch((error) => {
-                this.logger.error(`Title generation failed: ${error}`);
+        if (!workflow) {
+            throw new n8n_workflow_1.UnexpectedError('Failed to prepare chat workflow.');
+        }
+        const previousMessage = await this.ensurePreviousMessage(previousMessageId, sessionId);
+        if (model.provider === 'n8n' &&
+            workflow.responseMode === 'responseNodes' &&
+            previousMessage?.status === 'waiting' &&
+            previousMessage?.executionId) {
+            const execution = await this.executionRepository.findSingleExecution(previousMessage.executionId.toString(), {
+                includeData: true,
+                unflattenData: true,
+            });
+            if (!execution) {
+                throw new n8n_workflow_1.OperationalError('Chat session has expired.');
+            }
+            this.logger.debug(`Resuming execution ${execution.id} from waiting state for session ${sessionId}`);
+            await this.messageRepository.updateChatMessage(previousMessage.id, {
+                status: 'success',
             });
+            return await this.resumeChatExecution(execution, message, sessionId, messageId, previousMessage.id, model, res, workflow.responseMode);
+        }
+        await this.executeChatWorkflowWithCleanup(res, user, model, workflow.workflowData, workflow.executionData, sessionId, messageId, null, workflow.responseMode);
+        if (previousMessageId === null) {
+            try {
+                await this.generateSessionTitle(user, sessionId, message, processedAttachments, credentials, model);
+            }
+            catch (error) {
+                this.logger.warn(`Title generation failed: ${error}`);
+            }
         }
     }
     async editMessage(res, user, payload) {
         const { sessionId, editId, messageId, message, model, credentials, timeZone } = payload;
         const tz = timeZone ?? this.globalConfig.generic.timezone;
-        let workflow;
+        let workflow = null;
         let newStoredAttachments = [];
         try {
             workflow = await this.messageRepository.manager.transaction(async (trx) => {
@@ -141,6 +165,9 @@ let ChatHubService = class ChatHubService {
                 }
                 const messageToEdit = await this.getChatMessage(session.id, editId, [], trx);
                 if (messageToEdit.type === 'ai') {
+                    if (model.provider === 'n8n') {
+                        throw new bad_request_error_1.BadRequestError('Editing AI messages with n8n workflow agents is not supported');
+                    }
                     await this.messageRepository.updateChatMessage(editId, { content: payload.message }, trx);
                     return null;
                 }
@@ -179,12 +206,12 @@ let ChatHubService = class ChatHubService {
             return;
         }
         const { workflowData, executionData, responseMode } = workflow;
-        await this.executeChatWorkflowWithCleanup(res, user, workflowData, executionData, sessionId, messageId, model, null, responseMode);
+        await this.executeChatWorkflowWithCleanup(res, user, model, workflowData, executionData, sessionId, messageId, null, responseMode);
     }
     async regenerateAIMessage(res, user, payload) {
         const { sessionId, retryId, model, credentials, timeZone } = payload;
         const tz = timeZone ?? this.globalConfig.generic.timezone;
-        const { workflow: { workflowData, executionData, responseMode }, retryOfMessageId, previousMessageId, } = await this.messageRepository.manager.transaction(async (trx) => {
+        const { retryOfMessageId, previousMessageId, workflow } = await this.messageRepository.manager.transaction(async (trx) => {
             const session = await this.getChatSession(user, sessionId, trx);
             if (!session) {
                 throw new not_found_error_1.NotFoundError('Chat session not found');
@@ -208,16 +235,16 @@ let ChatHubService = class ChatHubService {
             const attachments = lastHumanMessage.attachments ?? [];
             const workflow = await this.prepareReplyWorkflow(user, sessionId, credentials, model, history, message, session.tools, attachments, tz, trx);
             return {
-                workflow,
                 previousMessageId: lastHumanMessage.id,
                 retryOfMessageId,
+                workflow,
             };
         });
-        await this.executeChatWorkflowWithCleanup(res, user, workflowData, executionData, sessionId, previousMessageId, model, retryOfMessageId, responseMode);
+        await this.executeChatWorkflowWithCleanup(res, user, model, workflow.workflowData, workflow.executionData, sessionId, previousMessageId, retryOfMessageId, workflow.responseMode);
     }
     async prepareReplyWorkflow(user, sessionId, credentials, model, history, message, tools, attachments, timeZone, trx) {
         if (model.provider === 'n8n') {
-            return await this.prepareCustomAgentWorkflow(user, sessionId, model.workflowId, message, attachments);
+            return await this.prepareWorkflowAgentWorkflow(user, sessionId, model.workflowId, message, attachments, trx);
         }
         if (model.provider === 'custom-agent') {
             return await this.prepareChatAgentWorkflow(model.agentId, user, sessionId, history, message, attachments, timeZone, trx);
@@ -231,7 +258,7 @@ let ChatHubService = class ChatHubService {
         return await this.chatHubWorkflowService.createChatWorkflow(user.id, sessionId, projectId, history, message, attachments, credentials, model, systemMessage, tools, timeZone, trx);
     }
     async prepareChatAgentWorkflow(agentId, user, sessionId, history, message, attachments, timeZone, trx) {
-        const agent = await this.chatHubAgentService.getAgentById(agentId, user.id);
+        const agent = await this.chatHubAgentService.getAgentById(agentId, user.id, trx);
         if (!agent) {
             throw new bad_request_error_1.BadRequestError('Agent not found');
         }
@@ -256,8 +283,8 @@ let ChatHubService = class ChatHubService {
         const { tools } = agent;
         return await this.prepareBaseChatWorkflow(user, sessionId, credentials, model, history, message, systemMessage, tools, attachments, timeZone, trx);
     }
-    async prepareCustomAgentWorkflow(user, sessionId, workflowId, message, attachments) {
-        const workflow = await this.workflowFinderService.findWorkflowForUser(workflowId, user, ['workflow:execute-chat'], { includeTags: false, includeParentFolder: false, includeActiveVersion: true });
+    async prepareWorkflowAgentWorkflow(user, sessionId, workflowId, message, attachments, trx) {
+        const workflow = await this.workflowFinderService.findWorkflowForUser(workflowId, user, ['workflow:execute-chat'], { includeTags: false, includeParentFolder: false, includeActiveVersion: true, em: trx });
         if (!workflow?.activeVersion) {
             throw new bad_request_error_1.BadRequestError('Workflow not found');
         }
@@ -277,12 +304,12 @@ let ChatHubService = class ChatHubService {
             throw new bad_request_error_1.BadRequestError('Chat Trigger node must be made available in Chat');
         }
         const responseMode = chatTriggerParams.options?.responseMode ?? 'streaming';
-        if (responseMode !== 'streaming') {
-            throw new bad_request_error_1.BadRequestError('Chat Trigger node response mode must be set to streaming to use the workflow on Chat');
+        if (!chat_hub_constants_1.SUPPORTED_RESPONSE_MODES.includes(responseMode)) {
+            throw new bad_request_error_1.BadRequestError('Chat Trigger node response mode must be set to "When Last Node Finishes", "Using Response Nodes" or "Streaming" to use the workflow on Chat');
         }
-        const chatResponseNodes = workflow.activeVersion.nodes.filter((node) => node.type === n8n_workflow_1.RESPOND_TO_CHAT_NODE_TYPE);
-        if (chatResponseNodes.length > 0) {
-            throw new bad_request_error_1.BadRequestError('Respond to Chat nodes are not supported in custom agent workflows');
+        const chatResponseNodes = workflow.activeVersion.nodes.filter((node) => node.type === n8n_workflow_1.CHAT_NODE_TYPE);
+        if (chatResponseNodes.length > 0 && responseMode !== 'responseNodes') {
+            throw new bad_request_error_1.BadRequestError('Chat nodes are not supported with the selected response mode. Please set the response mode to "Using Response Nodes" or remove the nodes from the workflow.');
         }
         const agentNodes = workflow.activeVersion.nodes?.filter((node) => node.type === n8n_workflow_1.AGENT_LANGCHAIN_NODE_TYPE);
         if (agentNodes.some((node) => node.typeVersion < chat_hub_constants_1.TOOLS_AGENT_NODE_MIN_VERSION)) {
@@ -301,6 +328,10 @@ let ChatHubService = class ChatHubService {
             ...workflow,
             nodes: workflow.activeVersion.nodes,
             connections: workflow.activeVersion.connections,
+            settings: {
+                ...workflow.settings,
+                saveDataSuccessExecution: 'all',
+            },
         };
         return {
             workflowData,
@@ -316,6 +347,7 @@ let ChatHubService = class ChatHubService {
         if (!previousMessage) {
             throw new bad_request_error_1.BadRequestError('The previous message does not exist in the session');
         }
+        return previousMessage;
     }
     async stopGeneration(user, sessionId, messageId) {
         await this.ensureConversation(user.id, sessionId);
@@ -335,11 +367,210 @@ let ChatHubService = class ChatHubService {
         await this.executionService.stop(message.execution.id, [message.execution.workflowId]);
         await this.messageRepository.updateChatMessage(messageId, { status: 'cancelled' });
     }
-    async executeChatWorkflow(res, user, workflowData, executionData, sessionId, previousMessageId, model, retryOfMessageId = null, executionMode = 'chat', responseMode) {
+    async executeChatWorkflow(res, user, model, workflowData, executionData, sessionId, previousMessageId, retryOfMessageId = null, executionMode = 'chat', responseMode) {
         this.logger.debug(`Starting execution of workflow "${workflowData.name}" with ID ${workflowData.id}`);
-        if (responseMode !== 'streaming') {
+        if (!chat_hub_constants_1.SUPPORTED_RESPONSE_MODES.includes(responseMode)) {
             throw new bad_request_error_1.BadRequestError(`Response mode "${responseMode}" is not supported yet.`);
         }
+        if (responseMode === 'lastNode' || responseMode === 'responseNodes') {
+            return await this.executeLastNode(res, user, model, workflowData, executionData, sessionId, previousMessageId, retryOfMessageId, executionMode, responseMode);
+        }
+        else if (responseMode === 'streaming') {
+            return await this.executeWithStreaming(res, user, model, workflowData, executionData, sessionId, previousMessageId, retryOfMessageId, executionMode);
+        }
+    }
+    async executeLastNode(res, user, model, workflowData, executionData, sessionId, previousMessageId, retryOfMessageId, executionMode, responseMode) {
+        const running = await this.workflowExecutionService.executeChatWorkflow(user, workflowData, executionData, undefined, false, executionMode);
+        const messageId = (0, uuid_1.v4)();
+        const executionId = running.executionId;
+        if (!executionId) {
+            throw new n8n_workflow_1.OperationalError('There was a problem starting the chat execution.');
+        }
+        await this.beginResponse(res, executionId, messageId, sessionId, model, previousMessageId, retryOfMessageId);
+        try {
+            await this.waitForExecutionCompletion(executionId);
+            const execution = await this.executionRepository.findSingleExecution(executionId, {
+                includeData: true,
+                unflattenData: true,
+            });
+            if (!execution) {
+                throw new n8n_workflow_1.OperationalError('Chat execution not found after completion - make sure your instance is saving executions.');
+            }
+            if (!['success', 'waiting', 'canceled'].includes(execution.status)) {
+                const errorMessage = this.getErrorMessage(execution) ?? 'Failed to generate a response';
+                throw new n8n_workflow_1.OperationalError(errorMessage);
+            }
+            const message = this.getMessage(execution, responseMode);
+            const status = execution?.status === 'waiting' ? 'waiting' : 'success';
+            await this.endResponse(res, message ?? '', status, executionId, messageId, previousMessageId, retryOfMessageId);
+            if (status === 'waiting' && responseMode === 'responseNodes') {
+                const lastNode = (0, utils_1.getLastNodeExecuted)(execution);
+                if (lastNode && (0, utils_1.shouldResumeImmediately)(lastNode)) {
+                    this.logger.debug(`Resuming execution ${execution.id} immediately after wait in node ${lastNode.name}`);
+                    await this.resumeChatExecution(execution, '', sessionId, messageId, messageId, model, res, responseMode);
+                }
+            }
+        }
+        catch (e) {
+            if (e instanceof n8n_workflow_1.ManualExecutionCancelledError) {
+                return;
+            }
+            const message = e instanceof Error ? e.message : 'Unknown error occurred during chat execution';
+            await this.endResponse(res, message ?? '', 'error', executionId, messageId, previousMessageId, retryOfMessageId);
+        }
+    }
+    async resumeChatExecution(execution, message, sessionId, messageId, previousMessageId, model, res, responseMode) {
+        await this.messageRepository.updateChatMessage(previousMessageId, {
+            status: 'success',
+        });
+        while (true) {
+            await this.resumeExecution(sessionId, execution, message);
+            previousMessageId = messageId;
+            messageId = (0, uuid_1.v4)();
+            await this.beginResponse(res, execution.id, messageId, sessionId, model, previousMessageId, null);
+            await this.waitForExecutionCompletion(execution.id);
+            const completed = await this.executionRepository.findSingleExecution(execution.id, {
+                includeData: true,
+                unflattenData: true,
+            });
+            if (!completed) {
+                throw new n8n_workflow_1.OperationalError('Chat execution not found after completion - make sure your instance is saving executions.');
+            }
+            if (!['success', 'waiting', 'canceled'].includes(completed.status)) {
+                const message = this.getErrorMessage(completed) ?? 'Failed to generate a response';
+                throw new n8n_workflow_1.OperationalError(message);
+            }
+            const reply = this.getMessage(completed, responseMode);
+            const status = completed?.status === 'waiting' ? 'waiting' : 'success';
+            await this.endResponse(res, reply ?? '', status, execution.id, messageId, previousMessageId, null);
+            const lastNode = (0, utils_1.getLastNodeExecuted)(completed);
+            if (status === 'waiting' && lastNode && (0, utils_1.shouldResumeImmediately)(lastNode)) {
+                this.logger.debug(`Resuming execution ${completed.id} immediately after wait in node ${lastNode.name}`);
+                await this.messageRepository.updateChatMessage(messageId, {
+                    status: 'success',
+                });
+                message = '';
+                execution = completed;
+            }
+            else {
+                return;
+            }
+        }
+    }
+    getMessage(execution, responseMode) {
+        const nodeName = this.getLastNodeExecuted(execution);
+        if (!nodeName)
+            return undefined;
+        const outputs = this.getNodeOutputs(execution, nodeName);
+        const entry = this.getFirstOutputEntry(outputs);
+        if (!entry)
+            return undefined;
+        const message = this.extractMessage(entry, responseMode);
+        if (typeof message === 'object' && message !== null) {
+            return (0, n8n_workflow_1.jsonStringify)(message);
+        }
+        return message;
+    }
+    getLastNodeExecuted(execution) {
+        const lastNodeExecuted = execution.data.resultData.lastNodeExecuted;
+        return typeof lastNodeExecuted === 'string' ? lastNodeExecuted : undefined;
+    }
+    getNodeOutputs(execution, nodeName) {
+        const runData = execution.data.resultData.runData[nodeName];
+        if (!runData || runData.length === 0)
+            return [];
+        const runIndex = runData.length - 1;
+        const data = runData[runIndex]?.data;
+        return data?.main ?? data?.[n8n_workflow_1.NodeConnectionTypes.AiTool] ?? [];
+    }
+    getFirstOutputEntry(outputs) {
+        for (const branch of outputs) {
+            if (!Array.isArray(branch) || branch.length === 0)
+                continue;
+            return branch[0];
+        }
+        return undefined;
+    }
+    extractMessage(entry, responseMode) {
+        if (responseMode === 'responseNodes') {
+            return entry.sendMessage ?? '';
+        }
+        if (responseMode === 'lastNode') {
+            const response = entry.json ?? {};
+            const message = response.output ?? response.text ?? response.message ?? '';
+            return typeof message === 'string' ? message : (0, n8n_workflow_1.jsonStringify)(message);
+        }
+        return undefined;
+    }
+    async beginResponse(res, executionId, messageId, sessionId, model, previousMessageId, retryOfMessageId) {
+        const beginChunk = {
+            type: 'begin',
+            metadata: {
+                timestamp: Date.now(),
+                messageId,
+                previousMessageId,
+                retryOfMessageId,
+                executionId: executionId ? parseInt(executionId, 10) : null,
+            },
+        };
+        if (!res.headersSent) {
+            res.writeHead(200, chat_hub_constants_1.JSONL_STREAM_HEADERS);
+            res.flushHeaders();
+        }
+        res.write((0, n8n_workflow_1.jsonStringify)(beginChunk) + '\n');
+        res.flush();
+        await this.saveAIMessage({
+            id: messageId,
+            content: '',
+            sessionId,
+            executionId: executionId ?? undefined,
+            model,
+            previousMessageId,
+            retryOfMessageId,
+            status: 'running',
+        });
+    }
+    async endResponse(res, content, status, executionId, messageId, previousMessageId, retryOfMessageId) {
+        const contentChunk = {
+            type: status === 'error' ? 'error' : 'item',
+            content,
+            metadata: {
+                timestamp: Date.now(),
+                messageId,
+                previousMessageId,
+                retryOfMessageId,
+                executionId: executionId ? parseInt(executionId, 10) : null,
+            },
+        };
+        res.write((0, n8n_workflow_1.jsonStringify)(contentChunk) + '\n');
+        res.flush();
+        if (status !== 'error') {
+            const endChunk = {
+                type: 'end',
+                metadata: {
+                    timestamp: Date.now(),
+                    messageId,
+                    previousMessageId,
+                    retryOfMessageId,
+                    executionId: executionId ? parseInt(executionId, 10) : null,
+                },
+            };
+            res.write((0, n8n_workflow_1.jsonStringify)(endChunk) + '\n');
+            res.flush();
+        }
+        await this.messageRepository.updateChatMessage(messageId, {
+            content,
+            status,
+        });
+    }
+    async resumeExecution(sessionId, execution, message) {
+        await this.executionManager.runWorkflow(execution, {
+            action: 'sendMessage',
+            chatInput: message,
+            sessionId,
+        });
+    }
+    async executeWithStreaming(res, user, model, workflowData, executionData, sessionId, previousMessageId, retryOfMessageId, executionMode) {
         let executionId = undefined;
         const aggregator = (0, stream_capturer_1.createStructuredChunkAggregator)(previousMessageId, retryOfMessageId, {
             onBegin: async (message) => {
@@ -391,17 +622,17 @@ let ChatHubService = class ChatHubService {
                     : 'Request was not processed';
             }
             const message = await aggregator.ingest(chunk);
-            const enriched = {
+            const messageChunk = {
                 ...chunk,
                 metadata: {
-                    ...chunk.metadata,
+                    timestamp: chunk.metadata.timestamp,
                     messageId: message.id,
                     previousMessageId: message.previousMessageId,
                     retryOfMessageId: message.retryOfMessageId,
                     executionId: executionId ? +executionId : null,
                 },
             };
-            return (0, n8n_workflow_1.jsonStringify)(enriched) + '\n';
+            return (0, n8n_workflow_1.jsonStringify)(messageChunk) + '\n';
         };
         const stream = (0, stream_capturer_1.interceptResponseWrites)(res, transform);
         let onStreamClosed = () => { };
@@ -413,7 +644,7 @@ let ChatHubService = class ChatHubService {
         stream.on('close', onStreamClosed);
         stream.writeHead(200, chat_hub_constants_1.JSONL_STREAM_HEADERS);
         stream.flushHeaders();
-        const execution = await this.workflowExecutionService.executeChatWorkflow(workflowData, executionData, user, stream, true, executionMode);
+        const execution = await this.workflowExecutionService.executeChatWorkflow(user, workflowData, executionData, stream, true, executionMode);
         executionId = execution.executionId;
         if (!executionId) {
             throw new n8n_workflow_1.OperationalError('There was a problem starting the chat execution.');
@@ -446,14 +677,19 @@ let ChatHubService = class ChatHubService {
         return await new Promise((resolve, reject) => {
             const poller = setInterval(async () => {
                 try {
-                    const result = await this.executionRepository.findSingleExecution(executionId, {
+                    const execution = await this.executionRepository.findSingleExecution(executionId, {
                         includeData: false,
                         unflattenData: false,
                     });
-                    if (!result || chat_hub_constants_1.EXECUTION_FINISHED_STATUSES.includes(result.status)) {
-                        this.logger.debug(`Execution ${executionId} finished with status ${result?.status ?? 'missing'}`);
+                    if (!execution || chat_hub_constants_1.EXECUTION_FINISHED_STATUSES.includes(execution.status)) {
+                        this.logger.debug(`Execution ${executionId} finished with status ${execution?.status ?? 'missing'}`);
                         clearInterval(poller);
-                        resolve();
+                        if (execution?.status === 'canceled') {
+                            reject(new n8n_workflow_1.ManualExecutionCancelledError(executionId));
+                        }
+                        else {
+                            resolve();
+                        }
                     }
                 }
                 catch (error) {
@@ -485,19 +721,22 @@ let ChatHubService = class ChatHubService {
             }
         }
         catch (error) {
-            if (error instanceof n8n_workflow_1.ManualExecutionCancelledError) {
+            if (error instanceof execution_not_found_error_1.ExecutionNotFoundError) {
                 return;
             }
+            if (error instanceof n8n_workflow_1.ManualExecutionCancelledError) {
+                throw error;
+            }
             if (error instanceof Error) {
                 this.logger.error(`Error during chat workflow execution: ${error}`);
             }
             throw error;
         }
     }
-    async executeChatWorkflowWithCleanup(res, user, workflowData, executionData, sessionId, previousMessageId, model, retryOfMessageId, responseMode) {
+    async executeChatWorkflowWithCleanup(res, user, model, workflowData, executionData, sessionId, previousMessageId, retryOfMessageId, responseMode) {
         try {
             const executionMode = model.provider === 'n8n' ? 'webhook' : 'chat';
-            await this.executeChatWorkflow(res, user, workflowData, executionData, sessionId, previousMessageId, model, retryOfMessageId, executionMode, responseMode);
+            await this.executeChatWorkflow(res, user, model, workflowData, executionData, sessionId, previousMessageId, retryOfMessageId, executionMode, responseMode);
         }
         finally {
             if (model.provider !== 'n8n') {
@@ -513,12 +752,6 @@ let ChatHubService = class ChatHubService {
                 await this.sessionRepository.updateChatSession(sessionId, { title });
             }
         }
-        catch (error) {
-            if (error instanceof Error) {
-                this.logger.error(`Error during session title generation workflow execution: ${error}`);
-            }
-            throw error;
-        }
         finally {
             await this.deleteChatWorkflow(workflowData.id);
         }
@@ -552,24 +785,24 @@ let ChatHubService = class ChatHubService {
     async resolveFromN8nWorkflow(user, { workflowId }, trx) {
         const workflowEntity = await this.workflowFinderService.findWorkflowForUser(workflowId, user, ['workflow:execute-chat'], { includeTags: false, includeParentFolder: false, includeActiveVersion: true, em: trx });
         if (!workflowEntity?.activeVersion) {
-            throw new bad_request_error_1.BadRequestError('Workflow not found for title generation');
+            throw new n8n_workflow_1.UserError('Workflow not found for title generation');
         }
         const modelNodes = this.findSupportedLLMNodes(workflowEntity.activeVersion.nodes);
         this.logger.debug(`Found ${modelNodes.length} LLM nodes in workflow ${workflowEntity.id} for title generation`);
         if (modelNodes.length === 0) {
-            throw new bad_request_error_1.BadRequestError('No supported Model nodes found in workflow for title generation');
+            throw new n8n_workflow_1.UserError('No supported Model nodes found in workflow for title generation');
         }
         const modelNode = modelNodes[0];
         const llmModel = modelNode.node.parameters?.model?.value;
         if (!llmModel) {
-            throw new bad_request_error_1.BadRequestError(`No model set on Model node "${modelNode.node.name}" for title generation`);
+            throw new n8n_workflow_1.UserError(`No model set on Model node "${modelNode.node.name}" for title generation`);
         }
         if (typeof llmModel !== 'string' || llmModel.length === 0 || llmModel.startsWith('=')) {
-            throw new bad_request_error_1.BadRequestError(`Invalid model set on Model node "${modelNode.node.name}" for title generation`);
+            throw new n8n_workflow_1.UserError(`Invalid model set on Model node "${modelNode.node.name}" for title generation`);
         }
         const llmCredentials = modelNode.node.credentials;
         if (!llmCredentials) {
-            throw new bad_request_error_1.BadRequestError(`No credentials found on Model node "${modelNode.node.name}" for title generation`);
+            throw new n8n_workflow_1.UserError(`No credentials found on Model node "${modelNode.node.name}" for title generation`);
         }
         const { credentialId, projectId } = await this.chatHubCredentialsService.findWorkflowCredentialAndProject(modelNode.provider, llmCredentials, workflowId);
         const resolvedModel = {
@@ -595,7 +828,7 @@ let ChatHubService = class ChatHubService {
         }, []);
     }
     async resolveFromCustomAgent(user, model, trx) {
-        const agent = await this.chatHubAgentService.getAgentById(model.agentId, user.id);
+        const agent = await this.chatHubAgentService.getAgentById(model.agentId, user.id, trx);
         if (!agent) {
             throw new bad_request_error_1.BadRequestError('Agent not found for title generation');
         }
@@ -617,7 +850,7 @@ let ChatHubService = class ChatHubService {
         return { resolvedCredentials, resolvedModel, credentialId, projectId };
     }
     async runTitleWorkflowAndGetTitle(user, workflowData, executionData) {
-        const { executionId } = await this.workflowExecutionService.executeChatWorkflow(workflowData, executionData, user, undefined, false, 'chat');
+        const { executionId } = await this.workflowExecutionService.executeChatWorkflow(user, workflowData, executionData, undefined, false, 'chat');
         await this.waitForExecutionCompletion(executionId);
         const execution = await this.executionRepository.findWithUnflattenedData(executionId, [
             workflowData.id,
@@ -668,7 +901,7 @@ let ChatHubService = class ChatHubService {
         return await this.sessionRepository.getOneById(sessionId, user.id, trx);
     }
     async createChatSession(user, sessionId, model, credentialId, tools, agentName, trx) {
-        await this.ensureValidModel(user, model);
+        await this.ensureValidModel(user, model, trx);
         return await this.sessionRepository.createChatSession({
             id: sessionId,
             ownerId: user.id,
@@ -797,15 +1030,15 @@ let ChatHubService = class ChatHubService {
             await this.sessionRepository.deleteChatHubSession(sessionId, trx);
         });
     }
-    async ensureValidModel(user, model) {
+    async ensureValidModel(user, model, trx) {
         if (model.provider === 'custom-agent') {
-            const agent = await this.chatHubAgentService.getAgentById(model.agentId, user.id);
+            const agent = await this.chatHubAgentService.getAgentById(model.agentId, user.id, trx);
             if (!agent) {
                 throw new bad_request_error_1.BadRequestError('Agent not found for chat session initialization');
             }
         }
         if (model.provider === 'n8n') {
-            const workflowEntity = await this.workflowFinderService.findWorkflowForUser(model.workflowId, user, ['workflow:execute-chat'], { includeTags: false, includeParentFolder: false, includeActiveVersion: true });
+            const workflowEntity = await this.workflowFinderService.findWorkflowForUser(model.workflowId, user, ['workflow:execute-chat'], { includeTags: false, includeParentFolder: false, includeActiveVersion: true, em: trx });
             if (!workflowEntity?.activeVersion) {
                 throw new bad_request_error_1.BadRequestError('Workflow not found for chat session initialization');
             }
@@ -871,6 +1104,7 @@ exports.ChatHubService = ChatHubService = __decorate([
         n8n_core_1.ErrorReporter,
         execution_service_1.ExecutionService,
         db_1.ExecutionRepository,
+        chat_execution_manager_1.ChatExecutionManager,
         workflow_execution_service_1.WorkflowExecutionService,
         workflow_finder_service_1.WorkflowFinderService,
         db_1.WorkflowRepository,