n8n 1.116.2 → 1.117.1

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

@@ -16,24 +16,53 @@ 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 credentials_helper_1 = require("../../credentials-helper");
+const active_executions_1 = require("../../active-executions");
+const credentials_service_1 = require("../../credentials/credentials.service");
+const bad_request_error_1 = require("../../errors/response-errors/bad-request.error");
 const not_found_error_1 = require("../../errors/response-errors/not-found.error");
+const execution_service_1 = require("../../executions/execution.service");
+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 credentials_service_1 = require("../../credentials/credentials.service");
-const active_executions_1 = require("../../active-executions");
+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 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',
+    AI_AGENT: 'AI Agent',
+    CHAT_MODEL: 'Chat Model',
+    MEMORY: 'Memory',
+    RESTORE_CHAT_MEMORY: 'Restore Chat Memory',
+    CLEAR_CHAT_MEMORY: 'Clear Chat Memory',
+};
 let ChatHubService = class ChatHubService {
-    constructor(logger, credentialsService, credentialsHelper, executionRepository, workflowExecutionService, workflowRepository, projectRepository, sharedWorkflowRepository, activeExecutions) {
+    constructor(logger, credentialsService, executionService, nodeParametersService, executionRepository, workflowExecutionService, workflowRepository, projectRepository, sharedWorkflowRepository, activeExecutions, sessionRepository, messageRepository) {
         this.logger = logger;
         this.credentialsService = credentialsService;
-        this.credentialsHelper = credentialsHelper;
+        this.executionService = executionService;
+        this.nodeParametersService = nodeParametersService;
         this.executionRepository = executionRepository;
         this.workflowExecutionService = workflowExecutionService;
         this.workflowRepository = workflowRepository;
         this.projectRepository = projectRepository;
         this.sharedWorkflowRepository = sharedWorkflowRepository;
         this.activeExecutions = activeExecutions;
-        this.sesssions = new Map();
+        this.sessionRepository = sessionRepository;
+        this.messageRepository = messageRepository;
     }
     async getModels(user, credentialIds) {
         const additionalData = await (0, workflow_execute_additional_data_1.getBase)({ userId: user.id });
@@ -43,16 +72,14 @@ let ChatHubService = class ChatHubService {
                 return [provider, { models: [] }];
             }
             await this.credentialsService.getOne(user, credentialId, false);
-            const credentials = await this.credentialsHelper.getDecrypted(additionalData, {
-                id: credentialId,
-                name: api_types_1.PROVIDER_CREDENTIAL_TYPE_MAP[provider],
-            }, api_types_1.PROVIDER_CREDENTIAL_TYPE_MAP[provider], 'internal', undefined, true);
-            const apiKey = this.extractApiKey(provider, credentials);
-            if (!apiKey) {
-                return [provider, { models: [] }];
-            }
             try {
-                return [provider, await this.fetchModelsForProvider(provider, apiKey)];
+                const credentials = {
+                    [api_types_1.PROVIDER_CREDENTIAL_TYPE_MAP[provider]]: { name: '', id: credentialId },
+                };
+                return [
+                    provider,
+                    await this.fetchModelsForProvider(provider, credentials, additionalData),
+                ];
             }
             catch {
                 return [
@@ -70,93 +97,74 @@ let ChatHubService = class ChatHubService {
             google: { models: [] },
         });
     }
-    async fetchModelsForProvider(provider, apiKey) {
+    async fetchModelsForProvider(provider, credentials, additionalData) {
         switch (provider) {
             case 'openai':
-                return await this.fetchOpenAiModels(apiKey);
+                return await this.fetchOpenAiModels(credentials, additionalData);
             case 'anthropic':
-                return await this.fetchAnthropicModels(apiKey);
+                return await this.fetchAnthropicModels(credentials, additionalData);
             case 'google':
-                return await this.fetchGoogleModels(apiKey);
+                return await this.fetchGoogleModels(credentials, additionalData);
         }
     }
-    async fetchOpenAiModels(apiKey) {
-        const response = await fetch('https://api.openai.com/v1/models', {
-            method: 'GET',
-            headers: {
-                Authorization: `Bearer ${apiKey}`,
-            },
-        });
-        if (!response.ok) {
-            throw new Error(`Failed to fetch OpenAI models: ${response.statusText}`);
-        }
-        const data = await response.json();
+    async fetchOpenAiModels(credentials, additionalData) {
+        const resourceLocatorResults = await this.nodeParametersService.getResourceLocatorResults('searchModels', 'parameters.model', additionalData, providerNodeTypeMapping.openai, {}, credentials);
         return {
-            models: data.data
-                .filter((model) => model.id.includes('gpt') &&
-                !model.id.includes('instruct') &&
-                !model.id.includes('audio'))
-                .map((model) => ({ name: model.id })),
+            models: resourceLocatorResults.results.map((result) => ({ name: String(result.value) })),
         };
     }
-    async fetchAnthropicModels(apiKey) {
-        const response = await fetch('https://api.anthropic.com/v1/models', {
-            method: 'GET',
-            headers: {
-                'x-api-key': apiKey,
-                'anthropic-version': '2023-06-01',
-            },
-        });
-        if (!response.ok) {
-            throw new Error(`Failed to fetch Anthropic models: ${response.statusText}`);
-        }
-        const data = (await response.json());
+    async fetchAnthropicModels(credentials, additionalData) {
+        const resourceLocatorResults = await this.nodeParametersService.getResourceLocatorResults('searchModels', 'parameters.model', additionalData, providerNodeTypeMapping.anthropic, {}, credentials);
         return {
-            models: (data.data || [])
-                .sort((a, b) => {
-                const dateA = new Date(a.created_at);
-                const dateB = new Date(b.created_at);
-                return dateB.getTime() - dateA.getTime();
-            })
-                .map((model) => ({ name: model.id })),
+            models: resourceLocatorResults.results.map((result) => ({ name: String(result.value) })),
         };
     }
-    async fetchGoogleModels(apiKey) {
-        const response = await fetch(`https://generativelanguage.googleapis.com/v1/models?key=${apiKey}`, {
-            method: 'GET',
-        });
-        if (!response.ok) {
-            throw new Error(`Failed to fetch Google models: ${response.statusText}`);
-        }
-        const data = await response.json();
+    async fetchGoogleModels(credentials, additionalData) {
+        const results = await this.nodeParametersService.getOptionsViaLoadOptions({
+            routing: {
+                request: {
+                    method: 'GET',
+                    url: '/v1beta/models',
+                },
+                output: {
+                    postReceive: [
+                        {
+                            type: 'rootProperty',
+                            properties: {
+                                property: 'models',
+                            },
+                        },
+                        {
+                            type: 'filter',
+                            properties: {
+                                pass: "={{ !$responseItem.name.includes('embedding') }}",
+                            },
+                        },
+                        {
+                            type: 'setKeyValue',
+                            properties: {
+                                name: '={{$responseItem.name}}',
+                                value: '={{$responseItem.name}}',
+                                description: '={{$responseItem.description}}',
+                            },
+                        },
+                        {
+                            type: 'sort',
+                            properties: {
+                                key: 'name',
+                            },
+                        },
+                    ],
+                },
+            },
+        }, additionalData, providerNodeTypeMapping.google, {}, credentials);
         return {
-            models: data.models
-                ?.filter((model) => model.name.includes('gemini') &&
-                model.supportedGenerationMethods?.includes('generateContent'))
-                .map((model) => {
-                const modelId = model.name.split('/').pop();
-                return { name: modelId };
-            }),
+            models: results.map((result) => ({ name: String(result.value) })),
         };
     }
-    extractApiKey(provider, credentials) {
-        if (typeof credentials !== 'object' || credentials === null) {
-            return undefined;
-        }
-        const creds = credentials;
-        switch (provider) {
-            case 'openai':
-            case 'anthropic':
-            case 'google':
-                return typeof creds.apiKey === 'string' ? creds.apiKey : undefined;
-        }
-    }
-    async createChatWorkflow(user, sessionId, nodes, connections) {
+    async createChatWorkflow(user, sessionId, history, humanMessage, credentials, model) {
+        const { nodes, connections, startNodes, triggerToStartFrom } = this.prepareChatWorkflow(sessionId, history, humanMessage, credentials, model);
         const { manager } = this.projectRepository;
-        const existing = await this.workflowRepository.findOneBy({ id: sessionId });
-        if (existing) {
-            return existing;
-        }
         return await manager.transaction(async (trx) => {
             const project = await this.projectRepository.getPersonalProjectForUser(user.id, trx);
             if (!project) {
@@ -164,7 +172,6 @@ let ChatHubService = class ChatHubService {
             }
             const newWorkflow = new db_1.WorkflowEntity();
             newWorkflow.versionId = (0, uuid_1.v4)();
-            newWorkflow.id = sessionId;
             newWorkflow.name = `Chat ${sessionId}`;
             newWorkflow.active = false;
             newWorkflow.nodes = nodes;
@@ -175,40 +182,218 @@ let ChatHubService = class ChatHubService {
                 projectId: project.id,
                 workflow,
             }));
-            return workflow;
+            return {
+                workflowData: {
+                    ...workflow,
+                    nodes,
+                    connections,
+                    versionId: (0, uuid_1.v4)(),
+                },
+                startNodes,
+                triggerToStartFrom,
+            };
         });
     }
-    getMessage(execution) {
-        const lastNodeExecuted = execution.data.resultData.lastNodeExecuted;
-        if (typeof lastNodeExecuted !== 'string')
+    async deleteChatWorkflow(workflowId) {
+        await this.workflowRepository.delete(workflowId);
+    }
+    getErrorMessage(execution) {
+        if (execution.data.resultData.error) {
+            return execution.data.resultData.error.description ?? execution.data.resultData.error.message;
+        }
+        return undefined;
+    }
+    getAIOutput(execution) {
+        const agent = execution.data.resultData.runData[NODE_NAMES.AI_AGENT];
+        if (!agent || !Array.isArray(agent) || agent.length === 0)
             return undefined;
-        const runIndex = execution.data.resultData.runData[lastNodeExecuted].length - 1;
-        const mainOutputs = execution.data.resultData.runData[lastNodeExecuted][runIndex]?.data?.main;
+        const runIndex = agent.length - 1;
+        const mainOutputs = agent[runIndex].data?.main;
         if (mainOutputs && Array.isArray(mainOutputs)) {
             for (const branch of mainOutputs) {
                 if (branch && Array.isArray(branch) && branch.length > 0 && branch[0].json?.output) {
-                    return branch[0].json.output;
+                    if (typeof branch[0].json.output === 'string') {
+                        return branch[0].json.output;
+                    }
                 }
             }
         }
         return undefined;
     }
-    async askN8n(res, user, payload) {
-        let session = this.sesssions.get(payload.sessionId);
-        if (!session) {
-            session = [];
-            this.sesssions.set(payload.sessionId, session);
+    getCredentialId(provider, credentials) {
+        return credentials[api_types_1.PROVIDER_CREDENTIAL_TYPE_MAP[provider]]?.id ?? null;
+    }
+    async sendHumanMessage(res, user, payload) {
+        const { sessionId, messageId, replyId, message } = payload;
+        const selectedModel = {
+            ...payload.model,
+            credentialId: this.getCredentialId(payload.model.provider, payload.credentials),
+        };
+        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 chatHistory = session.map((msg) => ({
-            type: msg.type,
-            message: msg.message,
-        }));
-        session.push({
-            id: payload.messageId,
-            message: payload.message,
-            type: 'user',
-            createdAt: new Date(),
+        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);
+        try {
+            await this.executeChatWorkflow(res, user, workflow, replyId, sessionId, messageId, selectedModel);
+        }
+        finally {
+            await this.deleteChatWorkflow(workflow.workflowData.id);
+        }
+    }
+    async editHumanMessage(res, user, payload) {
+        const { sessionId, editId, messageId, message, replyId } = payload;
+        const selectedModel = {
+            ...payload.model,
+            credentialId: this.getCredentialId(payload.model.provider, payload.credentials),
+        };
+        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);
+        try {
+            await this.executeChatWorkflow(res, user, workflow, replyId, sessionId, messageId, selectedModel);
+        }
+        finally {
+            await this.deleteChatWorkflow(workflow.workflowData.id);
+        }
+    }
+    async regenerateAIMessage(res, user, payload) {
+        const { sessionId, retryId, replyId } = payload;
+        const selectedModel = {
+            ...payload.model,
+            credentialId: this.getCredentialId(payload.model.provider, payload.credentials),
+        };
+        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);
+        try {
+            await this.executeChatWorkflow(res, user, workflow, replyId, sessionId, lastHumanMessage.id, selectedModel, retryOfMessageId);
+        }
+        finally {
+            await this.deleteChatWorkflow(workflow.workflowData.id);
+        }
+    }
+    async stopGeneration(user, sessionId, messageId) {
+        const session = await this.getChatSession(user, sessionId);
+        const message = await this.getChatMessage(session.id, messageId, [
+            'execution',
+            'execution.workflow',
+        ]);
+        if (message.type !== 'ai') {
+            throw new bad_request_error_1.BadRequestError('Can only stop AI messages');
+        }
+        if (!message.executionId || !message.execution) {
+            throw new bad_request_error_1.BadRequestError('Message is not associated with a workflow execution');
+        }
+        if (message.status !== 'running') {
+            throw new bad_request_error_1.BadRequestError('Can only stop messages that are currently running');
+        }
+        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, startNodes, triggerToStartFrom } = workflow;
+        this.logger.debug(`Starting execution of workflow "${workflowData.name}" with ID ${workflowData.id}`);
+        const { executionId } = await this.workflowExecutionService.executeManually({
+            workflowData,
+            startNodes,
+            triggerToStartFrom,
+        }, user, undefined, true, res);
+        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: '',
+            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.');
+                }
+            }
+            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') {
+                        const message = 'Generation cancelled.';
+                        await this.messageRepository.updateChatMessage(replyId, {
+                            content: message,
+                            status: 'cancelled',
+                        });
+                        return;
+                    }
+                }
+                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 message = this.getAIOutput(execution);
+            if (!message) {
+                throw new n8n_workflow_1.OperationalError('No response generated');
+            }
+            await this.messageRepository.updateChatMessage(replyId, {
+                content: message,
+                status: 'success',
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            await this.messageRepository.updateChatMessage(replyId, {
+                content: `Error: ${message}`,
+                status: 'error',
+            });
+        }
+    }
+    prepareChatWorkflow(sessionId, history, humanMessage, credentials, model) {
         const nodes = [
             {
                 parameters: {
@@ -220,7 +405,7 @@ let ChatHubService = class ChatHubService {
                 typeVersion: 1.3,
                 position: [0, 0],
                 id: (0, uuid_1.v4)(),
-                name: 'When chat message received',
+                name: NODE_NAMES.CHAT_TRIGGER,
                 webhookId: (0, uuid_1.v4)(),
             },
             {
@@ -229,69 +414,103 @@ 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),
                     },
                 },
                 type: n8n_workflow_1.AGENT_LANGCHAIN_NODE_TYPE,
                 typeVersion: 3,
                 position: [600, 0],
                 id: (0, uuid_1.v4)(),
-                name: 'AI Agent',
+                name: NODE_NAMES.AI_AGENT,
             },
-            this.createModelNode(payload),
+            this.createModelNode(credentials, model),
             {
                 parameters: {
                     sessionIdType: 'customKey',
-                    sessionKey: "={{ $('When chat message received').item.json.sessionId }}",
+                    sessionKey: `={{ $('${NODE_NAMES.CHAT_TRIGGER}').item.json.sessionId }}`,
+                    contextWindowLength: 20,
                 },
                 type: '@n8n/n8n-nodes-langchain.memoryBufferWindow',
                 typeVersion: 1.3,
-                position: [500, 200],
+                position: [480, 208],
                 id: (0, uuid_1.v4)(),
-                name: 'Memory',
+                name: NODE_NAMES.MEMORY,
             },
             {
                 parameters: {
                     mode: 'insert',
+                    insertMode: 'override',
                     messages: {
-                        messageValues: chatHistory,
+                        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: [200, 0],
+                position: [224, 0],
                 id: (0, uuid_1.v4)(),
-                name: 'Restore Chat Memory',
+                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,
             },
         ];
         const connections = {
-            'When chat message received': {
-                main: [[{ node: 'Restore Chat Memory', type: 'main', index: 0 }]],
+            [NODE_NAMES.CHAT_TRIGGER]: {
+                main: [
+                    [{ node: NODE_NAMES.RESTORE_CHAT_MEMORY, type: n8n_workflow_1.NodeConnectionTypes.Main, index: 0 }],
+                ],
             },
-            'Restore Chat Memory': {
-                main: [[{ node: 'AI Agent', type: 'main', index: 0 }]],
+            [NODE_NAMES.RESTORE_CHAT_MEMORY]: {
+                main: [[{ node: NODE_NAMES.AI_AGENT, type: n8n_workflow_1.NodeConnectionTypes.Main, index: 0 }]],
             },
-            'Chat Model': {
-                ai_languageModel: [[{ node: 'AI Agent', type: 'ai_languageModel', index: 0 }]],
+            [NODE_NAMES.CHAT_MODEL]: {
+                ai_languageModel: [
+                    [{ node: NODE_NAMES.AI_AGENT, type: n8n_workflow_1.NodeConnectionTypes.AiLanguageModel, index: 0 }],
+                ],
             },
-            Memory: {
+            [NODE_NAMES.MEMORY]: {
                 ai_memory: [
                     [
-                        { node: 'AI Agent', type: 'ai_memory', index: 0 },
-                        { node: 'Restore Chat Memory', type: 'ai_memory', index: 0 },
+                        { node: NODE_NAMES.AI_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]: {
+                main: [
+                    [
+                        {
+                            node: NODE_NAMES.CLEAR_CHAT_MEMORY,
+                            type: n8n_workflow_1.NodeConnectionTypes.Main,
+                            index: 0,
+                        },
                     ],
                 ],
             },
-        };
-        const workflow = await this.createChatWorkflow(user, payload.sessionId, nodes, connections);
-        const workflowData = {
-            ...workflow,
-            nodes,
-            connections,
-            versionId: (0, uuid_1.v4)(),
         };
         const startNodes = [{ name: 'Restore Chat Memory', sourceData: null }];
         const triggerToStartFrom = {
-            name: 'When chat message received',
+            name: NODE_NAMES.CHAT_TRIGGER,
             data: {
                 startTime: Date.now(),
                 executionTime: 0,
@@ -302,9 +521,9 @@ let ChatHubService = class ChatHubService {
                         [
                             {
                                 json: {
-                                    sessionId: `${payload.sessionId}-${payload.messageId}`,
+                                    sessionId,
                                     action: 'sendMessage',
-                                    chatInput: payload.message,
+                                    chatInput: humanMessage,
                                 },
                             },
                         ],
@@ -313,53 +532,74 @@ let ChatHubService = class ChatHubService {
                 source: [null],
             },
         };
-        this.logger.debug(`Starting execution of workflow "${workflow.name}" with ID ${workflow.id}`);
-        const { executionId } = await this.workflowExecutionService.executeManually({
-            workflowData,
-            startNodes,
-            triggerToStartFrom,
-        }, user, undefined, true, res);
-        if (!executionId) {
-            throw new n8n_workflow_1.OperationalError('There was a problem starting the chat execution.');
+        return { nodes, connections, startNodes, triggerToStartFrom };
+    }
+    async saveHumanMessage(payload, user, previousMessageId, selectedModel, revisionOfMessageId) {
+        await this.messageRepository.createChatMessage({
+            id: payload.messageId,
+            sessionId: payload.sessionId,
+            type: 'human',
+            name: user.firstName || 'User',
+            status: 'success',
+            content: payload.message,
+            previousMessageId,
+            revisionOfMessageId,
+            ...selectedModel,
+        });
+    }
+    async saveAIMessage({ id, sessionId, executionId, previousMessageId, message, selectedModel, retryOfMessageId, status, }) {
+        await this.messageRepository.createChatMessage({
+            id,
+            sessionId,
+            previousMessageId,
+            executionId: parseInt(executionId, 10),
+            type: 'ai',
+            name: 'AI',
+            status,
+            content: message,
+            retryOfMessageId,
+            ...selectedModel,
+        });
+    }
+    async getChatSession(user, sessionId, selectedModel, initialize = false, title = null) {
+        const existing = await this.sessionRepository.getOneById(sessionId, user.id);
+        if (existing) {
+            return existing;
         }
-        const result = await this.activeExecutions.getPostExecutePromise(executionId);
-        if (!result) {
-            throw new n8n_workflow_1.OperationalError('There was a problem executing the chat workflow.');
+        else if (!initialize) {
+            throw new not_found_error_1.NotFoundError('Chat session not found');
         }
-        const execution = await this.executionRepository.findWithUnflattenedData(executionId, [
-            workflow.id,
-        ]);
-        if (!execution) {
-            throw new not_found_error_1.NotFoundError(`Could not find execution with ID ${executionId}`);
-        }
-        const message = this.getMessage(execution);
-        if (message) {
-            this.logger.debug(`Assistant: ${message} (${payload.replyId})`);
-            session.push({
-                id: payload.replyId,
-                message,
-                type: 'ai',
-                createdAt: new Date(),
-            });
+        return await this.sessionRepository.createChatSession({
+            id: sessionId,
+            ownerId: user.id,
+            title: title ?? 'New Chat',
+            ...selectedModel,
+        });
+    }
+    async getChatMessage(sessionId, messageId, relations = []) {
+        const message = await this.messageRepository.getOneById(messageId, sessionId, relations);
+        if (!message) {
+            throw new not_found_error_1.NotFoundError('Chat message not found');
         }
+        return message;
     }
-    createModelNode(payload) {
+    createModelNode(credentials, { provider, model }) {
         const common = {
             position: [600, 200],
             id: (0, uuid_1.v4)(),
             name: 'Chat Model',
-            credentials: payload.credentials,
+            credentials,
+            type: providerNodeTypeMapping[provider].name,
+            typeVersion: providerNodeTypeMapping[provider].version,
         };
-        switch (payload.model.provider) {
+        switch (provider) {
             case 'openai':
                 return {
                     ...common,
                     parameters: {
-                        model: { __rl: true, mode: 'list', value: payload.model.model },
+                        model: { __rl: true, mode: 'list', value: model },
                         options: {},
                     },
-                    type: '@n8n/n8n-nodes-langchain.lmChatOpenAi',
-                    typeVersion: 1.2,
                 };
             case 'anthropic':
                 return {
@@ -368,169 +608,111 @@ let ChatHubService = class ChatHubService {
                         model: {
                             __rl: true,
                             mode: 'list',
-                            value: payload.model.model,
-                            cachedResultName: payload.model.model,
+                            value: model,
+                            cachedResultName: model,
                         },
                         options: {},
                     },
-                    type: '@n8n/n8n-nodes-langchain.lmChatAnthropic',
-                    typeVersion: 1.3,
                 };
             case 'google':
                 return {
                     ...common,
                     parameters: {
-                        model: { __rl: true, mode: 'list', value: payload.model.model },
+                        model: { __rl: true, mode: 'list', value: model },
                         options: {},
                     },
-                    type: '@n8n/n8n-nodes-langchain.lmChatGoogleGemini',
-                    typeVersion: 1.2,
                 };
         }
     }
-    async getConversations() {
-        const now = new Date();
-        const today = new Date(now);
-        const yesterday = new Date(now);
-        yesterday.setDate(yesterday.getDate() - 1);
-        const threeDaysAgo = new Date(now);
-        threeDaysAgo.setDate(threeDaysAgo.getDate() - 3);
-        const twoWeeksAgo = new Date(now);
-        twoWeeksAgo.setDate(twoWeeksAgo.getDate() - 14);
-        const twoMonthsAgo = new Date(now);
-        twoMonthsAgo.setMonth(twoMonthsAgo.getMonth() - 2);
-        return [
-            {
-                id: '7f3e2a91-8c4d-4b5a-9e1f-2d6c8a4b5e7f',
-                title: 'Getting Started with n8n',
-                createdAt: today.toISOString(),
-                updatedAt: today.toISOString(),
-            },
-            {
-                id: '3a8f5c2d-1e9b-4d7a-8c3e-6f2a9b4d8e1c',
-                title: 'Workflow Automation Ideas',
-                createdAt: yesterday.toISOString(),
-                updatedAt: yesterday.toISOString(),
-            },
-            {
-                id: '9b2e4f6a-7d1c-4a8b-9e3f-5c7d2a8b4e6f',
-                title: 'API Integration Help',
-                createdAt: threeDaysAgo.toISOString(),
-                updatedAt: threeDaysAgo.toISOString(),
-            },
-            {
-                id: '5c8a1d3e-4b9f-4e2a-8d6c-7f3a9b2e4c8d',
-                title: 'Database Schema Design',
-                createdAt: twoWeeksAgo.toISOString(),
-                updatedAt: twoWeeksAgo.toISOString(),
+    async getConversations(userId) {
+        const sessions = await this.sessionRepository.getManyByUserId(userId);
+        return sessions.map((session) => ({
+            id: session.id,
+            title: session.title,
+            ownerId: session.ownerId,
+            lastMessageAt: session.lastMessageAt?.toISOString() ?? null,
+            credentialId: session.credentialId,
+            provider: session.provider,
+            model: session.model,
+            workflowId: session.workflowId,
+            createdAt: session.createdAt.toISOString(),
+            updatedAt: session.updatedAt.toISOString(),
+        }));
+    }
+    async getConversation(userId, sessionId) {
+        const session = await this.sessionRepository.getOneById(sessionId, userId);
+        if (!session) {
+            throw new not_found_error_1.NotFoundError('Chat session not found');
+        }
+        const messages = await this.messageRepository.getManyBySessionId(sessionId);
+        return {
+            session: {
+                id: session.id,
+                title: session.title,
+                ownerId: session.ownerId,
+                lastMessageAt: session.lastMessageAt?.toISOString() ?? null,
+                credentialId: session.credentialId,
+                provider: session.provider,
+                model: session.model,
+                workflowId: session.workflowId,
+                createdAt: session.createdAt.toISOString(),
+                updatedAt: session.updatedAt.toISOString(),
             },
-            {
-                id: '2f6d9a4c-8e1b-4d7a-9c3e-6a8f2b5d4e9c',
-                title: 'Docker Deployment Questions',
-                createdAt: twoMonthsAgo.toISOString(),
-                updatedAt: twoMonthsAgo.toISOString(),
+            conversation: {
+                messages: Object.fromEntries(messages.map((m) => [m.id, this.convertMessageToDto(m)])),
             },
-        ];
+        };
     }
-    async getConversationMessages(conversationId) {
-        this.logger.debug(`Fetching messages for conversation ${conversationId}`);
-        const mockConversations = {
-            '7f3e2a91-8c4d-4b5a-9e1f-2d6c8a4b5e7f': [
-                {
-                    id: '650e8400-e29b-41d4-a716-446655440001',
-                    conversationId,
-                    role: 'user',
-                    content: 'How do I create my first workflow in n8n?',
-                    createdAt: new Date('2025-01-08T10:00:00Z').toISOString(),
-                },
-                {
-                    id: '650e8400-e29b-41d4-a716-446655440002',
-                    conversationId,
-                    role: 'assistant',
-                    content: "To create your first workflow in n8n:\n\n1. Click the '+' button in the top left\n2. Select 'Create New Workflow'\n3. Add nodes by clicking the '+' on the canvas\n4. Configure each node\n5. Connect nodes by dragging from one to another\n6. Test and activate your workflow\n\nWould you like help with a specific type of workflow?",
-                    createdAt: new Date('2025-01-08T10:00:30Z').toISOString(),
-                },
-                {
-                    id: '650e8400-e29b-41d4-a716-446655440003',
-                    conversationId,
-                    role: 'user',
-                    content: 'Yes, I want to automate sending emails when a new row is added to a Google Sheet.',
-                    createdAt: new Date('2025-01-08T10:05:00Z').toISOString(),
-                },
-                {
-                    id: '650e8400-e29b-41d4-a716-446655440004',
-                    conversationId,
-                    role: 'assistant',
-                    content: "Perfect! Here's how to set that up:\n\n1. Add a **Google Sheets Trigger** node\n   - Select 'On Row Added'\n   - Connect your Google account\n   - Choose your spreadsheet\n\n2. Add a **Gmail** node\n   - Connect your Gmail account\n   - Set the recipient email\n   - Use expressions to include data from the sheet\n\n3. Activate the workflow\n\nWould you like more details on any of these steps?",
-                    createdAt: new Date('2025-01-08T10:05:45Z').toISOString(),
-                },
-            ],
-            '3a8f5c2d-1e9b-4d7a-8c3e-6f2a9b4d8e1c': [
-                {
-                    id: '650e8400-e29b-41d4-a716-446655440011',
-                    conversationId,
-                    role: 'user',
-                    content: 'What are some creative workflow automation ideas?',
-                    createdAt: new Date('2025-01-07T14:30:00Z').toISOString(),
-                },
-                {
-                    id: '650e8400-e29b-41d4-a716-446655440012',
-                    conversationId,
-                    role: 'assistant',
-                    content: 'Here are some creative workflow automation ideas:\n\n**Social Media Automation:**\n- Auto-post blog content to multiple platforms\n- Monitor mentions and send notifications\n- Generate reports on engagement metrics\n\n**Business Operations:**\n- Sync data between CRM and accounting software\n- Auto-generate invoices from project completion\n- Send weekly team reports\n\n**Personal Productivity:**\n- Save email attachments to cloud storage\n- Create calendar events from emails\n- Track expenses from receipts\n\nWhich area interests you most?',
-                    createdAt: new Date('2025-01-07T14:32:00Z').toISOString(),
-                },
-                {
-                    id: '650e8400-e29b-41d4-a716-446655440013',
-                    conversationId,
-                    role: 'user',
-                    content: 'The social media automation sounds great! How complex is it to set up?',
-                    createdAt: new Date('2025-01-07T14:45:00Z').toISOString(),
-                },
-                {
-                    id: '650e8400-e29b-41d4-a716-446655440014',
-                    conversationId,
-                    role: 'assistant',
-                    content: "It's actually quite straightforward! For auto-posting to multiple platforms:\n\n**Difficulty: Beginner-friendly**\n\n1. Use an **RSS** trigger to monitor your blog\n2. Add **Twitter**, **LinkedIn**, and **Facebook** nodes\n3. Format your message with expressions\n4. Add conditions to customize per platform\n\nMost of the work is just connecting your accounts. The actual workflow can be set up in under 30 minutes!\n\nWant me to walk you through the specific nodes you'll need?",
-                    createdAt: new Date('2025-01-07T14:47:00Z').toISOString(),
-                },
-            ],
-            '9b2e4f6a-7d1c-4a8b-9e3f-5c7d2a8b4e6f': [
-                {
-                    id: '650e8400-e29b-41d4-a716-446655440021',
-                    conversationId,
-                    role: 'user',
-                    content: "I'm having trouble integrating with the Stripe API. Any tips?",
-                    createdAt: new Date('2025-01-06T09:00:00Z').toISOString(),
-                },
-                {
-                    id: '650e8400-e29b-41d4-a716-446655440022',
-                    conversationId,
-                    role: 'assistant',
-                    content: "I'd be happy to help with Stripe integration! What specific issue are you encountering?\n\n**Common Stripe integration patterns in n8n:**\n\n1. **Webhook-based** (Recommended)\n   - Stripe sends events to n8n\n   - Great for payment notifications\n   - Real-time updates\n\n2. **Polling-based**\n   - Check for new data periodically\n   - Good for reports and syncing\n\n3. **Manual trigger**\n   - Run on-demand operations\n   - Create customers, charges, etc.\n\nWhat's your use case?",
-                    createdAt: new Date('2025-01-06T09:02:00Z').toISOString(),
-                },
-                {
-                    id: '650e8400-e29b-41d4-a716-446655440023',
-                    conversationId,
-                    role: 'user',
-                    content: 'I want to receive notifications when a payment succeeds and create an invoice in my accounting software.',
-                    createdAt: new Date('2025-01-06T09:15:00Z').toISOString(),
-                },
-                {
-                    id: '650e8400-e29b-41d4-a716-446655440024',
-                    conversationId,
-                    role: 'assistant',
-                    content: "Perfect use case for webhooks! Here's the setup:\n\n**Step 1: n8n Webhook**\n- Add a Webhook node\n- Set method to POST\n- Copy the webhook URL\n\n**Step 2: Stripe Dashboard**\n- Go to Developers → Webhooks\n- Add endpoint with your n8n URL\n- Select `payment_intent.succeeded` event\n\n**Step 3: Process Payment Data**\n- Add a **Function** node to extract payment details\n- Parse customer, amount, currency\n\n**Step 4: Create Invoice**\n- Add your accounting software node (QuickBooks, Xero, etc.)\n- Map payment data to invoice fields\n\n**Step 5: Send Notification**\n- Add Email/Slack node for confirmation\n\nWant the specific code for the Function node?",
-                    createdAt: new Date('2025-01-06T09:18:00Z').toISOString(),
-                },
-            ],
+    convertMessageToDto(message) {
+        return {
+            id: message.id,
+            sessionId: message.sessionId,
+            type: message.type,
+            name: message.name,
+            content: message.content,
+            provider: message.provider,
+            model: message.model,
+            workflowId: message.workflowId,
+            executionId: message.executionId,
+            status: message.status,
+            createdAt: message.createdAt.toISOString(),
+            updatedAt: message.updatedAt.toISOString(),
+            previousMessageId: message.previousMessageId,
+            retryOfMessageId: message.retryOfMessageId,
+            revisionOfMessageId: message.revisionOfMessageId,
         };
-        const messages = mockConversations[conversationId];
-        if (messages) {
-            return messages;
+    }
+    buildMessageHistory(messages, lastMessageId) {
+        if (!lastMessageId)
+            return [];
+        const visited = new Set();
+        const historyIds = [];
+        let current = lastMessageId;
+        while (current && !visited.has(current)) {
+            historyIds.unshift(current);
+            visited.add(current);
+            current = messages[current]?.previousMessageId ?? null;
+        }
+        const history = historyIds.flatMap((id) => messages[id] ?? []);
+        return history;
+    }
+    async deleteAllSessions() {
+        const result = await this.sessionRepository.deleteAll();
+        return result;
+    }
+    async updateSessionTitle(userId, sessionId, title) {
+        const session = await this.sessionRepository.getOneById(sessionId, userId);
+        if (!session) {
+            throw new not_found_error_1.NotFoundError('Session not found');
+        }
+        return await this.sessionRepository.updateChatTitle(sessionId, title);
+    }
+    async deleteSession(userId, sessionId) {
+        const session = await this.sessionRepository.getOneById(sessionId, userId);
+        if (!session) {
+            throw new not_found_error_1.NotFoundError('Session not found');
         }
-        throw new not_found_error_1.NotFoundError(`Conversation not found. ID: ${conversationId}`);
+        await this.sessionRepository.deleteChatHubSession(sessionId);
     }
 };
 exports.ChatHubService = ChatHubService;
@@ -538,12 +720,15 @@ exports.ChatHubService = ChatHubService = __decorate([
     (0, di_1.Service)(),
     __metadata("design:paramtypes", [backend_common_1.Logger,
         credentials_service_1.CredentialsService,
-        credentials_helper_1.CredentialsHelper,
+        execution_service_1.ExecutionService,
+        dynamic_node_parameters_service_1.DynamicNodeParametersService,
         db_1.ExecutionRepository,
         workflow_execution_service_1.WorkflowExecutionService,
         db_1.WorkflowRepository,
         db_1.ProjectRepository,
         db_1.SharedWorkflowRepository,
-        active_executions_1.ActiveExecutions])
+        active_executions_1.ActiveExecutions,
+        chat_session_repository_1.ChatHubSessionRepository,
+        chat_message_repository_1.ChatHubMessageRepository])
 ], ChatHubService);
 //# sourceMappingURL=chat-hub.service.js.map