n8n 2.0.1 → 2.1.0

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

@@ -12,6 +12,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ChatHubService = void 0;
 const api_types_1 = require("@n8n/api-types");
 const backend_common_1 = require("@n8n/backend-common");
+const config_1 = require("@n8n/config");
 const db_1 = require("@n8n/db");
 const di_1 = require("@n8n/di");
 const n8n_core_1 = require("n8n-core");
@@ -27,682 +28,32 @@ const chat_message_repository_1 = require("./chat-message.repository");
 const chat_session_repository_1 = require("./chat-session.repository");
 const stream_capturer_1 = require("./stream-capturer");
 const 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 not_found_error_1 = require("../../errors/response-errors/not-found.error");
 const execution_service_1 = require("../../executions/execution.service");
-const dynamic_node_parameters_service_1 = require("../../services/dynamic-node-parameters.service");
-const workflow_execute_additional_data_1 = require("../../workflow-execute-additional-data");
 const workflow_execution_service_1 = require("../../workflows/workflow-execution.service");
 const workflow_finder_service_1 = require("../../workflows/workflow-finder.service");
-const workflow_service_1 = require("../../workflows/workflow.service");
+const chat_hub_models_service_1 = require("./chat-hub.models.service");
 let ChatHubService = class ChatHubService {
-    constructor(logger, errorReporter, executionService, nodeParametersService, executionRepository, workflowExecutionService, workflowService, workflowFinderService, workflowRepository, activeExecutions, sessionRepository, messageRepository, credentialsFinderService, chatHubAgentService, chatHubCredentialsService, chatHubWorkflowService, chatHubSettingsService, chatHubAttachmentService) {
+    constructor(logger, errorReporter, executionService, executionRepository, workflowExecutionService, workflowFinderService, workflowRepository, activeExecutions, sessionRepository, messageRepository, chatHubAgentService, chatHubCredentialsService, chatHubWorkflowService, chatHubModelsService, chatHubSettingsService, chatHubAttachmentService, instanceSettings, globalConfig) {
         this.logger = logger;
         this.errorReporter = errorReporter;
         this.executionService = executionService;
-        this.nodeParametersService = nodeParametersService;
         this.executionRepository = executionRepository;
         this.workflowExecutionService = workflowExecutionService;
-        this.workflowService = workflowService;
         this.workflowFinderService = workflowFinderService;
         this.workflowRepository = workflowRepository;
         this.activeExecutions = activeExecutions;
         this.sessionRepository = sessionRepository;
         this.messageRepository = messageRepository;
-        this.credentialsFinderService = credentialsFinderService;
         this.chatHubAgentService = chatHubAgentService;
         this.chatHubCredentialsService = chatHubCredentialsService;
         this.chatHubWorkflowService = chatHubWorkflowService;
+        this.chatHubModelsService = chatHubModelsService;
         this.chatHubSettingsService = chatHubSettingsService;
         this.chatHubAttachmentService = chatHubAttachmentService;
-    }
-    async getModels(user, credentialIds) {
-        const additionalData = await (0, workflow_execute_additional_data_1.getBase)({ userId: user.id });
-        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' && provider !== 'custom-agent') {
-                const credentialId = credentialIds[provider];
-                if (!credentialId) {
-                    return [provider, { models: [] }];
-                }
-                if (!allCredentials.some((credential) => credential.id === credentialId)) {
-                    return [
-                        provider,
-                        { models: [], error: 'Could not retrieve models. Verify credentials.' },
-                    ];
-                }
-                credentials[api_types_1.PROVIDER_CREDENTIAL_TYPE_MAP[provider]] = { name: '', id: credentialId };
-            }
-            try {
-                return [
-                    provider,
-                    await this.fetchModelsForProvider(user, provider, credentials, additionalData),
-                ];
-            }
-            catch {
-                return [
-                    provider,
-                    { models: [], error: 'Could not retrieve models. Verify credentials.' },
-                ];
-            }
-        }));
-        return responses.reduce((acc, [provider, res]) => {
-            acc[provider] = res;
-            return acc;
-        }, { ...api_types_1.emptyChatModelsResponse });
-    }
-    async fetchModelsForProvider(user, provider, credentials, additionalData) {
-        switch (provider) {
-            case 'openai':
-                return await this.fetchOpenAiModels(credentials, additionalData);
-            case 'anthropic':
-                return await this.fetchAnthropicModels(credentials, additionalData);
-            case 'google':
-                return await this.fetchGoogleModels(credentials, additionalData);
-            case 'ollama':
-                return await this.fetchOllamaModels(credentials, additionalData);
-            case 'azureOpenAi':
-            case 'azureEntraId':
-                return this.fetchAzureOpenAiModels(credentials, additionalData);
-            case 'awsBedrock':
-                return await this.fetchAwsBedrockModels(credentials, additionalData);
-            case 'vercelAiGateway':
-                return await this.fetchVercelAiGatewayModels(credentials, additionalData);
-            case 'xAiGrok':
-                return await this.fetchXAiGrokModels(credentials, additionalData);
-            case 'groq':
-                return await this.fetchGroqModels(credentials, additionalData);
-            case 'openRouter':
-                return await this.fetchOpenRouterModels(credentials, additionalData);
-            case 'deepSeek':
-                return await this.fetchDeepSeekModels(credentials, additionalData);
-            case 'cohere':
-                return await this.fetchCohereModels(credentials, additionalData);
-            case 'mistralCloud':
-                return await this.fetchMistralCloudModels(credentials, additionalData);
-            case 'n8n':
-                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, chat_hub_constants_1.PROVIDER_NODE_TYPE_MAP.openai, {}, credentials);
-        return {
-            models: resourceLocatorResults.results.map((result) => ({
-                name: result.name,
-                description: result.description ?? null,
-                model: {
-                    provider: 'openai',
-                    model: String(result.value),
-                },
-                createdAt: null,
-                updatedAt: null,
-                allowFileUploads: true,
-            })),
-        };
-    }
-    async fetchAnthropicModels(credentials, additionalData) {
-        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) => ({
-                name: result.name,
-                description: result.description ?? null,
-                model: {
-                    provider: 'anthropic',
-                    model: String(result.value),
-                },
-                createdAt: null,
-                updatedAt: null,
-                allowFileUploads: true,
-            })),
-        };
-    }
-    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, chat_hub_constants_1.PROVIDER_NODE_TYPE_MAP.google, {}, credentials);
-        return {
-            models: results.map((result) => ({
-                name: result.name,
-                description: result.description ?? null,
-                model: {
-                    provider: 'google',
-                    model: String(result.value),
-                },
-                createdAt: null,
-                updatedAt: null,
-                allowFileUploads: true,
-            })),
-        };
-    }
-    async fetchOllamaModels(credentials, additionalData) {
-        const results = await this.nodeParametersService.getOptionsViaLoadOptions({
-            routing: {
-                request: {
-                    method: 'GET',
-                    url: '/api/tags',
-                },
-                output: {
-                    postReceive: [
-                        {
-                            type: 'rootProperty',
-                            properties: {
-                                property: 'models',
-                            },
-                        },
-                        {
-                            type: 'setKeyValue',
-                            properties: {
-                                name: '={{$responseItem.name}}',
-                                value: '={{$responseItem.name}}',
-                            },
-                        },
-                        {
-                            type: 'sort',
-                            properties: {
-                                key: 'name',
-                            },
-                        },
-                    ],
-                },
-            },
-        }, additionalData, chat_hub_constants_1.PROVIDER_NODE_TYPE_MAP.ollama, {}, credentials);
-        return {
-            models: results.map((result) => ({
-                name: result.name,
-                description: result.description ?? null,
-                model: {
-                    provider: 'ollama',
-                    model: String(result.value),
-                },
-                createdAt: null,
-                updatedAt: null,
-                allowFileUploads: true,
-            })),
-        };
-    }
-    fetchAzureOpenAiModels(_credentials, _additionalData) {
-        return {
-            models: [],
-        };
-    }
-    async fetchAwsBedrockModels(credentials, additionalData) {
-        const foundationModelsRequest = this.nodeParametersService.getOptionsViaLoadOptions({
-            routing: {
-                request: {
-                    method: 'GET',
-                    url: '/foundation-models?&byOutputModality=TEXT&byInferenceType=ON_DEMAND',
-                },
-                output: {
-                    postReceive: [
-                        {
-                            type: 'rootProperty',
-                            properties: {
-                                property: 'modelSummaries',
-                            },
-                        },
-                        {
-                            type: 'setKeyValue',
-                            properties: {
-                                name: '={{$responseItem.modelName}}',
-                                description: '={{$responseItem.modelArn}}',
-                                value: '={{$responseItem.modelId}}',
-                            },
-                        },
-                        {
-                            type: 'sort',
-                            properties: {
-                                key: 'name',
-                            },
-                        },
-                    ],
-                },
-            },
-        }, additionalData, chat_hub_constants_1.PROVIDER_NODE_TYPE_MAP.awsBedrock, {}, credentials);
-        const inferenceProfileModelsRequest = this.nodeParametersService.getOptionsViaLoadOptions({
-            routing: {
-                request: {
-                    method: 'GET',
-                    url: '/inference-profiles?maxResults=1000',
-                },
-                output: {
-                    postReceive: [
-                        {
-                            type: 'rootProperty',
-                            properties: {
-                                property: 'inferenceProfileSummaries',
-                            },
-                        },
-                        {
-                            type: 'setKeyValue',
-                            properties: {
-                                name: '={{$responseItem.inferenceProfileName}}',
-                                description: '={{$responseItem.description || $responseItem.inferenceProfileArn}}',
-                                value: '={{$responseItem.inferenceProfileId}}',
-                            },
-                        },
-                        {
-                            type: 'sort',
-                            properties: {
-                                key: 'name',
-                            },
-                        },
-                    ],
-                },
-            },
-        }, additionalData, chat_hub_constants_1.PROVIDER_NODE_TYPE_MAP.awsBedrock, {}, credentials);
-        const [foundationModels, inferenceProfileModels] = await Promise.all([
-            foundationModelsRequest,
-            inferenceProfileModelsRequest,
-        ]);
-        return {
-            models: foundationModels.concat(inferenceProfileModels).map((result) => ({
-                name: result.name,
-                description: result.description ?? String(result.value),
-                model: {
-                    provider: 'awsBedrock',
-                    model: String(result.value),
-                },
-                createdAt: null,
-                updatedAt: null,
-                allowFileUploads: true,
-            })),
-        };
-    }
-    async fetchMistralCloudModels(credentials, additionalData) {
-        const results = await this.nodeParametersService.getOptionsViaLoadOptions({
-            routing: {
-                request: {
-                    method: 'GET',
-                    url: '/models',
-                },
-                output: {
-                    postReceive: [
-                        {
-                            type: 'rootProperty',
-                            properties: {
-                                property: 'data',
-                            },
-                        },
-                        {
-                            type: 'filter',
-                            properties: {
-                                pass: "={{ !$responseItem.id.includes('embed') }}",
-                            },
-                        },
-                        {
-                            type: 'setKeyValue',
-                            properties: {
-                                name: '={{ $responseItem.id }}',
-                                value: '={{ $responseItem.id }}',
-                            },
-                        },
-                        {
-                            type: 'sort',
-                            properties: {
-                                key: 'name',
-                            },
-                        },
-                    ],
-                },
-            },
-        }, additionalData, chat_hub_constants_1.PROVIDER_NODE_TYPE_MAP.mistralCloud, {}, credentials);
-        return {
-            models: results.map((result) => ({
-                name: result.name,
-                description: result.description ?? String(result.value),
-                model: {
-                    provider: 'mistralCloud',
-                    model: String(result.value),
-                },
-                createdAt: null,
-                updatedAt: null,
-            })),
-        };
-    }
-    async fetchCohereModels(credentials, additionalData) {
-        const results = await this.nodeParametersService.getOptionsViaLoadOptions({
-            routing: {
-                request: {
-                    method: 'GET',
-                    url: '/v1/models?page_size=100&endpoint=chat',
-                },
-                output: {
-                    postReceive: [
-                        {
-                            type: 'rootProperty',
-                            properties: {
-                                property: 'models',
-                            },
-                        },
-                        {
-                            type: 'setKeyValue',
-                            properties: {
-                                name: '={{$responseItem.name}}',
-                                value: '={{$responseItem.name}}',
-                                description: '={{$responseItem.description}}',
-                            },
-                        },
-                        {
-                            type: 'sort',
-                            properties: {
-                                key: 'name',
-                            },
-                        },
-                    ],
-                },
-            },
-        }, additionalData, chat_hub_constants_1.PROVIDER_NODE_TYPE_MAP.cohere, {}, credentials);
-        return {
-            models: results.map((result) => ({
-                name: result.name,
-                description: result.description ?? null,
-                model: {
-                    provider: 'cohere',
-                    model: String(result.value),
-                },
-                createdAt: null,
-                updatedAt: null,
-            })),
-        };
-    }
-    async fetchDeepSeekModels(credentials, additionalData) {
-        const results = await this.nodeParametersService.getOptionsViaLoadOptions({
-            routing: {
-                request: {
-                    method: 'GET',
-                    url: '/models',
-                },
-                output: {
-                    postReceive: [
-                        {
-                            type: 'rootProperty',
-                            properties: {
-                                property: 'data',
-                            },
-                        },
-                        {
-                            type: 'setKeyValue',
-                            properties: {
-                                name: '={{$responseItem.id}}',
-                                value: '={{$responseItem.id}}',
-                            },
-                        },
-                        {
-                            type: 'sort',
-                            properties: {
-                                key: 'name',
-                            },
-                        },
-                    ],
-                },
-            },
-        }, additionalData, chat_hub_constants_1.PROVIDER_NODE_TYPE_MAP.deepSeek, {}, credentials);
-        return {
-            models: results.map((result) => ({
-                name: result.name,
-                description: result.description ?? String(result.value),
-                model: {
-                    provider: 'deepSeek',
-                    model: String(result.value),
-                },
-                createdAt: null,
-                updatedAt: null,
-            })),
-        };
-    }
-    async fetchOpenRouterModels(credentials, additionalData) {
-        const results = await this.nodeParametersService.getOptionsViaLoadOptions({
-            routing: {
-                request: {
-                    method: 'GET',
-                    url: '/models',
-                },
-                output: {
-                    postReceive: [
-                        {
-                            type: 'rootProperty',
-                            properties: {
-                                property: 'data',
-                            },
-                        },
-                        {
-                            type: 'setKeyValue',
-                            properties: {
-                                name: '={{$responseItem.id}}',
-                                value: '={{$responseItem.id}}',
-                            },
-                        },
-                        {
-                            type: 'sort',
-                            properties: {
-                                key: 'name',
-                            },
-                        },
-                    ],
-                },
-            },
-        }, additionalData, chat_hub_constants_1.PROVIDER_NODE_TYPE_MAP.openRouter, {}, credentials);
-        return {
-            models: results.map((result) => ({
-                name: result.name,
-                description: result.description ?? null,
-                model: {
-                    provider: 'openRouter',
-                    model: String(result.value),
-                },
-                createdAt: null,
-                updatedAt: null,
-            })),
-        };
-    }
-    async fetchGroqModels(credentials, additionalData) {
-        const results = await this.nodeParametersService.getOptionsViaLoadOptions({
-            routing: {
-                request: {
-                    method: 'GET',
-                    url: '/models',
-                },
-                output: {
-                    postReceive: [
-                        {
-                            type: 'rootProperty',
-                            properties: {
-                                property: 'data',
-                            },
-                        },
-                        {
-                            type: 'filter',
-                            properties: {
-                                pass: '={{ $responseItem.active === true && $responseItem.object === "model" }}',
-                            },
-                        },
-                        {
-                            type: 'setKeyValue',
-                            properties: {
-                                name: '={{$responseItem.id}}',
-                                value: '={{$responseItem.id}}',
-                            },
-                        },
-                    ],
-                },
-            },
-        }, additionalData, chat_hub_constants_1.PROVIDER_NODE_TYPE_MAP.groq, {}, credentials);
-        return {
-            models: results.map((result) => ({
-                name: result.name,
-                description: result.description ?? null,
-                model: {
-                    provider: 'groq',
-                    model: String(result.value),
-                },
-                createdAt: null,
-                updatedAt: null,
-            })),
-        };
-    }
-    async fetchXAiGrokModels(credentials, additionalData) {
-        const results = await this.nodeParametersService.getOptionsViaLoadOptions({
-            routing: {
-                request: {
-                    method: 'GET',
-                    url: '/models',
-                },
-                output: {
-                    postReceive: [
-                        {
-                            type: 'rootProperty',
-                            properties: {
-                                property: 'data',
-                            },
-                        },
-                        {
-                            type: 'setKeyValue',
-                            properties: {
-                                name: '={{$responseItem.id}}',
-                                value: '={{$responseItem.id}}',
-                            },
-                        },
-                        {
-                            type: 'sort',
-                            properties: {
-                                key: 'name',
-                            },
-                        },
-                    ],
-                },
-            },
-        }, additionalData, chat_hub_constants_1.PROVIDER_NODE_TYPE_MAP.xAiGrok, {}, credentials);
-        return {
-            models: results.map((result) => ({
-                name: result.name,
-                description: result.description ?? null,
-                model: {
-                    provider: 'xAiGrok',
-                    model: String(result.value),
-                },
-                createdAt: null,
-                updatedAt: null,
-            })),
-        };
-    }
-    async fetchVercelAiGatewayModels(credentials, additionalData) {
-        const results = await this.nodeParametersService.getOptionsViaLoadOptions({
-            routing: {
-                request: {
-                    method: 'GET',
-                    url: '/models',
-                },
-                output: {
-                    postReceive: [
-                        {
-                            type: 'rootProperty',
-                            properties: {
-                                property: 'data',
-                            },
-                        },
-                        {
-                            type: 'setKeyValue',
-                            properties: {
-                                name: '={{$responseItem.id}}',
-                                value: '={{$responseItem.id}}',
-                            },
-                        },
-                        {
-                            type: 'sort',
-                            properties: {
-                                key: 'name',
-                            },
-                        },
-                    ],
-                },
-            },
-        }, additionalData, chat_hub_constants_1.PROVIDER_NODE_TYPE_MAP.vercelAiGateway, {}, credentials);
-        return {
-            models: results.map((result) => ({
-                name: result.name,
-                description: result.description ?? String(result.value),
-                model: {
-                    provider: 'vercelAiGateway',
-                    model: String(result.value),
-                },
-                createdAt: null,
-                updatedAt: null,
-            })),
-        };
-    }
-    async fetchAgentWorkflowsAsModels(user) {
-        const nodeTypes = [n8n_workflow_1.CHAT_TRIGGER_NODE_TYPE];
-        const workflows = await this.workflowService.getWorkflowsWithNodesIncluded(user, nodeTypes, true);
-        return {
-            models: workflows
-                .filter((workflow) => workflow.scopes.includes('workflow:read'))
-                .filter((workflow) => !!workflow.activeVersionId)
-                .flatMap((workflow) => {
-                const chatTrigger = workflow.nodes?.find((node) => node.type === n8n_workflow_1.CHAT_TRIGGER_NODE_TYPE);
-                if (!chatTrigger) {
-                    return [];
-                }
-                const chatTriggerParams = chat_hub_types_1.validChatTriggerParamsShape.safeParse(chatTrigger.parameters).data;
-                if (!chatTriggerParams) {
-                    return [];
-                }
-                return [
-                    {
-                        name: chatTriggerParams.agentName ?? workflow.name ?? 'Unknown Agent',
-                        description: chatTriggerParams.agentDescription ?? null,
-                        model: {
-                            provider: 'n8n',
-                            workflowId: workflow.id,
-                        },
-                        createdAt: workflow.createdAt ? workflow.createdAt.toISOString() : null,
-                        updatedAt: workflow.updatedAt ? workflow.updatedAt.toISOString() : null,
-                        allowFileUploads: chatTriggerParams.options?.allowFileUploads ?? false,
-                    },
-                ];
-            }),
-        };
+        this.instanceSettings = instanceSettings;
+        this.globalConfig = globalConfig;
     }
     async deleteChatWorkflow(workflowId) {
         await this.workflowRepository.delete(workflowId);
@@ -737,11 +88,13 @@ let ChatHubService = class ChatHubService {
         return credentials[api_types_1.PROVIDER_CREDENTIAL_TYPE_MAP[provider]]?.id ?? null;
     }
     async sendHumanMessage(res, user, payload) {
-        const { sessionId, messageId, message, model, credentials, previousMessageId, tools, attachments, } = payload;
+        const { sessionId, messageId, message, model, credentials, previousMessageId, tools, attachments, timeZone, } = payload;
+        const tz = timeZone ?? this.globalConfig.generic.timezone;
         const credentialId = this.getModelCredential(model, credentials);
         const processedAttachments = await this.chatHubAttachmentService.store(sessionId, messageId, attachments);
         let executionData;
         let workflowData;
+        let responseMode;
         try {
             const result = await this.messageRepository.manager.transaction(async (trx) => {
                 let session = await this.getChatSession(user, sessionId, trx);
@@ -750,10 +103,11 @@ let ChatHubService = class ChatHubService {
                 const messages = Object.fromEntries((session.messages ?? []).map((m) => [m.id, m]));
                 const history = this.buildMessageHistory(messages, previousMessageId);
                 await this.saveHumanMessage(payload, processedAttachments, user, previousMessageId, model, undefined, trx);
-                return await this.prepareReplyWorkflow(user, sessionId, credentials, model, history, message, tools, processedAttachments, trx);
+                return await this.prepareReplyWorkflow(user, sessionId, credentials, model, history, message, tools, processedAttachments, tz, trx);
             });
             executionData = result.executionData;
             workflowData = result.workflowData;
+            responseMode = result.responseMode;
         }
         catch (error) {
             if (processedAttachments.length > 0) {
@@ -766,15 +120,16 @@ let ChatHubService = class ChatHubService {
             }
             throw error;
         }
-        await this.executeChatWorkflowWithCleanup(res, user, workflowData, executionData, sessionId, messageId, model);
+        await this.executeChatWorkflowWithCleanup(res, user, workflowData, executionData, sessionId, messageId, model, null, responseMode);
         if (previousMessageId === null) {
-            await this.generateSessionTitle(user, sessionId, message, credentials, model).catch((error) => {
+            await this.generateSessionTitle(user, sessionId, message, processedAttachments, credentials, model).catch((error) => {
                 this.logger.error(`Title generation failed: ${error}`);
             });
         }
     }
     async editMessage(res, user, payload) {
-        const { sessionId, editId, messageId, message, model, credentials } = payload;
+        const { sessionId, editId, messageId, message, model, credentials, timeZone } = payload;
+        const tz = timeZone ?? this.globalConfig.generic.timezone;
         const workflow = await this.messageRepository.manager.transaction(async (trx) => {
             const session = await this.getChatSession(user, sessionId, trx);
             if (!session) {
@@ -791,19 +146,20 @@ let ChatHubService = class ChatHubService {
                 const revisionOfMessageId = messageToEdit.revisionOfMessageId ?? messageToEdit.id;
                 const attachments = messageToEdit.attachments ?? [];
                 await this.saveHumanMessage(payload, attachments, user, messageToEdit.previousMessageId, model, revisionOfMessageId, trx);
-                return await this.prepareReplyWorkflow(user, sessionId, credentials, model, history, message, session.tools, attachments, trx);
+                return await this.prepareReplyWorkflow(user, sessionId, credentials, model, history, message, session.tools, attachments, tz, trx);
             }
             throw new bad_request_error_1.BadRequestError('Only human and AI messages can be edited');
         });
         if (!workflow) {
             return;
         }
-        const { workflowData, executionData } = workflow;
-        await this.executeChatWorkflowWithCleanup(res, user, workflowData, executionData, sessionId, messageId, model);
+        const { workflowData, executionData, responseMode } = workflow;
+        await this.executeChatWorkflowWithCleanup(res, user, workflowData, executionData, sessionId, messageId, model, null, responseMode);
     }
     async regenerateAIMessage(res, user, payload) {
-        const { sessionId, retryId, model, credentials } = payload;
-        const { workflow: { workflowData, executionData }, retryOfMessageId, previousMessageId, } = await this.messageRepository.manager.transaction(async (trx) => {
+        const { sessionId, retryId, model, credentials, timeZone } = payload;
+        const tz = timeZone ?? this.globalConfig.generic.timezone;
+        const { workflow: { workflowData, executionData, responseMode }, retryOfMessageId, previousMessageId, } = await this.messageRepository.manager.transaction(async (trx) => {
             const session = await this.getChatSession(user, sessionId, trx);
             if (!session) {
                 throw new not_found_error_1.NotFoundError('Chat session not found');
@@ -825,30 +181,30 @@ let ChatHubService = class ChatHubService {
             const retryOfMessageId = messageToRetry.retryOfMessageId ?? messageToRetry.id;
             const message = lastHumanMessage ? lastHumanMessage.content : '';
             const attachments = lastHumanMessage.attachments ?? [];
-            const workflow = await this.prepareReplyWorkflow(user, sessionId, credentials, model, history, message, session.tools, attachments, trx);
+            const workflow = await this.prepareReplyWorkflow(user, sessionId, credentials, model, history, message, session.tools, attachments, tz, trx);
             return {
                 workflow,
                 previousMessageId: lastHumanMessage.id,
                 retryOfMessageId,
             };
         });
-        await this.executeChatWorkflowWithCleanup(res, user, workflowData, executionData, sessionId, previousMessageId, model, retryOfMessageId);
+        await this.executeChatWorkflowWithCleanup(res, user, workflowData, executionData, sessionId, previousMessageId, model, retryOfMessageId, responseMode);
     }
-    async prepareReplyWorkflow(user, sessionId, credentials, model, history, message, tools, attachments, trx) {
+    async prepareReplyWorkflow(user, sessionId, credentials, model, history, message, tools, attachments, timeZone, trx) {
         if (model.provider === 'n8n') {
             return await this.prepareCustomAgentWorkflow(user, sessionId, model.workflowId, message, attachments);
         }
         if (model.provider === 'custom-agent') {
-            return await this.prepareChatAgentWorkflow(model.agentId, user, sessionId, history, message, attachments, trx);
+            return await this.prepareChatAgentWorkflow(model.agentId, user, sessionId, history, message, attachments, timeZone, trx);
         }
-        return await this.prepareBaseChatWorkflow(user, sessionId, credentials, model, history, message, undefined, tools, attachments, trx);
+        return await this.prepareBaseChatWorkflow(user, sessionId, credentials, model, history, message, undefined, tools, attachments, timeZone, trx);
     }
-    async prepareBaseChatWorkflow(user, sessionId, credentials, model, history, message, systemMessage, tools, attachments, trx) {
+    async prepareBaseChatWorkflow(user, sessionId, credentials, model, history, message, systemMessage, tools, attachments, timeZone, trx) {
         await this.chatHubSettingsService.ensureModelIsAllowed(model);
         const credential = await this.chatHubCredentialsService.ensureCredentials(user, model.provider, credentials, trx);
-        return await this.chatHubWorkflowService.createChatWorkflow(user.id, sessionId, credential.projectId, history, message, attachments, credentials, model, systemMessage, tools, trx);
+        return await this.chatHubWorkflowService.createChatWorkflow(user.id, sessionId, credential.projectId, history, message, attachments, credentials, model, systemMessage, tools, timeZone, trx);
     }
-    async prepareChatAgentWorkflow(agentId, user, sessionId, history, message, attachments, trx) {
+    async prepareChatAgentWorkflow(agentId, user, sessionId, history, message, attachments, timeZone, trx) {
         const agent = await this.chatHubAgentService.getAgentById(agentId, user.id);
         if (!agent) {
             throw new bad_request_error_1.BadRequestError('Agent not found');
@@ -856,14 +212,11 @@ let ChatHubService = class ChatHubService {
         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 systemMessage = agent.systemPrompt + '\n\n' + this.chatHubWorkflowService.getSystemMessageMetadata(timeZone);
         const model = {
             provider: agent.provider,
             model: agent.model,
@@ -874,24 +227,42 @@ let ChatHubService = class ChatHubService {
                 name: '',
             },
         };
-        const tools = [];
-        return await this.prepareBaseChatWorkflow(user, sessionId, credentials, model, history, message, systemMessage, tools, attachments, trx);
+        const { tools } = agent;
+        return await this.prepareBaseChatWorkflow(user, sessionId, credentials, model, history, message, systemMessage, tools, attachments, timeZone, trx);
     }
     async prepareCustomAgentWorkflow(user, sessionId, workflowId, message, attachments) {
-        const workflowEntity = await this.workflowFinderService.findWorkflowForUser(workflowId, user, ['workflow:read'], { includeTags: false, includeParentFolder: false });
-        if (!workflowEntity) {
+        const workflow = await this.workflowFinderService.findWorkflowForUser(workflowId, user, ['workflow:execute-chat'], { includeTags: false, includeParentFolder: false, includeActiveVersion: true });
+        if (!workflow?.activeVersion) {
             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);
+        const chatTriggers = workflow.activeVersion.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);
+        const chatTrigger = chatTriggers[0];
+        if (chatTrigger.typeVersion < chat_hub_constants_1.CHAT_TRIGGER_NODE_MIN_VERSION) {
+            throw new bad_request_error_1.BadRequestError('Chat Trigger node version is too old to support Chat. Please update the node.');
+        }
+        const chatTriggerParams = chat_hub_types_1.chatTriggerParamsShape.safeParse(chatTrigger.parameters).data;
+        if (!chatTriggerParams) {
+            throw new bad_request_error_1.BadRequestError('Chat Trigger node has invalid parameters');
+        }
+        if (!chatTriggerParams.availableInChat) {
+            throw new bad_request_error_1.BadRequestError('Chat Trigger node must be made available in Chat');
+        }
+        const responseMode = chatTriggerParams.options?.responseMode ?? 'streaming';
+        if (responseMode !== 'streaming') {
+            throw new bad_request_error_1.BadRequestError('Chat Trigger node response mode must be set to streaming to use the workflow on Chat');
+        }
+        const chatResponseNodes = workflow.activeVersion.nodes.filter((node) => node.type === n8n_workflow_1.RESPOND_TO_CHAT_NODE_TYPE);
         if (chatResponseNodes.length > 0) {
             throw new bad_request_error_1.BadRequestError('Respond to Chat nodes are not supported in custom agent workflows');
         }
-        const nodeExecutionStack = this.chatHubWorkflowService.prepareExecutionData(chatTriggerNode, sessionId, message, attachments);
+        const agentNodes = workflow.activeVersion.nodes?.filter((node) => node.type === n8n_workflow_1.AGENT_LANGCHAIN_NODE_TYPE);
+        if (agentNodes.some((node) => node.typeVersion < chat_hub_constants_1.TOOLS_AGENT_NODE_MIN_VERSION)) {
+            throw new bad_request_error_1.BadRequestError('Agent node version is too old to support streaming responses. Please update the node.');
+        }
+        const nodeExecutionStack = this.chatHubWorkflowService.prepareExecutionData(chatTrigger, sessionId, message, attachments);
         const executionData = (0, n8n_workflow_1.createRunExecutionData)({
             executionData: {
                 nodeExecutionStack,
@@ -900,11 +271,15 @@ let ChatHubService = class ChatHubService {
                 userId: user.id,
             },
         });
+        const workflowData = {
+            ...workflow,
+            nodes: workflow.activeVersion.nodes,
+            connections: workflow.activeVersion.connections,
+        };
         return {
-            workflowData: {
-                ...workflowEntity,
-            },
+            workflowData,
             executionData,
+            responseMode,
         };
     }
     async ensurePreviousMessage(previousMessageId, sessionId, trx) {
@@ -937,8 +312,11 @@ let ChatHubService = class ChatHubService {
         await this.executionService.stop(message.execution.id, [message.execution.workflowId]);
         await this.messageRepository.updateChatMessage(messageId, { status: 'cancelled' });
     }
-    async executeChatWorkflow(res, user, workflowData, executionData, sessionId, previousMessageId, model, retryOfMessageId = null, executionMode = 'chat') {
+    async executeChatWorkflow(res, user, workflowData, executionData, sessionId, previousMessageId, model, retryOfMessageId = null, executionMode = 'chat', responseMode) {
         this.logger.debug(`Starting execution of workflow "${workflowData.name}" with ID ${workflowData.id}`);
+        if (responseMode !== 'streaming') {
+            throw new bad_request_error_1.BadRequestError(`Response mode "${responseMode}" is not supported yet.`);
+        }
         let executionId = undefined;
         const aggregator = (0, stream_capturer_1.createStructuredChunkAggregator)(previousMessageId, retryOfMessageId, {
             onBegin: async (message) => {
@@ -995,7 +373,7 @@ let ChatHubService = class ChatHubService {
                     executionId: executionId ? +executionId : null,
                 },
             };
-            return JSON.stringify(enriched) + '\n';
+            return (0, n8n_workflow_1.jsonStringify)(enriched) + '\n';
         };
         const stream = (0, stream_capturer_1.interceptResponseWrites)(res, transform);
         stream.on('finish', aggregator.finalizeAll);
@@ -1007,6 +385,52 @@ let ChatHubService = class ChatHubService {
         if (!executionId) {
             throw new n8n_workflow_1.OperationalError('There was a problem starting the chat execution.');
         }
+        await this.waitForExecutionCompletion(executionId);
+    }
+    async waitForExecutionCompletion(executionId) {
+        if (this.instanceSettings.isMultiMain) {
+            return await this.waitForExecutionPoller(executionId);
+        }
+        else {
+            return await this.waitForExecutionPromise(executionId);
+        }
+    }
+    async waitForExecutionPoller(executionId) {
+        return await new Promise((resolve, reject) => {
+            const poller = setInterval(async () => {
+                try {
+                    const result = await this.executionRepository.findSingleExecution(executionId, {
+                        includeData: false,
+                        unflattenData: false,
+                    });
+                    if (!result || chat_hub_constants_1.EXECUTION_FINISHED_STATUSES.includes(result.status)) {
+                        this.logger.debug(`Execution ${executionId} finished with status ${result?.status ?? 'missing'}`);
+                        clearInterval(poller);
+                        resolve();
+                    }
+                }
+                catch (error) {
+                    this.logger.error(`Stopping polling for execution ${executionId} due to error.`);
+                    clearInterval(poller);
+                    if (error instanceof Error) {
+                        this.logger.error(`Error while polling execution ${executionId}: ${error.message}`, {
+                            error,
+                        });
+                    }
+                    else {
+                        this.logger.error(`Unknown error while polling execution ${executionId}`, { error });
+                    }
+                    if (error instanceof Error) {
+                        reject(error);
+                    }
+                    else {
+                        reject(new Error('Unknown error while polling execution status'));
+                    }
+                }
+            }, chat_hub_constants_1.EXECUTION_POLL_INTERVAL);
+        });
+    }
+    async waitForExecutionPromise(executionId) {
         try {
             const result = await this.activeExecutions.getPostExecutePromise(executionId);
             if (!result) {
@@ -1023,10 +447,10 @@ let ChatHubService = class ChatHubService {
             throw error;
         }
     }
-    async executeChatWorkflowWithCleanup(res, user, workflowData, executionData, sessionId, previousMessageId, model, retryOfMessageId = null) {
+    async executeChatWorkflowWithCleanup(res, user, workflowData, executionData, sessionId, previousMessageId, model, retryOfMessageId, responseMode) {
         try {
             const executionMode = model.provider === 'n8n' ? 'webhook' : 'chat';
-            await this.executeChatWorkflow(res, user, workflowData, executionData, sessionId, previousMessageId, model, retryOfMessageId, executionMode);
+            await this.executeChatWorkflow(res, user, workflowData, executionData, sessionId, previousMessageId, model, retryOfMessageId, executionMode, responseMode);
         }
         finally {
             if (model.provider !== 'n8n') {
@@ -1034,8 +458,8 @@ let ChatHubService = class ChatHubService {
             }
         }
     }
-    async generateSessionTitle(user, sessionId, humanMessage, credentials, model) {
-        const { executionData, workflowData } = await this.prepareTitleGenerationWorkflow(user, sessionId, humanMessage, credentials, model);
+    async generateSessionTitle(user, sessionId, humanMessage, attachments, credentials, model) {
+        const { executionData, workflowData } = await this.prepareTitleGenerationWorkflow(user, sessionId, humanMessage, attachments, credentials, model);
         try {
             const title = await this.runTitleWorkflowAndGetTitle(user, workflowData, executionData);
             if (title) {
@@ -1052,14 +476,14 @@ let ChatHubService = class ChatHubService {
             await this.deleteChatWorkflow(workflowData.id);
         }
     }
-    async prepareTitleGenerationWorkflow(user, sessionId, humanMessage, incomingCredentials, incomingModel) {
+    async prepareTitleGenerationWorkflow(user, sessionId, humanMessage, attachments, 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);
+            this.logger.debug(`Using credential ID ${credential.id} for title generation in project ${credential.projectId}, model ${(0, n8n_workflow_1.jsonStringify)(resolvedModel)}`);
+            return await this.chatHubWorkflowService.createTitleGenerationWorkflow(user.id, sessionId, credential.projectId, humanMessage, attachments, resolvedCredentials, resolvedModel, trx);
         });
     }
     async resolveCredentialsAndModelForTitle(user, model, credentials, trx) {
@@ -1077,11 +501,11 @@ let ChatHubService = class ChatHubService {
         };
     }
     async resolveFromN8nWorkflow(user, { workflowId }, trx) {
-        const workflowEntity = await this.workflowFinderService.findWorkflowForUser(workflowId, user, ['workflow:read'], { includeTags: false, includeParentFolder: false, em: trx });
-        if (!workflowEntity) {
+        const workflowEntity = await this.workflowFinderService.findWorkflowForUser(workflowId, user, ['workflow:execute-chat'], { includeTags: false, includeParentFolder: false, includeActiveVersion: true, em: trx });
+        if (!workflowEntity?.activeVersion) {
             throw new bad_request_error_1.BadRequestError('Workflow not found for title generation');
         }
-        const modelNodes = this.findSupportedLLMNodes(workflowEntity);
+        const modelNodes = this.findSupportedLLMNodes(workflowEntity.activeVersion.nodes);
         this.logger.debug(`Found ${modelNodes.length} LLM nodes in workflow ${workflowEntity.id} for title generation`);
         if (modelNodes.length === 0) {
             throw new bad_request_error_1.BadRequestError('No supported Model nodes found in workflow for title generation');
@@ -1111,8 +535,8 @@ let ChatHubService = class ChatHubService {
         };
         return { resolvedCredentials, resolvedModel, credential };
     }
-    findSupportedLLMNodes(workflowEntity) {
-        return workflowEntity.nodes.reduce((acc, node) => {
+    findSupportedLLMNodes(nodes) {
+        return 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;
@@ -1126,9 +550,6 @@ let ChatHubService = class ChatHubService {
         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');
@@ -1147,24 +568,8 @@ let ChatHubService = class ChatHubService {
         return { resolvedCredentials, resolvedModel, credential };
     }
     async runTitleWorkflowAndGetTitle(user, workflowData, executionData) {
-        const started = await this.workflowExecutionService.executeChatWorkflow(workflowData, executionData, user, undefined, false, 'chat');
-        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 { executionId } = await this.workflowExecutionService.executeChatWorkflow(workflowData, executionData, user, undefined, false, 'chat');
+        await this.waitForExecutionCompletion(executionId);
         const execution = await this.executionRepository.findWithUnflattenedData(executionId, [
             workflowData.id,
         ]);
@@ -1238,21 +643,7 @@ let ChatHubService = class ChatHubService {
         const data = hasMore ? sessions.slice(0, limit) : sessions;
         const nextCursor = hasMore ? data[data.length - 1].id : null;
         return {
-            data: data.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,
-                agentId: session.agentId,
-                agentName: session.agentName ?? '',
-                createdAt: session.createdAt.toISOString(),
-                updatedAt: session.updatedAt.toISOString(),
-                tools: session.tools,
-            })),
+            data: data.map((session) => this.convertSessionEntityToDto(session)),
             nextCursor,
             hasMore,
         };
@@ -1264,21 +655,7 @@ let ChatHubService = class ChatHubService {
         }
         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,
-                agentId: session.agentId,
-                agentName: session.agentName ?? '',
-                createdAt: session.createdAt.toISOString(),
-                updatedAt: session.updatedAt.toISOString(),
-                tools: session.tools,
-            },
+            session: this.convertSessionEntityToDto(session),
             conversation: {
                 messages: Object.fromEntries(messages.map((m) => [m.id, this.convertMessageToDto(m)])),
             },
@@ -1363,6 +740,8 @@ let ChatHubService = class ChatHubService {
             sessionUpdates.title = updates.title;
         if (updates.credentialId !== undefined)
             sessionUpdates.credentialId = updates.credentialId;
+        if (updates.tools !== undefined)
+            sessionUpdates.tools = updates.tools;
         return await this.sessionRepository.updateChatSession(sessionId, sessionUpdates);
     }
     async deleteSession(userId, sessionId) {
@@ -1381,16 +760,39 @@ let ChatHubService = class ChatHubService {
             }
         }
         if (model.provider === 'n8n') {
-            const workflow = await this.workflowFinderService.findWorkflowForUser(model.workflowId, user, ['workflow:read'], { includeTags: false, includeParentFolder: false });
-            if (!workflow) {
+            const workflowEntity = await this.workflowFinderService.findWorkflowForUser(model.workflowId, user, ['workflow:execute-chat'], { includeTags: false, includeParentFolder: false, includeActiveVersion: true });
+            if (!workflowEntity?.activeVersion) {
                 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);
+            const chatTrigger = workflowEntity.activeVersion.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');
             }
         }
     }
+    convertSessionEntityToDto(session) {
+        const agent = session.workflow
+            ? this.chatHubModelsService.extractModelFromWorkflow(session.workflow)
+            : session.agent
+                ? this.chatHubAgentService.convertAgentEntityToModel(session.agent)
+                : undefined;
+        return {
+            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,
+            agentId: session.agentId,
+            agentName: agent?.name ?? session.agentName ?? session.model ?? '',
+            agentIcon: agent?.icon ?? null,
+            createdAt: session.createdAt.toISOString(),
+            updatedAt: session.updatedAt.toISOString(),
+            tools: session.tools,
+        };
+    }
 };
 exports.ChatHubService = ChatHubService;
 exports.ChatHubService = ChatHubService = __decorate([
@@ -1398,20 +800,20 @@ exports.ChatHubService = ChatHubService = __decorate([
     __metadata("design:paramtypes", [backend_common_1.Logger,
         n8n_core_1.ErrorReporter,
         execution_service_1.ExecutionService,
-        dynamic_node_parameters_service_1.DynamicNodeParametersService,
         db_1.ExecutionRepository,
         workflow_execution_service_1.WorkflowExecutionService,
-        workflow_service_1.WorkflowService,
         workflow_finder_service_1.WorkflowFinderService,
         db_1.WorkflowRepository,
         active_executions_1.ActiveExecutions,
         chat_session_repository_1.ChatHubSessionRepository,
         chat_message_repository_1.ChatHubMessageRepository,
-        credentials_finder_service_1.CredentialsFinderService,
         chat_hub_agent_service_1.ChatHubAgentService,
         chat_hub_credentials_service_1.ChatHubCredentialsService,
         chat_hub_workflow_service_1.ChatHubWorkflowService,
+        chat_hub_models_service_1.ChatHubModelsService,
         chat_hub_settings_service_1.ChatHubSettingsService,
-        chat_hub_attachment_service_1.ChatHubAttachmentService])
+        chat_hub_attachment_service_1.ChatHubAttachmentService,
+        n8n_core_1.InstanceSettings,
+        config_1.GlobalConfig])
 ], ChatHubService);
 //# sourceMappingURL=chat-hub.service.js.map