n8n 1.118.1 → 1.119.0

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

@@ -15,11 +15,9 @@ const backend_common_1 = require("@n8n/backend-common");
 const db_1 = require("@n8n/db");
 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_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");
@@ -27,42 +25,15 @@ const workflow_execute_additional_data_1 = require("../../workflow-execute-addit
 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_agent_service_1 = require("./chat-hub-agent.service");
+const chat_hub_credentials_service_1 = require("./chat-hub-credentials.service");
+const chat_hub_workflow_service_1 = require("./chat-hub-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',
-        version: 1.2,
-    },
-    anthropic: {
-        name: '@n8n/n8n-nodes-langchain.lmChatAnthropic',
-        version: 1.3,
-    },
-    google: {
-        name: '@n8n/n8n-nodes-langchain.lmChatGoogleGemini',
-        version: 1.2,
-    },
-};
-const NODE_NAMES = {
-    CHAT_TRIGGER: 'When chat message received',
-    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, executionService, nodeParametersService, executionRepository, workflowExecutionService, workflowService, workflowFinderService, workflowRepository, sharedWorkflowRepository, activeExecutions, sessionRepository, messageRepository, credentialsFinderService) {
+    constructor(logger, executionService, nodeParametersService, executionRepository, workflowExecutionService, workflowService, workflowFinderService, workflowRepository, activeExecutions, sessionRepository, messageRepository, credentialsFinderService, chatHubAgentService, chatHubCredentialsService, chatHubWorkflowService) {
         this.logger = logger;
         this.executionService = executionService;
         this.nodeParametersService = nodeParametersService;
@@ -71,21 +42,23 @@ let ChatHubService = class ChatHubService {
         this.workflowService = workflowService;
         this.workflowFinderService = workflowFinderService;
         this.workflowRepository = workflowRepository;
-        this.sharedWorkflowRepository = sharedWorkflowRepository;
         this.activeExecutions = activeExecutions;
         this.sessionRepository = sessionRepository;
         this.messageRepository = messageRepository;
         this.credentialsFinderService = credentialsFinderService;
+        this.chatHubAgentService = chatHubAgentService;
+        this.chatHubCredentialsService = chatHubCredentialsService;
+        this.chatHubWorkflowService = chatHubWorkflowService;
     }
     async getModels(user, credentialIds) {
         const additionalData = await (0, workflow_execute_additional_data_1.getBase)({ userId: user.id });
-        const providers = ['openai', 'anthropic', 'google'];
+        const providers = api_types_1.chatHubProviderSchema.options;
         const allCredentials = await this.credentialsFinderService.findCredentialsForUser(user, [
             'credential:read',
         ]);
         const responses = await Promise.all(providers.map(async (provider) => {
             const credentials = {};
-            if (provider !== 'n8n') {
+            if (provider !== 'n8n' && provider !== 'custom-agent') {
                 const credentialId = credentialIds[provider];
                 if (!credentialId) {
                     return [provider, { models: [] }];
@@ -114,12 +87,7 @@ let ChatHubService = class ChatHubService {
         return responses.reduce((acc, [provider, res]) => {
             acc[provider] = res;
             return acc;
-        }, {
-            openai: { models: [] },
-            anthropic: { models: [] },
-            google: { models: [] },
-            n8n: { models: [] },
-        });
+        }, { ...api_types_1.emptyChatModelsResponse });
     }
     async fetchModelsForProvider(user, provider, credentials, additionalData) {
         switch (provider) {
@@ -130,26 +98,38 @@ let ChatHubService = class ChatHubService {
             case 'google':
                 return await this.fetchGoogleModels(credentials, additionalData);
             case 'n8n':
-                return await this.fetchCustomAgentWorkflows(user);
+                return await this.fetchAgentWorkflowsAsModels(user);
+            case 'custom-agent':
+                return await this.chatHubAgentService.getAgentsByUserIdAsModels(user.id);
         }
     }
     async fetchOpenAiModels(credentials, additionalData) {
-        const resourceLocatorResults = await this.nodeParametersService.getResourceLocatorResults('searchModels', 'parameters.model', additionalData, providerNodeTypeMapping.openai, {}, credentials);
+        const resourceLocatorResults = await this.nodeParametersService.getResourceLocatorResults('searchModels', 'parameters.model', additionalData, chat_hub_constants_1.PROVIDER_NODE_TYPE_MAP.openai, {}, credentials);
         return {
             models: resourceLocatorResults.results.map((result) => ({
-                provider: 'openai',
-                name: String(result.value),
-                model: String(result.value),
+                name: result.name,
+                description: result.description ?? null,
+                model: {
+                    provider: 'openai',
+                    model: String(result.value),
+                },
+                createdAt: null,
+                updatedAt: null,
             })),
         };
     }
     async fetchAnthropicModels(credentials, additionalData) {
-        const resourceLocatorResults = await this.nodeParametersService.getResourceLocatorResults('searchModels', 'parameters.model', additionalData, providerNodeTypeMapping.anthropic, {}, credentials);
+        const resourceLocatorResults = await this.nodeParametersService.getResourceLocatorResults('searchModels', 'parameters.model', additionalData, chat_hub_constants_1.PROVIDER_NODE_TYPE_MAP.anthropic, {}, credentials);
         return {
             models: resourceLocatorResults.results.map((result) => ({
-                provider: 'anthropic',
-                name: String(result.value),
-                model: String(result.value),
+                name: result.name,
+                description: result.description ?? null,
+                model: {
+                    provider: 'anthropic',
+                    model: String(result.value),
+                },
+                createdAt: null,
+                updatedAt: null,
             })),
         };
     }
@@ -191,73 +171,57 @@ let ChatHubService = class ChatHubService {
                     ],
                 },
             },
-        }, additionalData, providerNodeTypeMapping.google, {}, credentials);
+        }, additionalData, chat_hub_constants_1.PROVIDER_NODE_TYPE_MAP.google, {}, credentials);
         return {
             models: results.map((result) => ({
-                provider: 'google',
                 name: String(result.value),
-                model: String(result.value),
+                description: result.description ?? null,
+                model: {
+                    provider: 'google',
+                    model: String(result.value),
+                },
+                createdAt: null,
+                updatedAt: null,
             })),
         };
     }
-    async fetchCustomAgentWorkflows(user) {
+    async fetchAgentWorkflowsAsModels(user) {
         const nodeTypes = [n8n_workflow_1.CHAT_TRIGGER_NODE_TYPE];
-        const workflows = await this.workflowService.getWorkflowsWithNodesIncluded(user, nodeTypes);
+        const workflows = await this.workflowService.getWorkflowsWithNodesIncluded(user, nodeTypes, true);
         return {
             models: workflows
+                .filter((workflow) => workflow.scopes.includes('workflow:read'))
                 .filter((workflow) => workflow.active)
-                .map((workflow) => ({
-                provider: 'n8n',
-                name: workflow.name ?? 'Unnamed workflow',
-                workflowId: workflow.id,
-            })),
+                .flatMap((workflow) => {
+                const chatTrigger = workflow.nodes?.find((node) => node.type === n8n_workflow_1.CHAT_TRIGGER_NODE_TYPE);
+                if (!chatTrigger) {
+                    return [];
+                }
+                if (chatTrigger.parameters.availableInChat !== true) {
+                    return [];
+                }
+                const name = typeof chatTrigger.parameters.agentName === 'string' &&
+                    chatTrigger.parameters.agentName.length > 0
+                    ? chatTrigger.parameters.agentName
+                    : workflow.name;
+                return [
+                    {
+                        name: name ?? 'Unknown Agent',
+                        description: typeof chatTrigger.parameters.agentDescription === 'string' &&
+                            chatTrigger.parameters.agentDescription.length > 0
+                            ? chatTrigger.parameters.agentDescription
+                            : null,
+                        model: {
+                            provider: 'n8n',
+                            workflowId: workflow.id,
+                        },
+                        createdAt: workflow.createdAt ? workflow.createdAt.toISOString() : null,
+                        updatedAt: workflow.updatedAt ? workflow.updatedAt.toISOString() : null,
+                    },
+                ];
+            }),
         };
     }
-    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 em.save(newWorkflow);
-            await em.save(this.sharedWorkflowRepository.create({
-                role: 'workflow:owner',
-                projectId,
-                workflow,
-            }));
-            return {
-                workflowData: {
-                    ...workflow,
-                    nodes,
-                    connections,
-                    versionId: (0, uuid_1.v4)(),
-                },
-                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);
     }
@@ -285,109 +249,42 @@ let ChatHubService = class ChatHubService {
         return undefined;
     }
     pickCredentialId(provider, credentials) {
-        if (provider === 'n8n') {
+        if (provider === 'n8n' || provider === 'custom-agent') {
             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: provider !== 'n8n' ? this.pickCredentialId(provider, payload.credentials) : null,
-        };
-        const workflow = await this.messageRepository.manager.transaction(async (trx) => {
+        const { sessionId, messageId, message, model, credentials, previousMessageId } = payload;
+        const { provider } = model;
+        const selectedModel = this.getModelWithCredentials(model, credentials);
+        const { executionData, workflowData } = await this.messageRepository.manager.transaction(async (trx) => {
             const session = await this.getChatSession(user, sessionId, selectedModel, true, trx);
-            await this.ensurePreviousMessage(payload.previousMessageId, sessionId, trx);
+            await this.ensurePreviousMessage(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 history = this.buildMessageHistory(messages, previousMessageId);
+            await this.saveHumanMessage(payload, user, previousMessageId, selectedModel, undefined, trx);
+            if (provider === 'n8n') {
+                return await this.prepareCustomAgentWorkflow(user, sessionId, model.workflowId, message);
             }
-            return await this.prepareCustomAgentWorkflow(user, sessionId, payload.model.workflowId, message);
-        });
-        try {
-            await this.executeChatWorkflow(res, user, workflow, replyId, sessionId, messageId, selectedModel);
-        }
-        finally {
-            if (provider !== 'n8n') {
-                await this.deleteChatWorkflow(workflow.workflowData.id);
+            if (provider === 'custom-agent') {
+                return await this.prepareChatAgentWorkflow(model.agentId, user, sessionId, history, message, trx);
             }
-        }
-    }
-    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');
+            return await this.prepareBaseChatWorkflow(user, sessionId, credentials, model, history, message, undefined, trx);
+        });
+        await this.executeChatWorkflowWithCleanup(res, user, workflowData, executionData, sessionId, messageId, selectedModel, provider);
+        if (previousMessageId === null) {
+            await this.generateSessionTitle(user, sessionId, message, credentials, model).catch((error) => {
+                this.logger.error(`Title generation failed: ${error}`);
+            });
         }
     }
     async editMessage(res, user, payload) {
-        const { sessionId, editId, messageId, replyId } = payload;
-        const selectedModel = {
-            ...payload.model,
-            credentialId: payload.model.provider !== 'n8n'
-                ? this.pickCredentialId(payload.model.provider, payload.credentials)
-                : null,
-        };
+        const { sessionId, editId, messageId, message, model, credentials } = payload;
+        const { provider } = model;
+        const selectedModel = this.getModelWithCredentials(model, credentials);
         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 session = await this.getChatSession(user, sessionId, selectedModel, true, 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');
@@ -397,35 +294,31 @@ let ChatHubService = class ChatHubService {
                 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);
+                if (provider === 'n8n') {
+                    return await this.prepareCustomAgentWorkflow(user, sessionId, model.workflowId, message);
+                }
+                if (provider === 'custom-agent') {
+                    return await this.prepareChatAgentWorkflow(model.agentId, user, sessionId, history, message, trx);
+                }
+                return await this.prepareBaseChatWorkflow(user, sessionId, credentials, model, history, message, undefined, trx);
             }
             return null;
         });
         if (!workflow) {
             return;
         }
-        try {
-            await this.executeChatWorkflow(res, user, workflow, replyId, sessionId, messageId, selectedModel);
-        }
-        finally {
-            await this.deleteChatWorkflow(workflow.workflowData.id);
-        }
+        const { workflowData, executionData } = workflow;
+        await this.executeChatWorkflowWithCleanup(res, user, workflowData, executionData, sessionId, messageId, selectedModel, provider);
     }
     async regenerateAIMessage(res, user, payload) {
-        const { sessionId, retryId, replyId } = payload;
-        const selectedModel = {
-            ...payload.model,
-            credentialId: payload.model.provider !== 'n8n'
-                ? this.pickCredentialId(payload.model.provider, payload.credentials)
-                : null,
-        };
-        const { workflow, retryOfMessageId, previousMessageId } = await this.messageRepository.manager.transaction(async (trx) => {
-            const credential = await this.ensureCredentials(user, payload.model, payload.credentials, trx);
+        const { sessionId, retryId, model, credentials } = payload;
+        const { provider } = model;
+        const selectedModel = this.getModelWithCredentials(model, credentials);
+        const { workflow: { workflowData, executionData }, retryOfMessageId, previousMessageId, } = await this.messageRepository.manager.transaction(async (trx) => {
             const session = await this.getChatSession(user, sessionId, undefined, false, trx);
             const messageToRetry = await this.getChatMessage(session.id, retryId, [], trx);
             if (messageToRetry.type !== 'ai') {
@@ -442,18 +335,120 @@ let ChatHubService = class ChatHubService {
                 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);
+            const message = lastHumanMessage ? lastHumanMessage.content : '';
+            let workflow;
+            if (provider === 'n8n') {
+                workflow = await this.prepareCustomAgentWorkflow(user, sessionId, model.workflowId, message);
+            }
+            else if (provider === 'custom-agent') {
+                workflow = await this.prepareChatAgentWorkflow(model.agentId, user, sessionId, history, message, trx);
+            }
+            else {
+                workflow = await this.prepareBaseChatWorkflow(user, sessionId, credentials, model, history, message, undefined, trx);
+            }
             return {
                 workflow,
                 previousMessageId: lastHumanMessage.id,
                 retryOfMessageId,
             };
         });
-        try {
-            await this.executeChatWorkflow(res, user, workflow, replyId, sessionId, previousMessageId, selectedModel, retryOfMessageId);
+        await this.executeChatWorkflowWithCleanup(res, user, workflowData, executionData, sessionId, previousMessageId, selectedModel, provider, retryOfMessageId);
+    }
+    async prepareBaseChatWorkflow(user, sessionId, credentials, model, history, message, systemMessage, trx) {
+        const credential = await this.chatHubCredentialsService.ensureCredentials(user, model.provider, credentials, trx);
+        return await this.chatHubWorkflowService.createChatWorkflow(user.id, sessionId, credential.projectId, history, message, credentials, model, systemMessage, trx);
+    }
+    async prepareChatAgentWorkflow(agentId, user, sessionId, history, message, trx) {
+        const agent = await this.chatHubAgentService.getAgentById(agentId, user.id);
+        if (!agent) {
+            throw new bad_request_error_1.BadRequestError('Agent not found');
         }
-        finally {
-            await this.deleteChatWorkflow(workflow.workflowData.id);
+        if (!agent.provider || !agent.model) {
+            throw new bad_request_error_1.BadRequestError('Provider or model not set for agent');
+        }
+        if (agent.provider === 'n8n' || agent.provider === 'custom-agent') {
+            throw new bad_request_error_1.BadRequestError('Invalid provider');
+        }
+        const credentialId = agent.credentialId;
+        if (!credentialId) {
+            throw new bad_request_error_1.BadRequestError('Credentials not set for agent');
+        }
+        const systemMessage = agent.systemPrompt;
+        const model = {
+            provider: agent.provider,
+            model: agent.model,
+        };
+        const credentials = {
+            [api_types_1.PROVIDER_CREDENTIAL_TYPE_MAP[agent.provider]]: {
+                id: credentialId,
+                name: '',
+            },
+        };
+        return await this.prepareBaseChatWorkflow(user, sessionId, credentials, model, history, message, systemMessage, 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 chatTriggerNode = chatTriggers[0];
+        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 nodeExecutionStack = [
+            {
+                node: chatTriggerNode,
+                data: {
+                    main: [
+                        [
+                            {
+                                json: {
+                                    sessionId,
+                                    action: 'sendMessage',
+                                    chatInput: message,
+                                },
+                            },
+                        ],
+                    ],
+                },
+                source: null,
+            },
+        ];
+        const executionData = {
+            startData: {},
+            resultData: {
+                runData: {},
+            },
+            executionData: {
+                contextData: {},
+                metadata: {},
+                nodeExecutionStack,
+                waitingExecution: {},
+                waitingExecutionSource: {},
+            },
+            manualData: {
+                userId: user.id,
+            },
+        };
+        return {
+            workflowData: {
+                ...workflowEntity,
+            },
+            executionData,
+        };
+    }
+    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 stopGeneration(user, sessionId, messageId) {
@@ -474,286 +469,281 @@ 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, workflow, replyId, sessionId, previousMessageId, selectedModel, retryOfMessageId) {
-        const { workflowData, triggerToStartFrom } = workflow;
+    async executeChatWorkflow(res, user, workflowData, executionData, sessionId, previousMessageId, selectedModel, retryOfMessageId = null) {
         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;
+        let executionId = undefined;
+        const aggregator = (0, stream_capturer_1.createStructuredChunkAggregator)(previousMessageId, retryOfMessageId, {
+            onBegin: async (message) => {
+                await this.saveAIMessage({
+                    ...message,
+                    sessionId,
+                    executionId,
+                    selectedModel,
+                    retryOfMessageId,
+                });
+            },
+            onItem: (_message, _chunk) => {
+            },
+            onEnd: async (message) => {
+                await this.messageRepository.updateChatMessage(message.id, {
+                    content: message.content,
+                    status: message.status,
+                });
+            },
+            onError: async (message, _errorText) => {
+                await this.messageRepository.manager.transaction(async (trx) => {
+                    await this.messageRepository.updateChatMessage(message.id, {
+                        content: message.content,
+                    }, trx);
+                    const savedMessage = await this.messageRepository.getOneById(message.id, sessionId, [], trx);
+                    if (savedMessage?.status === 'cancelled') {
+                        return;
+                    }
+                    await this.messageRepository.updateChatMessage(message.id, {
+                        status: 'error',
+                    }, trx);
+                });
+            },
+        });
+        const transform = (text) => {
+            const trimmed = text.trim();
+            if (!trimmed)
+                return text;
+            let chunk = null;
+            try {
+                chunk = (0, n8n_workflow_1.jsonParse)(trimmed);
+            }
+            catch {
+                return text;
             }
+            const message = aggregator.ingest(chunk);
+            const enriched = {
+                ...chunk,
+                metadata: {
+                    ...chunk.metadata,
+                    messageId: message.id,
+                    previousMessageId: message.previousMessageId,
+                    retryOfMessageId: message.retryOfMessageId,
+                    executionId: executionId ? +executionId : null,
+                },
+            };
+            return JSON.stringify(enriched) + '\n';
         };
-        const stream = (0, stream_capturer_1.captureResponseWrites)(res, onChunk);
-        stream.writeHead(200, JSONL_STREAM_HEADERS);
+        const stream = (0, stream_capturer_1.interceptResponseWrites)(res, transform);
+        stream.on('finish', aggregator.finalizeAll);
+        stream.on('close', aggregator.finalizeAll);
+        stream.writeHead(200, chat_hub_constants_1.JSONL_STREAM_HEADERS);
         stream.flushHeaders();
-        const { executionId } = await this.workflowExecutionService.executeManually({
-            workflowData,
-            triggerToStartFrom,
-        }, user, undefined, true, stream);
+        const execution = await this.workflowExecutionService.executeChatWorkflow(workflowData, executionData, user, stream, true);
+        executionId = execution.executionId;
         if (!executionId) {
             throw new n8n_workflow_1.OperationalError('There was a problem starting the chat execution.');
         }
-        await this.saveAIMessage({
-            id: replyId,
-            sessionId,
-            executionId,
-            previousMessageId,
-            message: partialMessage,
-            selectedModel,
-            retryOfMessageId,
-            status: 'running',
-        });
         try {
-            let result;
-            try {
-                result = await this.activeExecutions.getPostExecutePromise(executionId);
-                if (!result) {
-                    throw new n8n_workflow_1.OperationalError('There was a problem executing the chat workflow.');
-                }
+            const result = await this.activeExecutions.getPostExecutePromise(executionId);
+            if (!result) {
+                throw new n8n_workflow_1.OperationalError('There was a problem executing the chat workflow.');
             }
-            catch (error) {
-                if (error instanceof n8n_workflow_1.ManualExecutionCancelledError) {
-                    const execution = await this.executionRepository.findWithUnflattenedData(executionId, [
-                        workflowData.id,
-                    ]);
-                    if (!execution) {
-                        throw new n8n_workflow_1.OperationalError(`Could not find execution with ID ${executionId}`);
-                    }
-                    if (execution.status === 'canceled') {
-                        await this.messageRepository.updateChatMessage(replyId, {
-                            content: partialMessage || 'Generation cancelled.',
-                            status: 'cancelled',
-                        });
-                        return;
-                    }
-                }
-                throw error;
+        }
+        catch (error) {
+            if (error instanceof n8n_workflow_1.ManualExecutionCancelledError) {
+                return;
             }
-            const execution = await this.executionRepository.findWithUnflattenedData(executionId, [
-                workflowData.id,
-            ]);
-            if (!execution) {
-                throw new n8n_workflow_1.OperationalError(`Could not find execution with ID ${executionId}`);
+            if (error instanceof Error) {
+                this.logger.error(`Error during chat workflow execution: ${error}`);
             }
-            if (!execution.status || execution.status !== 'success') {
-                const message = this.getErrorMessage(execution) ?? 'Failed to generate a response';
-                throw new n8n_workflow_1.OperationalError(message);
+            throw error;
+        }
+    }
+    async executeChatWorkflowWithCleanup(res, user, workflowData, executionData, sessionId, previousMessageId, selectedModel, provider, retryOfMessageId = null) {
+        try {
+            await this.executeChatWorkflow(res, user, workflowData, executionData, sessionId, previousMessageId, selectedModel, retryOfMessageId);
+        }
+        finally {
+            if (provider !== 'n8n') {
+                await this.deleteChatWorkflow(workflowData.id);
             }
-            await this.messageRepository.updateChatMessage(replyId, {
-                content: partialMessage,
-                status: 'success',
-            });
-            const title = this.getAIOutput(execution, NODE_NAMES.TITLE_GENERATOR_AGENT);
+        }
+    }
+    async generateSessionTitle(user, sessionId, humanMessage, credentials, model) {
+        const { executionData, workflowData } = await this.prepareTitleGenerationWorkflow(user, sessionId, humanMessage, credentials, model);
+        try {
+            const title = await this.runTitleWorkflowAndGetTitle(user, workflowData, executionData);
             if (title) {
                 await this.sessionRepository.updateChatTitle(sessionId, title);
             }
         }
         catch (error) {
-            const message = error instanceof Error ? error.message : 'Unknown error';
-            await this.messageRepository.updateChatMessage(replyId, {
-                content: `Error: ${message}`,
-                status: 'error',
-            });
+            if (error instanceof Error) {
+                this.logger.error(`Error during session title generation workflow execution: ${error}`);
+            }
+            throw error;
+        }
+        finally {
+            await this.deleteChatWorkflow(workflowData.id);
         }
     }
-    prepareChatWorkflow({ sessionId, history, humanMessage, credentials, model, generateConversationTitle, }) {
-        const nodes = [
-            {
-                parameters: {
-                    public: true,
-                    mode: 'webhook',
-                    options: { responseMode: 'streaming' },
-                },
-                type: n8n_workflow_1.CHAT_TRIGGER_NODE_TYPE,
-                typeVersion: 1.3,
-                position: [0, 0],
-                id: (0, uuid_1.v4)(),
-                name: NODE_NAMES.CHAT_TRIGGER,
-                webhookId: (0, uuid_1.v4)(),
-            },
-            {
-                parameters: {
-                    promptType: 'define',
-                    text: "={{ $('When chat message received').item.json.chatInput }}",
-                    options: {
-                        enableStreaming: true,
-                        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.REPLY_AGENT,
-            },
-            this.createModelNode(credentials, model),
-            {
-                parameters: {
-                    sessionIdType: 'customKey',
-                    sessionKey: `={{ $('${NODE_NAMES.CHAT_TRIGGER}').item.json.sessionId }}`,
-                    contextWindowLength: 20,
-                },
-                type: '@n8n/n8n-nodes-langchain.memoryBufferWindow',
-                typeVersion: 1.3,
-                position: [480, 208],
-                id: (0, uuid_1.v4)(),
-                name: NODE_NAMES.MEMORY,
-            },
-            {
-                parameters: {
-                    mode: 'insert',
-                    insertMode: 'override',
-                    messages: {
-                        messageValues: history.map((message) => {
-                            const typeMap = {
-                                human: 'user',
-                                ai: 'ai',
-                                system: 'system',
-                            };
-                            return {
-                                type: typeMap[message.type] || 'system',
-                                message: message.content,
-                                hideFromUI: false,
-                            };
-                        }),
-                    },
-                },
-                type: '@n8n/n8n-nodes-langchain.memoryManager',
-                typeVersion: 1.1,
-                position: [224, 0],
-                id: (0, uuid_1.v4)(),
-                name: NODE_NAMES.RESTORE_CHAT_MEMORY,
-            },
-            {
-                parameters: {
-                    mode: 'delete',
-                    deleteMode: 'all',
-                },
-                type: '@n8n/n8n-nodes-langchain.memoryManager',
-                typeVersion: 1.1,
-                position: [976, 0],
-                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]: {
-                main: [
-                    [{ node: NODE_NAMES.RESTORE_CHAT_MEMORY, type: n8n_workflow_1.NodeConnectionTypes.Main, index: 0 }],
-                ],
-            },
-            [NODE_NAMES.RESTORE_CHAT_MEMORY]: {
-                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.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.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.REPLY_AGENT]: {
-                main: [
-                    [
-                        {
-                            node: NODE_NAMES.CLEAR_CHAT_MEMORY,
-                            type: n8n_workflow_1.NodeConnectionTypes.Main,
-                            index: 0,
-                        },
-                    ],
-                ],
+    async prepareTitleGenerationWorkflow(user, sessionId, humanMessage, incomingCredentials, incomingModel) {
+        return await this.messageRepository.manager.transaction(async (trx) => {
+            const { resolvedCredentials, resolvedModel, credential } = await this.resolveCredentialsAndModelForTitle(user, incomingModel, incomingCredentials, trx);
+            if (!credential) {
+                throw new bad_request_error_1.BadRequestError('Could not determine credentials for title generation');
+            }
+            this.logger.debug(`Using credential ID ${credential.id} for title generation in project ${credential.projectId}, model ${JSON.stringify(resolvedModel)}`);
+            return await this.chatHubWorkflowService.createTitleGenerationWorkflow(user.id, sessionId, credential.projectId, humanMessage, resolvedCredentials, resolvedModel, trx);
+        });
+    }
+    async resolveCredentialsAndModelForTitle(user, model, credentials, trx) {
+        if (model.provider === 'n8n') {
+            return await this.resolveFromN8nWorkflow(user, model, trx);
+        }
+        if (model.provider === 'custom-agent') {
+            return await this.resolveFromCustomAgent(user, model, trx);
+        }
+        const credential = await this.chatHubCredentialsService.ensureCredentials(user, model.provider, credentials, trx);
+        return {
+            resolvedCredentials: credentials,
+            resolvedModel: model,
+            credential,
+        };
+    }
+    async resolveFromN8nWorkflow(user, model, trx) {
+        const workflowEntity = await this.workflowFinderService.findWorkflowForUser(model.workflowId, user, ['workflow:read'], { includeTags: false, includeParentFolder: false });
+        if (!workflowEntity) {
+            throw new bad_request_error_1.BadRequestError('Workflow not found for title generation');
+        }
+        const modelNodes = this.findSupportedLLMNodes(workflowEntity);
+        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');
+        }
+        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`);
+        }
+        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`);
+        }
+        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`);
+        }
+        const credential = await this.chatHubCredentialsService.ensureCredentials(user, modelNode.provider, llmCredentials, trx);
+        const resolvedModel = {
+            provider: modelNode.provider,
+            model: llmModel,
+        };
+        const resolvedCredentials = {
+            [api_types_1.PROVIDER_CREDENTIAL_TYPE_MAP[modelNode.provider]]: {
+                id: credential.id,
+                name: '',
             },
         };
-        const triggerToStartFrom = {
-            name: NODE_NAMES.CHAT_TRIGGER,
-            data: {
-                startTime: Date.now(),
-                executionTime: 0,
-                executionIndex: 0,
-                executionStatus: 'success',
-                data: {
-                    main: [
-                        [
-                            {
-                                json: {
-                                    sessionId,
-                                    action: 'sendMessage',
-                                    chatInput: humanMessage,
-                                },
-                            },
-                        ],
-                    ],
-                },
-                source: [null],
+        return { resolvedCredentials, resolvedModel, credential };
+    }
+    findSupportedLLMNodes(workflowEntity) {
+        return workflowEntity.nodes.reduce((acc, node) => {
+            const supportedProvider = Object.entries(chat_hub_constants_1.PROVIDER_NODE_TYPE_MAP).find(([_provider, { name }]) => node.type === name);
+            if (supportedProvider) {
+                const [provider] = supportedProvider;
+                acc.push({ node, provider: provider });
+            }
+            return acc;
+        }, []);
+    }
+    async resolveFromCustomAgent(user, model, trx) {
+        const agent = await this.chatHubAgentService.getAgentById(model.agentId, user.id);
+        if (!agent) {
+            throw new bad_request_error_1.BadRequestError('Agent not found for title generation');
+        }
+        if (agent.provider === 'n8n' || agent.provider === 'custom-agent') {
+            throw new bad_request_error_1.BadRequestError('Invalid provider for title generation');
+        }
+        const credentialId = agent.credentialId;
+        if (!credentialId) {
+            throw new bad_request_error_1.BadRequestError('Credentials not set for agent');
+        }
+        const resolvedModel = {
+            provider: agent.provider,
+            model: agent.model,
+        };
+        const resolvedCredentials = {
+            [api_types_1.PROVIDER_CREDENTIAL_TYPE_MAP[agent.provider]]: {
+                id: credentialId,
+                name: '',
             },
         };
-        return { nodes, connections, triggerToStartFrom };
+        const credential = await this.chatHubCredentialsService.ensureCredentials(user, agent.provider, resolvedCredentials, trx);
+        return { resolvedCredentials, resolvedModel, credential };
+    }
+    async runTitleWorkflowAndGetTitle(user, workflowData, executionData) {
+        const started = await this.workflowExecutionService.executeChatWorkflow(workflowData, executionData, user);
+        const executionId = started.executionId;
+        if (!executionId) {
+            throw new n8n_workflow_1.OperationalError('There was a problem starting the chat execution.');
+        }
+        let run;
+        try {
+            run = await this.activeExecutions.getPostExecutePromise(executionId);
+            if (!run) {
+                throw new n8n_workflow_1.OperationalError('There was a problem executing the chat workflow.');
+            }
+        }
+        catch (error) {
+            if (error instanceof n8n_workflow_1.ManualExecutionCancelledError) {
+                return null;
+            }
+            throw error;
+        }
+        const execution = await this.executionRepository.findWithUnflattenedData(executionId, [
+            workflowData.id,
+        ]);
+        if (!execution) {
+            throw new n8n_workflow_1.OperationalError(`Could not find execution with ID ${executionId}`);
+        }
+        if (!execution.status || execution.status !== 'success') {
+            const message = this.getErrorMessage(execution) ?? 'Failed to generate a response';
+            throw new n8n_workflow_1.OperationalError(message);
+        }
+        const title = this.getAIOutput(execution, chat_hub_constants_1.NODE_NAMES.TITLE_GENERATOR_AGENT);
+        return title ?? null;
     }
     async saveHumanMessage(payload, user, previousMessageId, selectedModel, revisionOfMessageId, trx) {
         await this.messageRepository.createChatMessage({
             id: payload.messageId,
             sessionId: payload.sessionId,
             type: 'human',
-            name: user.firstName || 'User',
             status: 'success',
             content: payload.message,
             previousMessageId,
             revisionOfMessageId,
             ...selectedModel,
+            name: user.firstName || 'User',
         }, trx);
     }
-    async saveAIMessage({ id, sessionId, executionId, previousMessageId, message, selectedModel, retryOfMessageId, status, }) {
+    async saveAIMessage({ id, sessionId, executionId, previousMessageId, content, selectedModel, retryOfMessageId, status, }) {
         await this.messageRepository.createChatMessage({
             id,
             sessionId,
             previousMessageId,
-            executionId: parseInt(executionId, 10),
+            executionId: executionId ? parseInt(executionId, 10) : null,
             type: 'ai',
             name: 'AI',
             status,
-            content: message,
+            content,
             retryOfMessageId,
             ...selectedModel,
         });
     }
+    getModelWithCredentials(selectedModel, credentials) {
+        const provider = selectedModel.provider;
+        const modelWithCredentials = {
+            ...selectedModel,
+            credentialId: provider !== 'n8n' ? this.pickCredentialId(provider, credentials) : null,
+        };
+        return modelWithCredentials;
+    }
     async getChatSession(user, sessionId, selectedModel, initialize = false, trx) {
         const existing = await this.sessionRepository.getOneById(sessionId, user.id, trx);
         if (existing) {
@@ -762,10 +752,34 @@ let ChatHubService = class ChatHubService {
         else if (!initialize) {
             throw new not_found_error_1.NotFoundError('Chat session not found');
         }
+        let agentName = undefined;
+        if (selectedModel?.provider === 'custom-agent') {
+            const agent = await this.chatHubAgentService.getAgentById(selectedModel.agentId, user.id);
+            if (!agent) {
+                throw new bad_request_error_1.BadRequestError('Agent not found for chat session initialization');
+            }
+            agentName = agent.name;
+        }
+        if (selectedModel?.provider === 'n8n') {
+            const workflow = await this.workflowFinderService.findWorkflowForUser(selectedModel.workflowId, user, ['workflow:read'], { includeTags: false, includeParentFolder: false });
+            if (!workflow) {
+                throw new bad_request_error_1.BadRequestError('Workflow not found for chat session initialization');
+            }
+            const chatTrigger = workflow.nodes?.find((node) => node.type === n8n_workflow_1.CHAT_TRIGGER_NODE_TYPE);
+            if (!chatTrigger) {
+                throw new bad_request_error_1.BadRequestError('Chat trigger not found in workflow for chat session initialization');
+            }
+            agentName =
+                typeof chatTrigger.parameters.agentName === 'string' &&
+                    chatTrigger.parameters.agentName.length > 0
+                    ? chatTrigger.parameters.agentName
+                    : workflow.name;
+        }
         return await this.sessionRepository.createChatSession({
             id: sessionId,
             ownerId: user.id,
             title: 'New Chat',
+            agentName,
             ...selectedModel,
         }, trx);
     }
@@ -776,51 +790,6 @@ let ChatHubService = class ChatHubService {
         }
         return message;
     }
-    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, 500],
-            id: (0, uuid_1.v4)(),
-            name: 'Chat Model',
-            credentials,
-            type: providerNodeTypeMapping[provider].name,
-            typeVersion: providerNodeTypeMapping[provider].version,
-        };
-        switch (provider) {
-            case 'openai':
-                return {
-                    ...common,
-                    parameters: {
-                        model: { __rl: true, mode: 'list', value: model },
-                        options: {},
-                    },
-                };
-            case 'anthropic':
-                return {
-                    ...common,
-                    parameters: {
-                        model: {
-                            __rl: true,
-                            mode: 'list',
-                            value: model,
-                            cachedResultName: model,
-                        },
-                        options: {},
-                    },
-                };
-            case 'google':
-                return {
-                    ...common,
-                    parameters: {
-                        model: { __rl: true, mode: 'list', value: model },
-                        options: {},
-                    },
-                };
-        }
-    }
     async getConversations(userId) {
         const sessions = await this.sessionRepository.getManyByUserId(userId);
         return sessions.map((session) => ({
@@ -832,6 +801,8 @@ let ChatHubService = class ChatHubService {
             provider: session.provider,
             model: session.model,
             workflowId: session.workflowId,
+            agentId: session.agentId,
+            agentName: session.agentName,
             createdAt: session.createdAt.toISOString(),
             updatedAt: session.updatedAt.toISOString(),
         }));
@@ -852,6 +823,8 @@ let ChatHubService = class ChatHubService {
                 provider: session.provider,
                 model: session.model,
                 workflowId: session.workflowId,
+                agentId: session.agentId,
+                agentName: session.agentName,
                 createdAt: session.createdAt.toISOString(),
                 updatedAt: session.updatedAt.toISOString(),
             },
@@ -870,6 +843,7 @@ let ChatHubService = class ChatHubService {
             provider: message.provider,
             model: message.model,
             workflowId: message.workflowId,
+            agentId: message.agentId,
             executionId: message.executionId,
             status: message.status,
             createdAt: message.createdAt.toISOString(),
@@ -904,6 +878,51 @@ let ChatHubService = class ChatHubService {
         }
         return await this.sessionRepository.updateChatTitle(sessionId, title);
     }
+    async updateSession(user, sessionId, updates) {
+        const session = await this.sessionRepository.getOneById(sessionId, user.id);
+        if (!session) {
+            throw new not_found_error_1.NotFoundError('Session not found');
+        }
+        if (updates.workflowId) {
+            const workflow = await this.workflowFinderService.findWorkflowForUser(updates.workflowId, user, ['workflow:read'], { includeTags: false, includeParentFolder: false });
+            if (!workflow) {
+                throw new bad_request_error_1.BadRequestError('Workflow not found');
+            }
+            const chatTriggers = workflow.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 chatTrigger = chatTriggers[0];
+            updates.agentName =
+                typeof chatTrigger.parameters.agentName === 'string' &&
+                    chatTrigger.parameters.agentName.length > 0
+                    ? chatTrigger.parameters.agentName
+                    : workflow.name;
+        }
+        if (updates.agentId) {
+            const agent = await this.chatHubAgentService.getAgentById(updates.agentId, user.id);
+            if (!agent) {
+                throw new bad_request_error_1.BadRequestError('Agent not found');
+            }
+            updates.agentName = agent.name;
+        }
+        if (updates.provider === 'n8n') {
+            updates.model = null;
+            updates.credentialId = null;
+            updates.agentId = null;
+        }
+        else if (updates.provider === 'custom-agent') {
+            updates.model = null;
+            updates.credentialId = null;
+            updates.workflowId = null;
+        }
+        else if (updates.provider) {
+            updates.workflowId = null;
+            updates.agentId = null;
+            updates.agentName = null;
+        }
+        return await this.sessionRepository.updateChatSession(sessionId, updates);
+    }
     async deleteSession(userId, sessionId) {
         const session = await this.sessionRepository.getOneById(sessionId, userId);
         if (!session) {
@@ -923,10 +942,12 @@ exports.ChatHubService = ChatHubService = __decorate([
         workflow_service_1.WorkflowService,
         workflow_finder_service_1.WorkflowFinderService,
         db_1.WorkflowRepository,
-        db_1.SharedWorkflowRepository,
         active_executions_1.ActiveExecutions,
         chat_session_repository_1.ChatHubSessionRepository,
         chat_message_repository_1.ChatHubMessageRepository,
-        credentials_finder_service_1.CredentialsFinderService])
+        credentials_finder_service_1.CredentialsFinderService,
+        chat_hub_agent_service_1.ChatHubAgentService,
+        chat_hub_credentials_service_1.ChatHubCredentialsService,
+        chat_hub_workflow_service_1.ChatHubWorkflowService])
 ], ChatHubService);
 //# sourceMappingURL=chat-hub.service.js.map