n8n 1.117.2 → 1.118.0

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

@@ -17,16 +17,21 @@ const di_1 = require("@n8n/di");
 const n8n_workflow_1 = require("n8n-workflow");
 const uuid_1 = require("uuid");
 const active_executions_1 = require("../../active-executions");
-const credentials_service_1 = require("../../credentials/credentials.service");
+const credentials_finder_service_1 = require("../../credentials/credentials-finder.service");
 const bad_request_error_1 = require("../../errors/response-errors/bad-request.error");
+const forbidden_error_1 = require("../../errors/response-errors/forbidden.error");
 const not_found_error_1 = require("../../errors/response-errors/not-found.error");
 const execution_service_1 = require("../../executions/execution.service");
 const dynamic_node_parameters_service_1 = require("../../services/dynamic-node-parameters.service");
 const workflow_execute_additional_data_1 = require("../../workflow-execute-additional-data");
 const workflow_execution_service_1 = require("../../workflows/workflow-execution.service");
+const workflow_finder_service_1 = require("../../workflows/workflow-finder.service");
+const workflow_service_1 = require("../../workflows/workflow.service");
+const chat_hub_constants_1 = require("./chat-hub.constants");
 const chat_message_repository_1 = require("./chat-message.repository");
 const chat_session_repository_1 = require("./chat-session.repository");
 const context_limits_1 = require("./context-limits");
