n8n 2.23.2 → 2.24.0

package/dist/modules/agents/agents.service.js

@@ -60,6 +60,7 @@ const conflict_error_1 = require("../../errors/response-errors/conflict.error");
 const not_found_error_1 = require("../../errors/response-errors/not-found.error");
 const node_definition_resolver_1 = require("../../modules/instance-ai/node-definition-resolver");
 const node_execution_1 = require("../../node-execution");
+const oauth_service_1 = require("../../oauth/oauth.service");
 const publisher_service_1 = require("../../scaling/pubsub/publisher.service");
 const url_service_1 = require("../../services/url.service");
 const telemetry_1 = require("../../telemetry");
@@ -75,18 +76,31 @@ const agent_execution_service_1 = require("./agent-execution.service");
 const agent_skills_service_1 = require("./agent-skills.service");
 const agents_tools_service_1 = require("./agents-tools.service");
 const builder_tool_names_1 = require("./builder/builder-tool-names");
+const llm_provider_defaults_1 = require("./builder/interactive/llm-provider-defaults");
+const agent_task_entity_1 = require("./entities/agent-task.entity");
 const execution_recorder_1 = require("./execution-recorder");
 const agent_chat_integration_1 = require("./integrations/agent-chat-integration");
+const integration_action_executor_1 = require("./integrations/integration-action-executor");
+const integration_context_query_executor_1 = require("./integrations/integration-context-query-executor");
+const integration_message_context_service_1 = require("./integrations/integration-message-context.service");
+const integration_tools_1 = require("./integrations/integration-tools");
 const integrations_sync_1 = require("./integrations/integrations-sync");
 const n8n_checkpoint_storage_1 = require("./integrations/n8n-checkpoint-storage");
 const n8n_memory_1 = require("./integrations/n8n-memory");
+const environment_tool_1 = require("./tools/environment-tool");
+const rich_interaction_tool_1 = require("./integrations/rich-interaction-tool");
 const agent_config_composition_1 = require("./json-config/agent-config-composition");
 const from_json_config_1 = require("./json-config/from-json-config");
+const mcp_client_factory_1 = require("./json-config/mcp-client-factory");
 const agent_history_repository_1 = require("./repositories/agent-history.repository");
+const agent_task_snapshot_repository_1 = require("./repositories/agent-task-snapshot.repository");
+const agent_task_repository_1 = require("./repositories/agent-task.repository");
 const agent_repository_1 = require("./repositories/agent.repository");
 const agent_secure_runtime_1 = require("./runtime/agent-secure-runtime");
 const tool_registry_1 = require("./tool-registry");
 const chat_integration_service_1 = require("./integrations/chat-integration.service");