+const stream_capturer_1 = require("./stream-capturer");
 const providerNodeTypeMapping = {
     openai: {
         name: '@n8n/n8n-nodes-langchain.lmChatOpenAi',
@@ -43,42 +48,60 @@ const providerNodeTypeMapping = {
 };
 const NODE_NAMES = {
     CHAT_TRIGGER: 'When chat message received',
-    AI_AGENT: 'AI Agent',
+    REPLY_AGENT: 'AI Agent',
+    TITLE_GENERATOR_AGENT: 'Title Generator Agent',
     CHAT_MODEL: 'Chat Model',
     MEMORY: 'Memory',
     RESTORE_CHAT_MEMORY: 'Restore Chat Memory',
     CLEAR_CHAT_MEMORY: 'Clear Chat Memory',
 };
+const JSONL_STREAM_HEADERS = {
+    'Content-Type': 'application/json-lines; charset=utf-8',
+    'Transfer-Encoding': 'chunked',
+    'Cache-Control': 'no-cache',
+    Connection: 'keep-alive',
+};
 let ChatHubService = class ChatHubService {
-    constructor(logger, credentialsService, executionService, nodeParametersService, executionRepository, workflowExecutionService, workflowRepository, projectRepository, sharedWorkflowRepository, activeExecutions, sessionRepository, messageRepository) {
+    constructor(logger, executionService, nodeParametersService, executionRepository, workflowExecutionService, workflowService, workflowFinderService, workflowRepository, sharedWorkflowRepository, activeExecutions, sessionRepository, messageRepository, credentialsFinderService) {
         this.logger = logger;
-        this.credentialsService = credentialsService;
         this.executionService = executionService;
         this.nodeParametersService = nodeParametersService;
         this.executionRepository = executionRepository;
         this.workflowExecutionService = workflowExecutionService;
+        this.workflowService = workflowService;
+        this.workflowFinderService = workflowFinderService;
         this.workflowRepository = workflowRepository;
-        this.projectRepository = projectRepository;
         this.sharedWorkflowRepository = sharedWorkflowRepository;
         this.activeExecutions = activeExecutions;
         this.sessionRepository = sessionRepository;
         this.messageRepository = messageRepository;
+        this.credentialsFinderService = credentialsFinderService;
     }
     async getModels(user, credentialIds) {
         const additionalData = await (0, workflow_execute_additional_data_1.getBase)({ userId: user.id });
-        const responses = await Promise.all(api_types_1.chatHubProviderSchema.options.map(async (provider) => {
-            const credentialId = credentialIds[provider];
-            if (!credentialId) {
-                return [provider, { models: [] }];
+        const providers = ['openai', 'anthropic', 'google'];
+        const allCredentials = await this.credentialsFinderService.findCredentialsForUser(user, [
+            'credential:read',
+        ]);
+        const responses = await Promise.all(providers.map(async (provider) => {
+            const credentials = {};
+            if (provider !== 'n8n') {
+                const credentialId = credentialIds[provider];
+                if (!credentialId) {
+                    return [provider, { models: [] }];
+                }
+                if (!allCredentials.some((credential) => credential.id === credentialId)) {
+                    return [
+                        provider,
+                        { models: [], error: 'Could not retrieve models. Verify credentials.' },
+                    ];
+                }
+                credentials[api_types_1.PROVIDER_CREDENTIAL_TYPE_MAP[provider]] = { name: '', id: credentialId };
             }
-            await this.credentialsService.getOne(user, credentialId, false);
             try {
-                const credentials = {
-                    [api_types_1.PROVIDER_CREDENTIAL_TYPE_MAP[provider]]: { name: '', id: credentialId },
-                };
                 return [
                     provider,
-                    await this.fetchModelsForProvider(provider, credentials, additionalData),
+                    await this.fetchModelsForProvider(user, provider, credentials, additionalData),
                 ];
             }
             catch {
@@ -95,9 +118,10 @@ let ChatHubService = class ChatHubService {
             openai: { models: [] },
             anthropic: { models: [] },
             google: { models: [] },
+            n8n: { models: [] },
         });
     }
-    async fetchModelsForProvider(provider, credentials, additionalData) {
+    async fetchModelsForProvider(user, provider, credentials, additionalData) {
         switch (provider) {
             case 'openai':
                 return await this.fetchOpenAiModels(credentials, additionalData);
@@ -105,18 +129,28 @@ let ChatHubService = class ChatHubService {
                 return await this.fetchAnthropicModels(credentials, additionalData);
             case 'google':
                 return await this.fetchGoogleModels(credentials, additionalData);
+            case 'n8n':
+                return await this.fetchCustomAgentWorkflows(user);
         }
     }
     async fetchOpenAiModels(credentials, additionalData) {
         const resourceLocatorResults = await this.nodeParametersService.getResourceLocatorResults('searchModels', 'parameters.model', additionalData, providerNodeTypeMapping.openai, {}, credentials);
         return {
-            models: resourceLocatorResults.results.map((result) => ({ name: String(result.value) })),
+            models: resourceLocatorResults.results.map((result) => ({
+                provider: 'openai',
+                name: String(result.value),
+                model: String(result.value),
+            })),
         };
     }
     async fetchAnthropicModels(credentials, additionalData) {
         const resourceLocatorResults = await this.nodeParametersService.getResourceLocatorResults('searchModels', 'parameters.model', additionalData, providerNodeTypeMapping.anthropic, {}, credentials);
         return {
-            models: resourceLocatorResults.results.map((result) => ({ name: String(result.value) })),
+            models: resourceLocatorResults.results.map((result) => ({
+                provider: 'anthropic',
+                name: String(result.value),
+                model: String(result.value),
+            })),
         };
     }
     async fetchGoogleModels(credentials, additionalData) {
@@ -159,27 +193,46 @@ let ChatHubService = class ChatHubService {
             },
         }, additionalData, providerNodeTypeMapping.google, {}, credentials);
         return {
-            models: results.map((result) => ({ name: String(result.value) })),
+            models: results.map((result) => ({
+                provider: 'google',
+                name: String(result.value),
+                model: String(result.value),
+            })),
         };
     }
-    async createChatWorkflow(user, sessionId, history, humanMessage, credentials, model) {
-        const { nodes, connections, startNodes, triggerToStartFrom } = this.prepareChatWorkflow(sessionId, history, humanMessage, credentials, model);
-        const { manager } = this.projectRepository;
-        return await manager.transaction(async (trx) => {
-            const project = await this.projectRepository.getPersonalProjectForUser(user.id, trx);
-            if (!project) {
-                throw new not_found_error_1.NotFoundError('Could not find a personal project for this user');
-            }
+    async fetchCustomAgentWorkflows(user) {
+        const nodeTypes = [n8n_workflow_1.CHAT_TRIGGER_NODE_TYPE];
+        const workflows = await this.workflowService.getWorkflowsWithNodesIncluded(user, nodeTypes);
+        return {
+            models: workflows
+                .filter((workflow) => workflow.active)
+                .map((workflow) => ({
+                provider: 'n8n',
+                name: workflow.name ?? 'Unnamed workflow',
+                workflowId: workflow.id,
+            })),
+        };
+    }
+    async createChatWorkflow(sessionId, projectId, history, humanMessage, credentials, model, generateConversationTitle, trx) {
+        return await (0, db_1.withTransaction)(this.workflowRepository.manager, trx, async (em) => {
+            const { nodes, connections, triggerToStartFrom } = this.prepareChatWorkflow({
+                sessionId,
+                history,
+                humanMessage,
+                credentials,
+                model,
+                generateConversationTitle,
+            });
             const newWorkflow = new db_1.WorkflowEntity();
             newWorkflow.versionId = (0, uuid_1.v4)();
             newWorkflow.name = `Chat ${sessionId}`;
             newWorkflow.active = false;
             newWorkflow.nodes = nodes;
             newWorkflow.connections = connections;
-            const workflow = await trx.save(newWorkflow);
-            await trx.save(this.sharedWorkflowRepository.create({
+            const workflow = await em.save(newWorkflow);
+            await em.save(this.sharedWorkflowRepository.create({
                 role: 'workflow:owner',
-                projectId: project.id,
+                projectId,
                 workflow,
             }));
             return {
@@ -189,11 +242,22 @@ let ChatHubService = class ChatHubService {
                     connections,
                     versionId: (0, uuid_1.v4)(),
                 },
-                startNodes,
                 triggerToStartFrom,
             };
         });
     }
+    async ensureCredentials(user, model, credentials, trx) {
+        const allCredentials = await this.credentialsFinderService.findAllCredentialsForUser(user, ['credential:read'], trx);
+        const credentialId = this.pickCredentialId(model.provider, credentials);
+        if (!credentialId) {
+            throw new bad_request_error_1.BadRequestError('No credentials provided for the selected model provider');
+        }
+        const credential = allCredentials.find((c) => c.id === credentialId);
+        if (!credential) {
+            throw new forbidden_error_1.ForbiddenError("You don't have access to the provided credentials");
+        }
+        return credential;
+    }
     async deleteChatWorkflow(workflowId) {
         await this.workflowRepository.delete(workflowId);
     }
@@ -203,8 +267,8 @@ let ChatHubService = class ChatHubService {
         }
         return undefined;
     }
-    getAIOutput(execution) {
-        const agent = execution.data.resultData.runData[NODE_NAMES.AI_AGENT];
+    getAIOutput(execution, nodeName) {
+        const agent = execution.data.resultData.runData[nodeName];
         if (!agent || !Array.isArray(agent) || agent.length === 0)
             return undefined;
         const runIndex = agent.length - 1;
@@ -220,49 +284,131 @@ let ChatHubService = class ChatHubService {
         }
         return undefined;
     }
-    getCredentialId(provider, credentials) {
+    pickCredentialId(provider, credentials) {
+        if (provider === 'n8n') {
+            return null;
+        }
         return credentials[api_types_1.PROVIDER_CREDENTIAL_TYPE_MAP[provider]]?.id ?? null;
     }
     async sendHumanMessage(res, user, payload) {
         const { sessionId, messageId, replyId, message } = payload;
+        const provider = payload.model.provider;
         const selectedModel = {
             ...payload.model,
-            credentialId: this.getCredentialId(payload.model.provider, payload.credentials),
+            credentialId: provider !== 'n8n' ? this.pickCredentialId(provider, payload.credentials) : null,
         };
-        const session = await this.getChatSession(user, sessionId, selectedModel, true, message);
-        if (payload.previousMessageId) {
-            const previousMessage = await this.messageRepository.getOneById(payload.previousMessageId, sessionId);
-            if (!previousMessage) {
-                throw new bad_request_error_1.BadRequestError('The previous message does not exist in the session');
+        const workflow = await this.messageRepository.manager.transaction(async (trx) => {
+            const session = await this.getChatSession(user, sessionId, selectedModel, true, trx);
+            await this.ensurePreviousMessage(payload.previousMessageId, sessionId, trx);
+            const messages = Object.fromEntries((session.messages ?? []).map((m) => [m.id, m]));
+            const history = this.buildMessageHistory(messages, payload.previousMessageId);
+            await this.saveHumanMessage(payload, user, payload.previousMessageId, selectedModel, undefined, trx);
+            if (provider !== 'n8n') {
+                return await this.prepareBaseChatWorkflow(user, payload, sessionId, history, message, trx);
             }
-        }
-        const messages = Object.fromEntries((session.messages ?? []).map((m) => [m.id, m]));
-        const history = this.buildMessageHistory(messages, payload.previousMessageId);
-        await this.saveHumanMessage(payload, user, payload.previousMessageId, selectedModel);
-        const workflow = await this.createChatWorkflow(user, session.id, history, message, payload.credentials, payload.model);
+            return await this.prepareCustomAgentWorkflow(user, sessionId, payload.model.workflowId, message);
+        });
         try {
             await this.executeChatWorkflow(res, user, workflow, replyId, sessionId, messageId, selectedModel);
         }
         finally {
-            await this.deleteChatWorkflow(workflow.workflowData.id);
+            if (provider !== 'n8n') {
+                await this.deleteChatWorkflow(workflow.workflowData.id);
+            }
         }
     }
-    async editHumanMessage(res, user, payload) {
-        const { sessionId, editId, messageId, message, replyId } = payload;
+    async prepareBaseChatWorkflow(user, payload, sessionId, history, message, trx) {
+        const credential = await this.ensureCredentials(user, payload.model, payload.credentials, trx);
+        return await this.createChatWorkflow(sessionId, credential.projectId, history, message, payload.credentials, payload.model, payload.previousMessageId === null, trx);
+    }
+    async prepareCustomAgentWorkflow(user, sessionId, workflowId, message) {
+        const workflowEntity = await this.workflowFinderService.findWorkflowForUser(workflowId, user, ['workflow:read'], { includeTags: false, includeParentFolder: false });
+        if (!workflowEntity) {
+            throw new bad_request_error_1.BadRequestError('Workflow not found');
+        }
+        const chatTriggers = workflowEntity.nodes.filter((node) => node.type === n8n_workflow_1.CHAT_TRIGGER_NODE_TYPE);
+        if (chatTriggers.length !== 1) {
+            throw new bad_request_error_1.BadRequestError('Workflow must have exactly one chat trigger');
+        }
+        const chatResponseNodes = workflowEntity.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 agents = workflowEntity.nodes.filter((node) => node.type === n8n_workflow_1.AGENT_LANGCHAIN_NODE_TYPE);
+        if (agents.length !== 1) {
+            throw new bad_request_error_1.BadRequestError('Workflow must have exactly one AI Agent node');
+        }
+        return {
+            workflowData: {
+                ...workflowEntity,
+                pinData: {},
+            },
+            triggerToStartFrom: {
+                name: chatTriggers[0].name,
+                data: {
+                    startTime: Date.now(),
+                    executionTime: 0,
+                    executionIndex: 0,
+                    executionStatus: 'success',
+                    data: {
+                        main: [
+                            [
+                                {
+                                    json: {
+                                        sessionId,
+                                        action: 'sendMessage',
+                                        chatInput: message,
+                                    },
+                                },
+                            ],
+                        ],
+                    },
+                    source: [null],
+                },
+            },
+        };
+    }
+    async ensurePreviousMessage(previousMessageId, sessionId, trx) {
+        if (!previousMessageId) {
+            return;
+        }
+        const previousMessage = await this.messageRepository.getOneById(previousMessageId, sessionId, [], trx);
+        if (!previousMessage) {
+            throw new bad_request_error_1.BadRequestError('The previous message does not exist in the session');
+        }
+    }
+    async editMessage(res, user, payload) {
+        const { sessionId, editId, messageId, replyId } = payload;
         const selectedModel = {
             ...payload.model,
-            credentialId: this.getCredentialId(payload.model.provider, payload.credentials),
+            credentialId: payload.model.provider !== 'n8n'
+                ? this.pickCredentialId(payload.model.provider, payload.credentials)
+                : null,
         };
-        const session = await this.getChatSession(user, sessionId);
-        const messageToEdit = await this.getChatMessage(session.id, editId);
-        if (messageToEdit.type !== 'human') {
-            throw new bad_request_error_1.BadRequestError('Can only edit human messages');
-        }
-        const messages = Object.fromEntries((session.messages ?? []).map((m) => [m.id, m]));
-        const history = this.buildMessageHistory(messages, messageToEdit.previousMessageId);
-        const revisionOfMessageId = messageToEdit.revisionOfMessageId ?? messageToEdit.id;
-        await this.saveHumanMessage(payload, user, messageToEdit.previousMessageId, selectedModel, revisionOfMessageId);
-        const workflow = await this.createChatWorkflow(user, session.id, history, message, payload.credentials, payload.model);
+        const workflow = await this.messageRepository.manager.transaction(async (trx) => {
+            const credential = await this.ensureCredentials(user, payload.model, payload.credentials, trx);
+            const session = await this.getChatSession(user, sessionId, undefined, false, trx);
+            const messageToEdit = await this.getChatMessage(session.id, editId, [], trx);
+            if (!['ai', 'human'].includes(messageToEdit.type)) {
+                throw new bad_request_error_1.BadRequestError('Only human and AI messages can be edited');
+            }
+            if (messageToEdit.type === 'ai') {
+                await this.messageRepository.updateChatMessage(editId, { content: payload.message }, trx);
+                return null;
+            }
+            if (messageToEdit.type === 'human') {
+                const { message } = payload;
+                const messages = Object.fromEntries((session.messages ?? []).map((m) => [m.id, m]));
+                const history = this.buildMessageHistory(messages, messageToEdit.previousMessageId);
+                const revisionOfMessageId = messageToEdit.revisionOfMessageId ?? messageToEdit.id;
+                await this.saveHumanMessage(payload, user, messageToEdit.previousMessageId, selectedModel, revisionOfMessageId, trx);
+                return await this.createChatWorkflow(session.id, credential.projectId, history, message, payload.credentials, payload.model, messageToEdit.previousMessageId === null, trx);
+            }
+            return null;
+        });
+        if (!workflow) {
+            return;
+        }
         try {
             await this.executeChatWorkflow(res, user, workflow, replyId, sessionId, messageId, selectedModel);
         }
@@ -274,27 +420,37 @@ let ChatHubService = class ChatHubService {
         const { sessionId, retryId, replyId } = payload;
         const selectedModel = {
             ...payload.model,
-            credentialId: this.getCredentialId(payload.model.provider, payload.credentials),
+            credentialId: payload.model.provider !== 'n8n'
+                ? this.pickCredentialId(payload.model.provider, payload.credentials)
+                : null,
         };
-        const session = await this.getChatSession(user, sessionId);
-        const messageToRetry = await this.getChatMessage(session.id, retryId);
-        if (messageToRetry.type !== 'ai') {
-            throw new bad_request_error_1.BadRequestError('Can only retry AI messages');
-        }
-        const messages = Object.fromEntries((session.messages ?? []).map((m) => [m.id, m]));
-        const history = this.buildMessageHistory(messages, messageToRetry.previousMessageId);
-        const lastHumanMessage = history.filter((m) => m.type === 'human').pop();
-        if (!lastHumanMessage) {
-            throw new bad_request_error_1.BadRequestError('No human message found to base the retry on');
-        }
-        const lastHumanMessageIndex = history.indexOf(lastHumanMessage);
-        if (lastHumanMessageIndex !== -1) {
-            history.splice(lastHumanMessageIndex + 1);
-        }
-        const retryOfMessageId = messageToRetry.retryOfMessageId ?? messageToRetry.id;
-        const workflow = await this.createChatWorkflow(user, session.id, history, lastHumanMessage ? lastHumanMessage.content : '', payload.credentials, payload.model);
+        const { workflow, retryOfMessageId, previousMessageId } = await this.messageRepository.manager.transaction(async (trx) => {
+            const credential = await this.ensureCredentials(user, payload.model, payload.credentials, trx);
+            const session = await this.getChatSession(user, sessionId, undefined, false, trx);
+            const messageToRetry = await this.getChatMessage(session.id, retryId, [], trx);
+            if (messageToRetry.type !== 'ai') {
+                throw new bad_request_error_1.BadRequestError('Can only retry AI messages');
+            }
+            const messages = Object.fromEntries((session.messages ?? []).map((m) => [m.id, m]));
+            const history = this.buildMessageHistory(messages, messageToRetry.previousMessageId);
+            const lastHumanMessage = history.filter((m) => m.type === 'human').pop();
+            if (!lastHumanMessage) {
+                throw new bad_request_error_1.BadRequestError('No human message found to base the retry on');
+            }
+            const lastHumanMessageIndex = history.indexOf(lastHumanMessage);
+            if (lastHumanMessageIndex !== -1) {
+                history.splice(lastHumanMessageIndex + 1);
+            }
+            const retryOfMessageId = messageToRetry.retryOfMessageId ?? messageToRetry.id;
+            const workflow = await this.createChatWorkflow(session.id, credential.projectId, history, lastHumanMessage ? lastHumanMessage.content : '', payload.credentials, payload.model, false, trx);
+            return {
+                workflow,
+                previousMessageId: lastHumanMessage.id,
+                retryOfMessageId,
+            };
+        });
         try {
-            await this.executeChatWorkflow(res, user, workflow, replyId, sessionId, lastHumanMessage.id, selectedModel, retryOfMessageId);
+            await this.executeChatWorkflow(res, user, workflow, replyId, sessionId, previousMessageId, selectedModel, retryOfMessageId);
         }
         finally {
             await this.deleteChatWorkflow(workflow.workflowData.id);
@@ -319,13 +475,22 @@ let ChatHubService = class ChatHubService {
         await this.messageRepository.updateChatMessage(messageId, { status: 'cancelled' });
     }
     async executeChatWorkflow(res, user, workflow, replyId, sessionId, previousMessageId, selectedModel, retryOfMessageId) {
-        const { workflowData, startNodes, triggerToStartFrom } = workflow;
+        const { workflowData, triggerToStartFrom } = workflow;
         this.logger.debug(`Starting execution of workflow "${workflowData.name}" with ID ${workflowData.id}`);
+        let partialMessage = '';
+        const onChunk = (chunk) => {
+            const data = (0, n8n_workflow_1.jsonParse)(chunk);
+            if (data && data.type === 'item' && typeof data.content === 'string') {
+                partialMessage += data.content;
+            }
+        };
+        const stream = (0, stream_capturer_1.captureResponseWrites)(res, onChunk);
+        stream.writeHead(200, JSONL_STREAM_HEADERS);
+        stream.flushHeaders();
         const { executionId } = await this.workflowExecutionService.executeManually({
             workflowData,
-            startNodes,
             triggerToStartFrom,
-        }, user, undefined, true, res);
+        }, user, undefined, true, stream);
         if (!executionId) {
             throw new n8n_workflow_1.OperationalError('There was a problem starting the chat execution.');
         }
@@ -334,7 +499,7 @@ let ChatHubService = class ChatHubService {
             sessionId,
             executionId,
             previousMessageId,
-            message: '',
+            message: partialMessage,
             selectedModel,
             retryOfMessageId,
             status: 'running',
@@ -356,9 +521,8 @@ let ChatHubService = class ChatHubService {
                         throw new n8n_workflow_1.OperationalError(`Could not find execution with ID ${executionId}`);
                     }
                     if (execution.status === 'canceled') {
-                        const message = 'Generation cancelled.';
                         await this.messageRepository.updateChatMessage(replyId, {
-                            content: message,
+                            content: partialMessage || 'Generation cancelled.',
                             status: 'cancelled',
                         });
                         return;
@@ -376,14 +540,14 @@ let ChatHubService = class ChatHubService {
                 const message = this.getErrorMessage(execution) ?? 'Failed to generate a response';
                 throw new n8n_workflow_1.OperationalError(message);
             }
-            const message = this.getAIOutput(execution);
-            if (!message) {
-                throw new n8n_workflow_1.OperationalError('No response generated');
-            }
             await this.messageRepository.updateChatMessage(replyId, {
-                content: message,
+                content: partialMessage,
                 status: 'success',
             });
+            const title = this.getAIOutput(execution, NODE_NAMES.TITLE_GENERATOR_AGENT);
+            if (title) {
+                await this.sessionRepository.updateChatTitle(sessionId, title);
+            }
         }
         catch (error) {
             const message = error instanceof Error ? error.message : 'Unknown error';
@@ -393,7 +557,7 @@ let ChatHubService = class ChatHubService {
             });
         }
     }
-    prepareChatWorkflow(sessionId, history, humanMessage, credentials, model) {
+    prepareChatWorkflow({ sessionId, history, humanMessage, credentials, model, generateConversationTitle, }) {
         const nodes = [
             {
                 parameters: {
@@ -414,14 +578,16 @@ let ChatHubService = class ChatHubService {
                     text: "={{ $('When chat message received').item.json.chatInput }}",
                     options: {
                         enableStreaming: true,
-                        maxTokensFromMemory: (0, context_limits_1.getMaxContextWindowTokens)(model.provider, model.model),
+                        maxTokensFromMemory: model.provider !== 'n8n'
+                            ? (0, context_limits_1.getMaxContextWindowTokens)(model.provider, model.model)
+                            : undefined,
                     },
                 },
                 type: n8n_workflow_1.AGENT_LANGCHAIN_NODE_TYPE,
                 typeVersion: 3,
                 position: [600, 0],
                 id: (0, uuid_1.v4)(),
-                name: NODE_NAMES.AI_AGENT,
+                name: NODE_NAMES.REPLY_AGENT,
             },
             this.createModelNode(credentials, model),
             {
@@ -472,6 +638,22 @@ let ChatHubService = class ChatHubService {
                 id: (0, uuid_1.v4)(),
                 name: NODE_NAMES.CLEAR_CHAT_MEMORY,
             },
+            {
+                disabled: !generateConversationTitle,
+                parameters: {
+                    promptType: 'define',
+                    text: "={{ $('When chat message received').item.json.chatInput }}",
+                    options: {
+                        enableStreaming: false,
+                        systemMessage: chat_hub_constants_1.CONVERSATION_TITLE_GENERATION_PROMPT,
+                    },
+                },
+                type: n8n_workflow_1.AGENT_LANGCHAIN_NODE_TYPE,
+                typeVersion: 3,
+                position: [224, 360],
+                id: (0, uuid_1.v4)(),
+                name: NODE_NAMES.TITLE_GENERATOR_AGENT,
+            },
         ];
         const connections = {
             [NODE_NAMES.CHAT_TRIGGER]: {
@@ -480,23 +662,35 @@ let ChatHubService = class ChatHubService {
                 ],
             },
             [NODE_NAMES.RESTORE_CHAT_MEMORY]: {
-                main: [[{ node: NODE_NAMES.AI_AGENT, type: n8n_workflow_1.NodeConnectionTypes.Main, index: 0 }]],
+                main: [
+                    [
+                        { node: NODE_NAMES.REPLY_AGENT, type: n8n_workflow_1.NodeConnectionTypes.Main, index: 0 },
+                        { node: NODE_NAMES.TITLE_GENERATOR_AGENT, type: n8n_workflow_1.NodeConnectionTypes.Main, index: 0 },
+                    ],
+                ],
             },
             [NODE_NAMES.CHAT_MODEL]: {
                 ai_languageModel: [
-                    [{ node: NODE_NAMES.AI_AGENT, type: n8n_workflow_1.NodeConnectionTypes.AiLanguageModel, index: 0 }],
+                    [
+                        { node: NODE_NAMES.REPLY_AGENT, type: n8n_workflow_1.NodeConnectionTypes.AiLanguageModel, index: 0 },
+                        {
+                            node: NODE_NAMES.TITLE_GENERATOR_AGENT,
+                            type: n8n_workflow_1.NodeConnectionTypes.AiLanguageModel,
+                            index: 0,
+                        },
+                    ],
                 ],
             },
             [NODE_NAMES.MEMORY]: {
                 ai_memory: [
                     [
-                        { node: NODE_NAMES.AI_AGENT, type: n8n_workflow_1.NodeConnectionTypes.AiMemory, index: 0 },
+                        { node: NODE_NAMES.REPLY_AGENT, type: n8n_workflow_1.NodeConnectionTypes.AiMemory, index: 0 },
                         { node: NODE_NAMES.RESTORE_CHAT_MEMORY, type: n8n_workflow_1.NodeConnectionTypes.AiMemory, index: 0 },
                         { node: NODE_NAMES.CLEAR_CHAT_MEMORY, type: n8n_workflow_1.NodeConnectionTypes.AiMemory, index: 0 },
                     ],
                 ],
             },
-            [NODE_NAMES.AI_AGENT]: {
+            [NODE_NAMES.REPLY_AGENT]: {
                 main: [
                     [
                         {
@@ -508,7 +702,6 @@ let ChatHubService = class ChatHubService {
                 ],
             },
         };
-        const startNodes = [{ name: 'Restore Chat Memory', sourceData: null }];
         const triggerToStartFrom = {
             name: NODE_NAMES.CHAT_TRIGGER,
             data: {
@@ -532,9 +725,9 @@ let ChatHubService = class ChatHubService {
                 source: [null],
             },
         };
-        return { nodes, connections, startNodes, triggerToStartFrom };
+        return { nodes, connections, triggerToStartFrom };
     }
-    async saveHumanMessage(payload, user, previousMessageId, selectedModel, revisionOfMessageId) {
+    async saveHumanMessage(payload, user, previousMessageId, selectedModel, revisionOfMessageId, trx) {
         await this.messageRepository.createChatMessage({
             id: payload.messageId,
             sessionId: payload.sessionId,
@@ -545,7 +738,7 @@ let ChatHubService = class ChatHubService {
             previousMessageId,
             revisionOfMessageId,
             ...selectedModel,
-        });
+        }, trx);
     }
     async saveAIMessage({ id, sessionId, executionId, previousMessageId, message, selectedModel, retryOfMessageId, status, }) {
         await this.messageRepository.createChatMessage({
@@ -561,8 +754,8 @@ let ChatHubService = class ChatHubService {
             ...selectedModel,
         });
     }
-    async getChatSession(user, sessionId, selectedModel, initialize = false, title = null) {
-        const existing = await this.sessionRepository.getOneById(sessionId, user.id);
+    async getChatSession(user, sessionId, selectedModel, initialize = false, trx) {
+        const existing = await this.sessionRepository.getOneById(sessionId, user.id, trx);
         if (existing) {
             return existing;
         }
@@ -572,20 +765,24 @@ let ChatHubService = class ChatHubService {
         return await this.sessionRepository.createChatSession({
             id: sessionId,
             ownerId: user.id,
-            title: title ?? 'New Chat',
+            title: 'New Chat',
             ...selectedModel,
-        });
+        }, trx);
     }
-    async getChatMessage(sessionId, messageId, relations = []) {
-        const message = await this.messageRepository.getOneById(messageId, sessionId, relations);
+    async getChatMessage(sessionId, messageId, relations = [], trx) {
+        const message = await this.messageRepository.getOneById(messageId, sessionId, relations, trx);
         if (!message) {
             throw new not_found_error_1.NotFoundError('Chat message not found');
         }
         return message;
     }
-    createModelNode(credentials, { provider, model }) {
+    createModelNode(credentials, conversationModel) {
+        if (conversationModel.provider === 'n8n') {
+            throw new n8n_workflow_1.OperationalError('Custom agent workflows do not require a model node');
+        }
+        const { provider, model } = conversationModel;
         const common = {
-            position: [600, 200],
+            position: [600, 500],
             id: (0, uuid_1.v4)(),
             name: 'Chat Model',
             credentials,
@@ -719,16 +916,17 @@ exports.ChatHubService = ChatHubService;
 exports.ChatHubService = ChatHubService = __decorate([
     (0, di_1.Service)(),
     __metadata("design:paramtypes", [backend_common_1.Logger,
-        credentials_service_1.CredentialsService,
         execution_service_1.ExecutionService,
         dynamic_node_parameters_service_1.DynamicNodeParametersService,
         db_1.ExecutionRepository,
         workflow_execution_service_1.WorkflowExecutionService,
+        workflow_service_1.WorkflowService,
+        workflow_finder_service_1.WorkflowFinderService,
         db_1.WorkflowRepository,
-        db_1.ProjectRepository,
         db_1.SharedWorkflowRepository,
         active_executions_1.ActiveExecutions,
         chat_session_repository_1.ChatHubSessionRepository,
-        chat_message_repository_1.ChatHubMessageRepository])
+        chat_message_repository_1.ChatHubMessageRepository,
+        credentials_finder_service_1.CredentialsFinderService])
 ], ChatHubService);
 //# sourceMappingURL=chat-hub.service.js.map