+const agent_knowledge_command_service_1 = require("./agent-knowledge-command.service");
+const agent_knowledge_service_1 = require("./agent-knowledge.service");
 function chatThreadId(agentId, userId) {
     const baseThreadId = `${builder_tool_names_1.AGENT_THREAD_PREFIX.TEST}${agentId}`;
     return userId ? `${baseThreadId}:${userId}` : baseThreadId;
@@ -119,7 +133,10 @@ let AgentsService = class AgentsService {
     clearRuntimes(agentId, options = {}) {
         for (const key of this.runtimes.keys()) {
             if (key === agentId || key.startsWith(`${agentId}:`)) {
+                const entry = this.runtimes.get(key);
                 this.runtimes.delete(key);
+                if (entry)
+                    this.closeAgentResources(entry.agent, agentId);
             }
         }
         if (options.skipBroadcast)
@@ -140,7 +157,7 @@ let AgentsService = class AgentsService {
     handleAgentConfigChanged(payload) {
         this.clearRuntimes(payload.agentId, { skipBroadcast: true });
     }
-    constructor(logger, agentRepository, projectRelationRepository, workflowRunner, activeExecutions, executionRepository, workflowRepository, userRepository, workflowFinderService, urlService, n8nCheckpointStorage, secureRuntime, ephemeralNodeExecutor, agentsToolsService, n8nMemory, agentExecutionService, agentHistoryRepository, agentSkillsService, publisher, agentsConfig, globalConfig, telemetry, chatIntegrationService) {
+    constructor(logger, agentRepository, projectRelationRepository, workflowRunner, activeExecutions, executionRepository, workflowRepository, userRepository, workflowFinderService, urlService, n8nCheckpointStorage, secureRuntime, ephemeralNodeExecutor, agentsToolsService, n8nMemory, agentExecutionService, agentHistoryRepository, agentSkillsService, agentTaskRepository, agentTaskSnapshotRepository, publisher, agentsConfig, globalConfig, telemetry, chatIntegrationService, agentKnowledgeService, agentKnowledgeCommandService, oauthService) {
         this.logger = logger;
         this.agentRepository = agentRepository;
         this.projectRelationRepository = projectRelationRepository;
@@ -159,16 +176,32 @@ let AgentsService = class AgentsService {
         this.agentExecutionService = agentExecutionService;
         this.agentHistoryRepository = agentHistoryRepository;
         this.agentSkillsService = agentSkillsService;
+        this.agentTaskRepository = agentTaskRepository;
+        this.agentTaskSnapshotRepository = agentTaskSnapshotRepository;
         this.publisher = publisher;
         this.agentsConfig = agentsConfig;
         this.globalConfig = globalConfig;
         this.telemetry = telemetry;
         this.chatIntegrationService = chatIntegrationService;
+        this.agentKnowledgeService = agentKnowledgeService;
+        this.agentKnowledgeCommandService = agentKnowledgeCommandService;
+        this.oauthService = oauthService;
         this.runtimes = new ttl_map_1.TtlMap(30 * constants_1.Time.minutes.toMilliseconds);
     }
     isNodeToolsModuleEnabled() {
         return this.agentsConfig.modules.includes('node-tools-searcher');
     }
+    isKnowledgeBaseModuleEnabled() {
+        return this.agentsConfig.modules.includes('knowledge-base');
+    }
+    closeAgentResources(agent, agentId) {
+        agent.close().catch((error) => {
+            this.logger.warn('[AgentsService] Failed to close agent resources on eviction', {
+                agentId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        });
+    }
     createAgentExecutionCounter({ agentId, userId, }) {
         const attribution = userId ? { user_id: userId } : {};
         return {
@@ -200,6 +233,13 @@ let AgentsService = class AgentsService {
             label: i.displayLabel,
             icon: i.displayIcon,
             credentialTypes: i.credentialTypes,
+            ...(i.builderGuidance
+                ? {
+                    capabilities: i.builderGuidance.capabilities,
+                    useIntegrationWhen: i.builderGuidance.useIntegrationWhen,
+                    useNodeToolWhen: i.builderGuidance.useNodeToolWhen,
+                }
+                : {}),
         }));
     }
     async create(projectId, name) {
@@ -279,7 +319,7 @@ let AgentsService = class AgentsService {
         });
         return agents.filter((agent) => agent.activeVersionId !== null);
     }
-    async publishAgent(agentId, projectId, user, versionId) {
+    async publishAgent(agentId, projectId, user, versionId, options = {}) {
         const agent = await this.agentRepository.findByIdAndProjectId(agentId, projectId);
         if (!agent) {
             throw new not_found_error_1.NotFoundError(`Agent "${agentId}" not found`);
@@ -287,6 +327,9 @@ let AgentsService = class AgentsService {
         if (!versionId && agent.versionId !== null && agent.versionId === agent.activeVersionId) {
             return agent;
         }
+        if (versionId !== undefined && versionId === agent.activeVersionId) {
+            return agent;
+        }
         await this.agentRepository.manager.transaction(async (trx) => {
             if (versionId) {
                 const existing = await this.agentHistoryRepository.findByVersionAndAgentId(versionId, agentId, trx);
@@ -295,6 +338,7 @@ let AgentsService = class AgentsService {
                 }
                 agent.activeVersionId = existing.versionId;
                 agent.activeVersion = existing;
+                agent.versionId = (0, uuid_1.v4)();
             }
             else {
                 agent.versionId ??= (0, uuid_1.v4)();
@@ -306,13 +350,14 @@ let AgentsService = class AgentsService {
                     skills: this.agentSkillsService.snapshotConfiguredSkills(agent.schema, agent.skills ?? {}),
                     publishedBy: user,
                 }, trx);
+                await this.snapshotConfiguredTasks(trx, agent.versionId, agent.id, agent.schema);
                 agent.activeVersionId = agent.versionId;
             }
             await trx.save(agent);
         });
         this.clearRuntimes(agentId);
-        const credentialIntegrations = (agent.integrations ?? []).filter(api_types_1.isAgentCredentialIntegration);
-        if (credentialIntegrations.length > 0) {
+        const credentialIntegrations = agent.integrations ?? [];
+        if (credentialIntegrations.length > 0 && options.syncIntegrations !== false) {
             const { ChatIntegrationService } = await Promise.resolve().then(() => __importStar(require('./integrations/chat-integration.service')));
             await di_1.Container.get(ChatIntegrationService)
                 .syncToConfig(agent, [], credentialIntegrations)
@@ -321,6 +366,10 @@ let AgentsService = class AgentsService {
                 error,
             }));
         }
+        const { AgentTaskService } = await Promise.resolve().then(() => __importStar(require('./agent-task.service')));
+        await di_1.Container.get(AgentTaskService)
+            .requestReconcile(agentId)
+            .catch((error) => this.logger.warn('Failed to register agent tasks on publish', { agentId, error }));
         this.logger.debug('Published SDK agent', { agentId, projectId, userId: user.id });
         return agent;
     }
@@ -333,17 +382,15 @@ let AgentsService = class AgentsService {
             agent.activeVersionId = null;
             agent.activeVersion = null;
             agent.versionId = (0, uuid_1.v4)();
-            const hasActiveSchedule = (agent.integrations ?? []).some((integration) => (0, api_types_1.isAgentScheduleIntegration)(integration) && integration.active);
-            if (hasActiveSchedule) {
-                agent.integrations = (agent.integrations ?? []).map((integration) => (0, api_types_1.isAgentScheduleIntegration)(integration) ? { ...integration, active: false } : integration);
-            }
             await trx.save(agent);
         });
         this.clearRuntimes(agentId);
         const { ChatIntegrationService } = await Promise.resolve().then(() => __importStar(require('./integrations/chat-integration.service')));
         await di_1.Container.get(ChatIntegrationService).disconnect(agentId);
-        const { AgentScheduleService } = await Promise.resolve().then(() => __importStar(require('./integrations/agent-schedule.service')));
-        di_1.Container.get(AgentScheduleService).deregister(agentId);
+        const { AgentTaskService } = await Promise.resolve().then(() => __importStar(require('./agent-task.service')));
+        await di_1.Container.get(AgentTaskService)
+            .requestReconcile(agentId)
+            .catch((error) => this.logger.warn('Failed to stop agent tasks on unpublish', { agentId, error }));
         this.logger.debug('Unpublished SDK agent', { agentId, projectId });
         return agent;
     }
@@ -366,24 +413,80 @@ let AgentsService = class AgentsService {
                 agent.description = agent.schema.description ?? null;
             }
             await trx.save(agent);
+            await this.restoreTasksFromSnapshot(trx, agentId, activeVersion.versionId);
         });
         this.clearRuntimes(agentId);
         this.logger.debug('Reverted SDK agent to published version', { agentId, projectId });
         return agent;
     }
+    async revertToVersion(agentId, projectId, versionId) {
+        const agent = await this.agentRepository.findByIdAndProjectId(agentId, projectId);
+        if (!agent) {
+            throw new not_found_error_1.NotFoundError(`Agent "${agentId}" not found`);
+        }
+        await this.agentRepository.manager.transaction(async (trx) => {
+            const target = await this.agentHistoryRepository.findByVersionAndAgentId(versionId, agentId, trx);
+            if (!target) {
+                throw new not_found_error_1.NotFoundError(`Version "${versionId}" not found`);
+            }
+            agent.schema = target.schema ? (0, n8n_workflow_1.deepCopy)(target.schema) : null;
+            agent.tools = (0, n8n_workflow_1.deepCopy)(target.tools ?? {});
+            agent.skills = (0, n8n_workflow_1.deepCopy)(target.skills ?? {});
+            agent.versionId = (0, uuid_1.v4)();
+            if (agent.schema) {
+                agent.name = agent.schema.name;
+                agent.description = agent.schema.description ?? null;
+            }
+            await trx.save(agent);
+        });
+        this.clearRuntimes(agentId);
+        this.logger.debug('Reverted SDK agent to a specific version', {
+            agentId,
+            projectId,
+            versionId,
+        });
+        return agent;
+    }
+    async hasPublishHistory(agentId) {
+        return await this.agentHistoryRepository.existsForAgent(agentId);
+    }
+    async listPublishHistory(agentId, projectId, take, skip) {
+        const agent = await this.agentRepository.findByIdAndProjectId(agentId, projectId);
+        if (!agent) {
+            throw new not_found_error_1.NotFoundError(`Agent "${agentId}" not found`);
+        }
+        const versions = await this.agentHistoryRepository.findByAgentId(agentId, take, skip);
+        return versions.map((v) => ({
+            versionId: v.versionId,
+            agentId: v.agentId,
+            createdAt: v.createdAt.toISOString(),
+            updatedAt: v.updatedAt.toISOString(),
+            author: v.author,
+            isActive: v.versionId === agent.activeVersionId,
+        }));
+    }
     async delete(agentId, projectId) {
         const agent = await this.agentRepository.findByIdAndProjectId(agentId, projectId);
         if (!agent) {
             return false;
         }
+        try {
+            await this.agentKnowledgeService.deleteAllFilesForAgent(agentId);
+        }
+        catch (error) {
+            this.logger.warn('Failed to delete knowledge files on agent delete', {
+                agentId,
+                error: error instanceof Error ? error.message : error,
+            });
+        }
         await this.agentRepository.remove(agent);
         this.clearRuntimes(agentId);
         try {
-            const { AgentScheduleService } = await Promise.resolve().then(() => __importStar(require('./integrations/agent-schedule.service')));
-            di_1.Container.get(AgentScheduleService).deregister(agentId);
+            const { AgentTaskService } = await Promise.resolve().then(() => __importStar(require('./agent-task.service')));
+            await di_1.Container.get(AgentTaskService).requestReconcile(agentId);
         }
         catch (error) {
-            this.logger.warn('Failed to stop schedule on agent delete', {
+            this.logger.warn('Failed to stop tasks on agent delete', {
                 agentId,
                 error: error instanceof Error ? error.message : error,
             });
@@ -478,32 +581,45 @@ let AgentsService = class AgentsService {
         };
     }
     async injectRuntimeDependencies(params) {
-        const { agent, agentId, projectId, credentialProvider, nodeToolsEnabled, integrationType } = params;
-        try {
-            const { createGetEnvironmentTool } = await Promise.resolve().then(() => __importStar(require('./tools/environment-tool')));
-            agent.tool(createGetEnvironmentTool());
-        }
-        catch (toolError) {
-            this.logger.warn('Failed to inject get_environment tool', {
-                agentId,
-                error: toolError instanceof Error ? toolError.message : String(toolError),
-            });
-        }
-        const integration = integrationType
-            ? di_1.Container.get(agent_chat_integration_1.ChatIntegrationRegistry).get(integrationType)
-            : undefined;
-        if (integration?.supportedComponents !== undefined) {
+        const { agent, agentId, projectId, credentialProvider, nodeToolsEnabled, credentialIntegrations, integrationType, } = params;
+        agent.tool((0, environment_tool_1.createGetEnvironmentTool)());
+        if (this.isKnowledgeBaseModuleEnabled()) {
             try {
-                const { createRichInteractionTool } = await Promise.resolve().then(() => __importStar(require('./integrations/rich-interaction-tool')));
-                agent.tool(createRichInteractionTool(integrationType));
+                const { createSearchKnowledgeTool } = await Promise.resolve().then(() => __importStar(require('./tools/knowledge/tool')));
+                agent.tool(createSearchKnowledgeTool({
+                    agentId,
+                    projectId,
+                    knowledgeService: this.agentKnowledgeService,
+                    commandService: this.agentKnowledgeCommandService,
+                }));
             }
             catch (toolError) {
-                this.logger.warn('Failed to inject rich_interaction tool', {
+                this.logger.warn('Failed to inject search_knowledge tool', {
                     agentId,
                     error: toolError instanceof Error ? toolError.message : String(toolError),
                 });
             }
         }
+        const integrationRegistry = di_1.Container.get(agent_chat_integration_1.ChatIntegrationRegistry);
+        const integration = integrationType ? integrationRegistry.get(integrationType) : undefined;
+        if (integration?.supportedComponents !== undefined) {
+            agent.tool((0, rich_interaction_tool_1.createRichInteractionTool)(integrationType));
+        }
+        if (credentialIntegrations.length > 0) {
+            const messageContextStore = di_1.Container.get(integration_message_context_service_1.IntegrationMessageContextService);
+            const actionExecutor = di_1.Container.get(integration_action_executor_1.ChatIntegrationActionExecutor);
+            const queryExecutor = di_1.Container.get(integration_context_query_executor_1.ChatIntegrationContextQueryExecutor);
+            for (const descriptor of (0, integration_tools_1.getIntegrationToolConnectionDescriptors)(credentialIntegrations, agentId, (integrationConfig) => {
+                const integrationDef = integrationRegistry.get(integrationConfig.type);
+                return {
+                    contextQueries: integrationDef?.contextQueries,
+                    actions: integrationDef?.actions,
+                };
+            })) {
+                agent.tool((0, integration_tools_1.createIntegrationContextTool)({ descriptor, messageContextStore, queryExecutor }));
+                agent.tool((0, integration_tools_1.createIntegrationActionTool)({ descriptor, messageContextStore, actionExecutor }));
+            }
+        }
         if (nodeToolsEnabled) {
             this.attachNodeToolChain(agent, credentialProvider, projectId);
         }
@@ -590,9 +706,12 @@ let AgentsService = class AgentsService {
             missing.push('model');
         }
         let credentialList;
-        const credentialExists = async (credentialId) => {
+        const findCredential = async (credentialId) => {
             credentialList ??= await credentialProvider.list();
-            return credentialList.some((credential) => credential.id === credentialId);
+            return credentialList.find((credential) => credential.id === credentialId);
+        };
+        const credentialExists = async (credentialId) => {
+            return (await findCredential(credentialId)) !== undefined;
         };
         if (!config.credential?.trim()) {
             missing.push('credential');
@@ -607,20 +726,67 @@ let AgentsService = class AgentsService {
             }
         }
         const episodicMemory = config.memory?.episodicMemory;
-        if (config.memory?.enabled && episodicMemory?.enabled === true) {
+        if (config.memory?.enabled) {
             try {
-                if (!(await credentialExists(episodicMemory.credential.trim()))) {
-                    missing.push('episodicMemory.credential');
+                await this.validateMemoryWorkerModel(config.memory.observationalMemory?.observerModel, 'memory.observationalMemory.observerModel', findCredential, missing);
+                await this.validateMemoryWorkerModel(config.memory.observationalMemory?.reflectorModel, 'memory.observationalMemory.reflectorModel', findCredential, missing);
+                if (episodicMemory?.enabled === true) {
+                    if (!(await credentialExists(episodicMemory.credential.trim()))) {
+                        missing.push('episodicMemory.credential');
+                    }
+                    await this.validateMemoryWorkerModel(episodicMemory.extractorModel, 'memory.episodicMemory.extractorModel', findCredential, missing);
+                    await this.validateMemoryWorkerModel(episodicMemory.reflectorModel, 'memory.episodicMemory.reflectorModel', findCredential, missing);
                 }
             }
             catch {
             }
         }
+        const webSearch = config.config?.webSearch;
+        if (webSearch?.enabled &&
+            (webSearch.provider === 'brave' || webSearch.provider === 'searxng')) {
+            const webSearchCredentialId = webSearch.credential?.trim();
+            if (!webSearchCredentialId) {
+                missing.push('webSearch.credential');
+            }
+            else {
+                try {
+                    if (!(await credentialExists(webSearchCredentialId))) {
+                        missing.push('webSearch.credential');
+                    }
+                }
+                catch {
+                }
+            }
+        }
         missing.push(...this.agentSkillsService
             .getMissingSkillIds(config, agentEntity.skills ?? {})
             .map((skillId) => `skill:${skillId}`));
         return { missing };
     }
+    async validateMemoryWorkerModel(modelConfig, path, findCredential, missing) {
+        if (modelConfig === undefined || modelConfig === null)
+            return;
+        if (typeof modelConfig === 'string') {
+            missing.push(`${path}.credential`);
+            return;
+        }
+        if (!modelConfig.model?.trim() || !api_types_1.AgentModelSchema.safeParse(modelConfig.model).success) {
+            missing.push(`${path}.model`);
+        }
+        const credentialId = modelConfig.credential?.trim();
+        if (!credentialId) {
+            missing.push(`${path}.credential`);
+            return;
+        }
+        const credential = await findCredential(credentialId);
+        if (!credential ||
+            !this.workerCredentialSupportsModel(credential.type, modelConfig.model ?? '')) {
+            missing.push(`${path}.credential`);
+        }
+    }
+    workerCredentialSupportsModel(credentialType, model) {
+        return llm_provider_defaults_1.LLM_PROVIDER_DEFAULTS[credentialType]?.provider === getProviderPrefix(model);
+    }
     async *executeForChat(config) {
         const { agentId, projectId, message, userId, memory } = config;
         const runtime = await this.getRuntime({ agentId, projectId, n8nUserId: userId });
@@ -669,12 +835,12 @@ let AgentsService = class AgentsService {
             source: integrationType,
         });
     }
-    async *executeForSchedulePublished(config) {
-        const { agentId, projectId, message, memory } = config;
+    async *executeForTaskPublished(config) {
+        const { agentId, projectId, message, memory, taskId, taskVersionId } = config;
         const runtime = await this.getRuntime({
             agentId,
             projectId,
-            integrationType: api_types_1.AGENT_SCHEDULE_TRIGGER_TYPE,
+            integrationType: 'task',
             usePublishedVersion: true,
         });
         yield* this.streamChatResponse({
@@ -684,11 +850,28 @@ let AgentsService = class AgentsService {
             message,
             memory,
             projectId: runtime.projectId,
-            source: api_types_1.AGENT_SCHEDULE_TRIGGER_TYPE,
+            source: 'task',
+            taskId,
+            taskVersionId,
+        });
+    }
+    async *executeForTaskNow(config) {
+        const { agentId, projectId, userId, message, memory, taskId } = config;
+        const runtime = await this.getRuntime({ agentId, projectId, n8nUserId: userId });
+        yield* this.streamChatResponse({
+            agentInstance: runtime.agent,
+            toolRegistry: runtime.toolRegistry,
+            agentId,
+            userId,
+            message,
+            memory,
+            projectId: runtime.projectId,
+            source: 'task',
+            taskId,
         });
     }
     async *streamChatResponse(config) {
-        const { agentInstance, toolRegistry, agentId, userId, message, memory, projectId, source } = config;
+        const { agentInstance, toolRegistry, agentId, userId, message, memory, projectId, source, taskId, taskVersionId, } = config;
         const { threadId, resourceId } = memory;
         const recorder = new execution_recorder_1.ExecutionRecorder(toolRegistry);
         const resultStream = await agentInstance.stream(message, {
@@ -731,6 +914,8 @@ let AgentsService = class AgentsService {
             record: messageRecord,
             hitlStatus: recorder.suspended ? 'suspended' : undefined,
             source,
+            taskId,
+            taskVersionId,
         })
             .catch((error) => {
             this.logger.warn('Failed to record agent execution', {
@@ -873,6 +1058,15 @@ let AgentsService = class AgentsService {
                 error: 'config.nodeTools.enabled requires the node-tools-searcher agents module to be enabled.',
             };
         }
+        const mcpServers = config.mcpServers ?? [];
+        for (const server of mcpServers) {
+            if (server.authentication !== 'none' && !server.credential) {
+                return {
+                    valid: false,
+                    error: `MCP server "${server.name}" requires a credential when authentication is not "none".`,
+                };
+            }
+        }
         try {
             this.validateNodeToolExpressions(config);
         }
@@ -905,6 +1099,18 @@ let AgentsService = class AgentsService {
             throw new n8n_workflow_1.UserError(`Invalid agent config: ${result.error}`);
         }
         this.validateConfigRefs(result.config, entity);
+        const tasksProvided = result.config.tasks !== undefined;
+        const existingTaskIds = tasksProvided
+            ? (await this.agentTaskRepository.findByAgentId(agentId)).map((task) => task.id)
+            : [];
+        if (tasksProvided) {
+            const existingTaskIdSet = new Set(existingTaskIds);
+            for (const ref of result.config.tasks ?? []) {
+                if (!existingTaskIdSet.has(ref.id)) {
+                    throw new n8n_workflow_1.UserError(`Invalid agent config: Missing task body: ${ref.id}`);
+                }
+            }
+        }
         const previousIntegrations = entity.integrations ?? [];
         const previousSchema = entity.schema ?? null;
         const integrationsProvided = result.config.integrations !== undefined;
@@ -915,6 +1121,7 @@ let AgentsService = class AgentsService {
         const memoryProvided = result.config.memory !== undefined;
         const providerToolsProvided = result.config.providerTools !== undefined;
         const configBlockProvided = result.config.config !== undefined;
+        const mcpServersProvided = result.config.mcpServers !== undefined;
         const { schemaConfig: decomposedSchema, integrations: decomposedIntegrations } = (0, agent_config_composition_1.decomposeJsonConfig)(result.config);
         const nextIntegrations = integrationsProvided ? decomposedIntegrations : previousIntegrations;
         const nextSchema = {
@@ -927,8 +1134,10 @@ let AgentsService = class AgentsService {
             ...(memoryProvided ? { memory: decomposedSchema.memory } : {}),
             ...(toolsProvided ? { tools: decomposedSchema.tools } : {}),
             ...(skillsProvided ? { skills: decomposedSchema.skills } : {}),
+            ...(tasksProvided ? { tasks: decomposedSchema.tasks } : {}),
             ...(providerToolsProvided ? { providerTools: decomposedSchema.providerTools } : {}),
             ...(configBlockProvided ? { config: decomposedSchema.config } : {}),
+            ...(mcpServersProvided ? { mcpServers: decomposedSchema.mcpServers } : {}),
         };
         entity.schema = nextSchema;
         entity.name = result.config.name;
@@ -955,6 +1164,13 @@ let AgentsService = class AgentsService {
         this.clearRuntimes(agentId);
         const saved = await this.agentRepository.save(entity);
         this.logger.debug('Updated agent JSON config', { agentId, projectId });
+        if (tasksProvided) {
+            const referencedTaskIds = new Set((result.config.tasks ?? []).map((ref) => ref.id));
+            const orphanTaskIds = existingTaskIds.filter((id) => !referencedTaskIds.has(id));
+            if (orphanTaskIds.length > 0) {
+                await this.agentTaskRepository.delete(orphanTaskIds);
+            }
+        }
         if (integrationsProvided) {
             await (0, integrations_sync_1.syncAgentIntegrations)(saved, previousIntegrations, nextIntegrations, this.logger);
         }
@@ -964,43 +1180,41 @@ let AgentsService = class AgentsService {
             versionId: saved.versionId,
         };
     }
-    async saveCredentialIntegration(agent, integration) {
-        const parseResult = api_types_1.AgentCredentialIntegrationSchema.safeParse(integration);
+    async saveCredentialIntegration(agent, integration, options = {}) {
+        const parseResult = api_types_1.AgentIntegrationSchema.safeParse(integration);
         if (!parseResult.success) {
             throw new n8n_workflow_1.UserError(`Invalid credential integration: ${parseResult.error.message}`);
         }
         const validated = parseResult.data;
         const { type, credentialId } = validated;
         const existing = agent.integrations ?? [];
-        const alreadyExists = existing.some((i) => (0, api_types_1.isAgentCredentialIntegration)(i) && i.type === type && i.credentialId === credentialId);
+        const alreadyExists = existing.some((i) => i.type === type && i.credentialId === credentialId);
         agent.integrations = alreadyExists
-            ? existing.map((existingIntegration) => (0, api_types_1.isAgentCredentialIntegration)(existingIntegration) &&
-                existingIntegration.type === type &&
-                existingIntegration.credentialId === credentialId
+            ? existing.map((existingIntegration) => existingIntegration.type === type && existingIntegration.credentialId === credentialId
                 ? validated
                 : existingIntegration)
             : [...existing, validated];
+        (0, agent_draft_utils_1.markAgentDraftDirty)(agent);
+        this.clearRuntimes(agent.id);
         const result = await this.agentRepository.save(agent);
-        await this.chatIntegrationService.broadcastIntegrationChange(agent.id, integration, 'connect');
+        if (options.broadcast !== false) {
+            await this.chatIntegrationService.broadcastIntegrationChange(agent.id, integration, 'connect');
+        }
         return result;
     }
     async removeCredentialIntegration(agent, type, credentialId) {
         if (!agent.integrations?.length)
             return agent;
-        const integration = agent.integrations.find((i) => (0, api_types_1.isAgentCredentialIntegration)(i) && i.type === type && i.credentialId === credentialId);
+        const integration = agent.integrations.find((i) => i.type === type && i.credentialId === credentialId);
         if (!integration)
             return agent;
         agent.integrations = agent.integrations.filter((i) => i !== integration);
+        (0, agent_draft_utils_1.markAgentDraftDirty)(agent);
+        this.clearRuntimes(agent.id);
         const result = await this.agentRepository.save(agent);
         await this.chatIntegrationService.broadcastIntegrationChange(agent.id, integration, 'disconnect');
         return result;
     }
-    validateIntegrationRefs(integrations, agent) {
-        const activeUnpublishedSchedule = integrations.some((integration) => (0, api_types_1.isAgentScheduleIntegration)(integration) && integration.active);
-        if (activeUnpublishedSchedule && !agent.activeVersionId) {
-            throw new n8n_workflow_1.UserError('Invalid agent config: schedule integration cannot be active until the agent is published');
-        }
-    }
     async buildCustomTool(agentId, projectId, code, descriptor) {
         const entity = await this.agentRepository.findByIdAndProjectId(agentId, projectId);
         if (!entity)
@@ -1089,7 +1303,6 @@ let AgentsService = class AgentsService {
         if (missingToolIds.length > 0) {
             throw new n8n_workflow_1.UserError(`Invalid agent config: Missing custom tool definitions: ${missingToolIds.join(', ')}`);
         }
-        this.validateIntegrationRefs(config.integrations ?? [], entity);
     }
     getMissingCustomToolIds(config, tools) {
         const refs = (config?.tools ?? []).filter((ref) => ref.type === 'custom');
@@ -1121,6 +1334,61 @@ let AgentsService = class AgentsService {
         }
         return snapshot;
     }
+    async snapshotConfiguredTasks(trx, versionId, agentId, config) {
+        if (!config)
+            return;
+        const refs = config.tasks ?? [];
+        if (refs.length === 0)
+            return;
+        const bodies = await trx.getRepository(agent_task_entity_1.AgentTask).findBy({ agentId });
+        const byId = new Map(bodies.map((body) => [body.id, body]));
+        const missing = refs.filter((ref) => !byId.has(ref.id)).map((ref) => ref.id);
+        if (missing.length > 0) {
+            throw new n8n_workflow_1.UserError(`Cannot publish agent with missing task bodies: ${missing.join(', ')}`);
+        }
+        await this.agentTaskSnapshotRepository.saveForVersion(refs.map((ref) => {
+            const body = byId.get(ref.id);
+            if (!body) {
+                throw new n8n_workflow_1.UserError(`Cannot publish agent with missing task body: ${ref.id}`);
+            }
+            return {
+                versionId,
+                taskId: ref.id,
+                enabled: ref.enabled,
+                name: body.name,
+                objective: body.objective,
+                cronExpression: body.cronExpression,
+            };
+        }), trx);
+    }
+    async restoreTasksFromSnapshot(trx, agentId, versionId) {
+        const repo = trx.getRepository(agent_task_entity_1.AgentTask);
+        const existing = await repo.findBy({ agentId });
+        const snapshots = await this.agentTaskSnapshotRepository.findByVersionId(versionId, trx);
+        const snapshotIds = new Set(snapshots.map((snapshot) => snapshot.taskId));
+        const orphanIds = existing.filter((row) => !snapshotIds.has(row.id)).map((row) => row.id);
+        if (orphanIds.length > 0)
+            await repo.delete(orphanIds);
+        const existingIds = new Set(existing.map((row) => row.id));
+        for (const snapshot of snapshots) {
+            if (existingIds.has(snapshot.taskId)) {
+                await repo.update(snapshot.taskId, {
+                    name: snapshot.name,
+                    objective: snapshot.objective,
+                    cronExpression: snapshot.cronExpression,
+                });
+            }
+            else {
+                await repo.insert({
+                    id: snapshot.taskId,
+                    agentId,
+                    name: snapshot.name,
+                    objective: snapshot.objective,
+                    cronExpression: snapshot.cronExpression,
+                });
+            }
+        }
+    }
     async reconstructFromConfig(agentEntity, credentialProvider, userId, integrationType) {
         const config = agentEntity.schema;
         if (!config) {
@@ -1137,6 +1405,11 @@ let AgentsService = class AgentsService {
         const toolExecutor = this.secureRuntime.createToolExecutor(toolsByName);
         const toolResolver = this.makeToolResolver(agentEntity.projectId, userId);
         const resolvedTools = [];
+        const buildMcpClient = async (server) => await (0, mcp_client_factory_1.buildMcpClientForServer)(server, {
+            credentialProvider,
+            oauthService: this.oauthService,
+            projectId: agentEntity.projectId,
+        });
         const reconstructed = await (0, from_json_config_1.buildFromJson)(config, toolDescriptors, {
             toolExecutor,
             credentialProvider,
@@ -1148,6 +1421,7 @@ let AgentsService = class AgentsService {
             },
             skills: agentEntity.skills ?? {},
             memoryFactory: this.getMemoryFactory(agentEntity.id),
+            buildMcpClient,
         });
         await this.injectRuntimeDependencies({
             agent: reconstructed,
@@ -1155,6 +1429,7 @@ let AgentsService = class AgentsService {
             projectId: agentEntity.projectId,
             credentialProvider,
             nodeToolsEnabled: this.shouldAttachNodeTools(config.config),
+            credentialIntegrations: agentEntity.integrations ?? [],
             integrationType,
         });
         const toolRegistry = (0, tool_registry_1.buildToolRegistry)(resolvedTools);
@@ -1188,10 +1463,19 @@ exports.AgentsService = AgentsService = __decorate([
         agent_execution_service_1.AgentExecutionService,
         agent_history_repository_1.AgentHistoryRepository,
         agent_skills_service_1.AgentSkillsService,
+        agent_task_repository_1.AgentTaskRepository,
+        agent_task_snapshot_repository_1.AgentTaskSnapshotRepository,
         publisher_service_1.Publisher,
         config_1.AgentsConfig,
         config_1.GlobalConfig,
         telemetry_1.Telemetry,
-        chat_integration_service_1.ChatIntegrationService])
+        chat_integration_service_1.ChatIntegrationService,
+        agent_knowledge_service_1.AgentKnowledgeService,
+        agent_knowledge_command_service_1.AgentKnowledgeCommandService,
+        oauth_service_1.OauthService])
 ], AgentsService);
+function getProviderPrefix(modelId) {
+    const slashIdx = modelId.indexOf('/');
+    return slashIdx === -1 ? '' : modelId.slice(0, slashIdx);
+}
 //# sourceMappingURL=agents.service.js.map