n8n 2.25.6 → 2.26.0

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

@@ -54,52 +54,39 @@ const decorators_1 = require("@n8n/decorators");
 const di_1 = require("@n8n/di");
 const n8n_workflow_1 = require("n8n-workflow");
 const uuid_1 = require("uuid");
-const active_executions_1 = require("../../active-executions");
 const credentials_service_1 = require("../../credentials/credentials.service");
 const 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");
 const ttl_map_1 = require("../../utils/ttl-map");
-const workflow_runner_1 = require("../../workflow-runner");
-const workflow_finder_service_1 = require("../../workflows/workflow-finder.service");
 const agents_credential_provider_1 = require("./adapters/agents-credential-provider");
 const agent_draft_utils_1 = require("./utils/agent-draft.utils");
 const agent_memory_scope_1 = require("./utils/agent-memory-scope");
 const execution_to_message_mapper_1 = require("./utils/execution-to-message-mapper");
 const agent_resource_id_1 = require("./utils/agent-resource-id");
+const agent_stream_1 = require("./utils/agent-stream");
+const structured_output_error_1 = require("./utils/structured-output-error");
 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 model_id_1 = require("./json-config/model-id");
+const sanitize_unknown_agent_credentials_1 = require("./json-config/sanitize-unknown-agent-credentials");
+const agent_runtime_reconstruction_service_1 = require("./agent-runtime-reconstruction.service");
 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}`;
@@ -157,21 +144,11 @@ 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, agentTaskRepository, agentTaskSnapshotRepository, publisher, agentsConfig, globalConfig, telemetry, chatIntegrationService, agentKnowledgeService, agentKnowledgeCommandService, oauthService) {
+    constructor(logger, agentRepository, projectRelationRepository, n8nCheckpointStorage, n8nMemory, agentExecutionService, agentHistoryRepository, agentSkillsService, agentTaskRepository, agentTaskSnapshotRepository, publisher, agentsConfig, globalConfig, telemetry, chatIntegrationService, agentKnowledgeService, agentRuntimeReconstructionService) {
         this.logger = logger;
         this.agentRepository = agentRepository;
         this.projectRelationRepository = projectRelationRepository;
-        this.workflowRunner = workflowRunner;
-        this.activeExecutions = activeExecutions;
-        this.executionRepository = executionRepository;
-        this.workflowRepository = workflowRepository;
-        this.userRepository = userRepository;
-        this.workflowFinderService = workflowFinderService;
-        this.urlService = urlService;
         this.n8nCheckpointStorage = n8nCheckpointStorage;
-        this.secureRuntime = secureRuntime;
-        this.ephemeralNodeExecutor = ephemeralNodeExecutor;
-        this.agentsToolsService = agentsToolsService;
         this.n8nMemory = n8nMemory;
         this.agentExecutionService = agentExecutionService;
         this.agentHistoryRepository = agentHistoryRepository;
@@ -184,8 +161,7 @@ let AgentsService = class AgentsService {
         this.telemetry = telemetry;
         this.chatIntegrationService = chatIntegrationService;
         this.agentKnowledgeService = agentKnowledgeService;
-        this.agentKnowledgeCommandService = agentKnowledgeCommandService;
-        this.oauthService = oauthService;
+        this.agentRuntimeReconstructionService = agentRuntimeReconstructionService;
         this.runtimes = new ttl_map_1.TtlMap(30 * constants_1.Time.minutes.toMilliseconds);
     }
     isNodeToolsModuleEnabled() {
@@ -222,9 +198,6 @@ let AgentsService = class AgentsService {
             }),
         };
     }
-    shouldAttachNodeTools(config) {
-        return this.isNodeToolsModuleEnabled() && (0, api_types_1.isNodeToolsEnabled)(config);
-    }
     listChatIntegrations() {
         return di_1.Container.get(agent_chat_integration_1.ChatIntegrationRegistry)
             .list()
@@ -510,9 +483,6 @@ let AgentsService = class AgentsService {
             return null;
         return (0, execution_to_message_mapper_1.executionsToMessagesDto)(detail.executions);
     }
-    getMemoryFactory(agentId) {
-        return (_params) => this.n8nMemory.getImplementation(agentId);
-    }
     createCredentialProvider(projectId) {
         return new agents_credential_provider_1.AgentsCredentialProvider(di_1.Container.get(credentials_service_1.CredentialsService), projectId);
     }
@@ -528,16 +498,7 @@ let AgentsService = class AgentsService {
         let n8nUserId = params.n8nUserId;
         let agentData = agentEntity;
         if (usePublishedVersion) {
-            const activeVersionSchema = agentEntity.activeVersion?.schema;
-            if (!activeVersionSchema) {
-                throw new not_found_error_1.NotFoundError(`Agent ${agentId} is not published`);
-            }
-            agentData = {
-                ...agentEntity,
-                schema: activeVersionSchema,
-                tools: agentEntity.activeVersion?.tools ?? agentEntity.tools ?? {},
-                skills: agentEntity.activeVersion?.skills ?? agentEntity.skills ?? {},
-            };
+            agentData = this.getPublishedAgent(agentEntity);
             n8nUserId ??= agentEntity.activeVersion?.publishedById ?? undefined;
         }
         if (!n8nUserId) {
@@ -551,87 +512,8 @@ let AgentsService = class AgentsService {
             throw new Error(`Agent ${agentId} failed to reconstruct`);
         return runtime;
     }
-    makeToolResolver(projectId, userId) {
-        return async (ref) => {
-            if (ref.type === 'workflow') {
-                if (!userId) {
-                    throw new n8n_workflow_1.UserError('userId is required when agent uses workflow tools');
-                }
-                const { resolveWorkflowTool } = await Promise.resolve().then(() => __importStar(require('./tools/workflow-tool-factory')));
-                return await resolveWorkflowTool(ref, {
-                    workflowRepository: this.workflowRepository,
-                    workflowRunner: this.workflowRunner,
-                    activeExecutions: this.activeExecutions,
-                    executionRepository: this.executionRepository,
-                    workflowFinderService: this.workflowFinderService,
-                    userRepository: this.userRepository,
-                    userId,
-                    projectId,
-                    webhookBaseUrl: this.urlService.getWebhookBaseUrl(),
-                });
-            }
-            if (ref.type === 'node') {
-                const { resolveNodeTool } = await Promise.resolve().then(() => __importStar(require('./tools/node-tool-factory')));
-                return await resolveNodeTool(ref, {
-                    executor: this.ephemeralNodeExecutor,
-                    projectId,
-                });
-            }
-            return null;
-        };
-    }
-    async injectRuntimeDependencies(params) {
-        const { agent, agentId, projectId, credentialProvider, nodeToolsEnabled, credentialIntegrations, integrationType, } = params;
-        agent.tool((0, environment_tool_1.createGetEnvironmentTool)());
-        if (this.isKnowledgeBaseModuleEnabled()) {
-            try {
-                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 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);
-        }
-        if (!agent.hasCheckpointStorage()) {
-            agent.checkpoint(this.n8nCheckpointStorage);
-        }
-    }
-    attachNodeToolChain(agent, credentialProvider, projectId) {
-        agent.tool(this.agentsToolsService.getRuntimeTools(credentialProvider, projectId));
-    }
     async *resumeForChat(config) {
-        const { agentId, projectId, runId, toolCallId, resumeData, integrationType } = config;
+        const { agentId, projectId, runId, toolCallId, resumeData, integrationType, userId, usePublishedVersion = true, } = config;
         const checkpointStatus = await this.n8nCheckpointStorage.getStatus(runId);
         if (checkpointStatus.status === 'expired') {
             throw new n8n_workflow_1.UserError(`Checkpoint ${runId} is expired and cannot be resumed`);
@@ -647,7 +529,8 @@ let AgentsService = class AgentsService {
         const runtime = await this.getRuntime({
             agentId,
             projectId,
-            usePublishedVersion: true,
+            ...(userId ? { n8nUserId: userId } : {}),
+            usePublishedVersion,
             integrationType,
         });
         const { agent: agentInstance, toolRegistry } = runtime;
@@ -655,20 +538,11 @@ let AgentsService = class AgentsService {
         const resultStream = await agentInstance.resume('stream', resumeData, {
             runId,
             toolCallId,
-            executionCounter: this.createAgentExecutionCounter({ agentId }),
+            executionCounter: this.createAgentExecutionCounter({ agentId, userId }),
         });
-        const reader = resultStream.stream.getReader();
-        try {
-            while (true) {
-                const { done, value } = await reader.read();
-                if (done)
-                    break;
-                recorder.record(value);
-                yield value;
-            }
-        }
-        finally {
-            reader.releaseLock();
+        for await (const value of (0, agent_stream_1.streamAgentChunks)(resultStream.stream)) {
+            recorder.record(value);
+            yield value;
         }
         const messageRecord = recorder.getMessageRecord();
         void this.agentExecutionService
@@ -758,6 +632,16 @@ let AgentsService = class AgentsService {
                 }
             }
         }
+        try {
+            const modelsByDifficulty = config.subAgents?.modelsByDifficulty;
+            if (modelsByDifficulty) {
+                for (const difficulty of api_types_1.SUB_AGENT_TASK_DIFFICULTIES) {
+                    await this.validateMemoryWorkerModel(modelsByDifficulty[difficulty], `subAgents.modelsByDifficulty.${difficulty}`, findCredential, missing);
+                }
+            }
+        }
+        catch {
+        }
         missing.push(...this.agentSkillsService
             .getMissingSkillIds(config, agentEntity.skills ?? {})
             .map((skillId) => `skill:${skillId}`));
@@ -785,7 +669,7 @@ let AgentsService = class AgentsService {
         }
     }
     workerCredentialSupportsModel(credentialType, model) {
-        return llm_provider_defaults_1.LLM_PROVIDER_DEFAULTS[credentialType]?.provider === getProviderPrefix(model);
+        return llm_provider_defaults_1.LLM_PROVIDER_DEFAULTS[credentialType]?.provider === (0, model_id_1.getProviderPrefix)(model);
     }
     async *executeForChat(config) {
         const { agentId, projectId, message, userId, memory } = config;
@@ -878,30 +762,21 @@ let AgentsService = class AgentsService {
             persistence: { threadId, resourceId },
             executionCounter: this.createAgentExecutionCounter({ agentId, userId }),
         });
-        const reader = resultStream.stream.getReader();
-        try {
-            while (true) {
-                const { done, value } = await reader.read();
-                if (done)
-                    break;
-                recorder.record(value);
-                if (value.type === 'tool-call-suspended') {
-                    this.logger.info('Chat: tool-call-suspended chunk received', {
-                        agentId,
-                        toolCallId: value.toolCallId,
-                        toolName: value.toolName,
-                    });
-                }
-                if (value.type === 'finish' && value.finishReason === 'max-iterations') {
-                    for (const chunk of getMaxIterationsChunks()) {
-                        yield chunk;
-                    }
+        for await (const value of (0, agent_stream_1.streamAgentChunks)(resultStream.stream)) {
+            recorder.record(value);
+            if (value.type === 'tool-call-suspended') {
+                this.logger.info('Chat: tool-call-suspended chunk received', {
+                    agentId,
+                    toolCallId: value.toolCallId,
+                    toolName: value.toolName,
+                });
+            }
+            if (value.type === 'finish' && value.finishReason === 'max-iterations') {
+                for (const chunk of getMaxIterationsChunks()) {
+                    yield chunk;
                 }
-                yield value;
             }
-        }
-        finally {
-            reader.releaseLock();
+            yield value;
         }
         const messageRecord = recorder.getMessageRecord();
         void this.agentExecutionService
@@ -925,12 +800,15 @@ let AgentsService = class AgentsService {
             });
         });
     }
-    async compileIsolated(agentEntity, credentialProvider, userId) {
+    async compileIsolated(agentEntity, credentialProvider, userId, outputSchema) {
         if (!agentEntity.schema) {
             return { ok: false, error: 'Agent has no JSON config. Create a config first.' };
         }
         try {
             const { agent: reconstructed } = await this.reconstructFromConfig(agentEntity, credentialProvider, userId);
+            if (outputSchema) {
+                reconstructed.structuredOutput(outputSchema);
+            }
             return { ok: true, agent: reconstructed };
         }
         catch (e) {
@@ -940,16 +818,29 @@ let AgentsService = class AgentsService {
             };
         }
     }
-    async executeForWorkflow(agentId, message, executionId, threadId, userId, projectId, telemetryUserId) {
+    getPublishedAgent(agentEntity) {
+        const activeVersionSchema = agentEntity.activeVersion?.schema;
+        if (!activeVersionSchema) {
+            throw new n8n_workflow_1.OperationalError('Agent is not published. Publish the agent before using it in a workflow.');
+        }
+        return {
+            ...agentEntity,
+            schema: activeVersionSchema,
+            tools: agentEntity.activeVersion?.tools ?? agentEntity.tools ?? {},
+            skills: agentEntity.activeVersion?.skills ?? agentEntity.skills ?? {},
+        };
+    }
+    async executeForWorkflow(agentId, message, executionId, threadId, userId, projectId, telemetryUserId, useDraftVersion, outputSchema) {
         const agentEntity = await this.agentRepository.findByIdAndProjectId(agentId, projectId);
         if (!agentEntity) {
             throw new n8n_workflow_1.OperationalError('Agent not found or not accessible.');
         }
-        if (!agentEntity.activeVersionId) {
-            throw new n8n_workflow_1.OperationalError('Agent is not published. Publish the agent before using it in a workflow.');
-        }
         const credentialProvider = new agents_credential_provider_1.AgentsCredentialProvider(di_1.Container.get(credentials_service_1.CredentialsService), projectId);
-        const compiled = await this.compileIsolated(agentEntity, credentialProvider, userId);
+        let agentData = agentEntity;
+        if (!useDraftVersion) {
+            agentData = this.getPublishedAgent(agentEntity);
+        }
+        const compiled = await this.compileIsolated(agentData, credentialProvider, userId, outputSchema);
         if (!compiled.ok || !compiled.agent) {
             throw new n8n_workflow_1.OperationalError(`Failed to compile agent: ${compiled.error ?? 'unknown error'}`);
         }
@@ -962,32 +853,23 @@ let AgentsService = class AgentsService {
             persistence: { resourceId: executionId, threadId },
             executionCounter: this.createAgentExecutionCounter({ agentId, userId: telemetryUserId }),
         });
-        const reader = resultStream.stream.getReader();
-        try {
-            while (true) {
-                const { done, value } = await reader.read();
-                if (done)
-                    break;
-                recorder.record(value);
-                if (value.type === 'tool-call') {
-                    toolInputs.set(value.toolCallId, { toolName: value.toolName, input: value.input });
-                }
-                else if (value.type === 'tool-result') {
-                    const pending = toolInputs.get(value.toolCallId);
-                    toolCalls.push({
-                        toolName: value.toolName,
-                        input: pending?.input ?? null,
-                        result: value.output,
-                    });
-                    toolInputs.delete(value.toolCallId);
-                }
-                else if (value.type === 'finish' && value.structuredOutput !== undefined) {
-                    structuredOutput = value.structuredOutput;
-                }
+        for await (const value of (0, agent_stream_1.streamAgentChunks)(resultStream.stream)) {
+            recorder.record(value);
+            if (value.type === 'tool-call') {
+                toolInputs.set(value.toolCallId, { toolName: value.toolName, input: value.input });
+            }
+            else if (value.type === 'tool-result') {
+                const pending = toolInputs.get(value.toolCallId);
+                toolCalls.push({
+                    toolName: value.toolName,
+                    input: pending?.input ?? null,
+                    result: value.output,
+                });
+                toolInputs.delete(value.toolCallId);
+            }
+            else if (value.type === 'finish' && value.structuredOutput !== undefined) {
+                structuredOutput = value.structuredOutput;
             }
-        }
-        finally {
-            reader.releaseLock();
         }
         const messageRecord = recorder.getMessageRecord();
         void this.agentExecutionService
@@ -1012,10 +894,19 @@ let AgentsService = class AgentsService {
                 'Suspend/resume is not supported in workflow execution context.');
         }
         if (messageRecord.error) {
+            if (outputSchema) {
+                const structuredOutputError = (0, structured_output_error_1.describeStructuredOutputError)(messageRecord.error);
+                if (structuredOutputError) {
+                    throw new n8n_workflow_1.OperationalError(structuredOutputError);
+                }
+            }
             throw new n8n_workflow_1.OperationalError(`Agent execution failed: ${messageRecord.error}`);
         }
         if (messageRecord.finishReason === 'error') {
-            throw new n8n_workflow_1.OperationalError('Agent execution finished with an error.');
+            throw new n8n_workflow_1.OperationalError(outputSchema
+                ? 'Agent execution finished with an error while producing structured output. ' +
+                    "The agent's model or provider may not support JSON Schema structured output."
+                : 'Agent execution finished with an error.');
         }
         return {
             response: messageRecord.assistantResponse,
@@ -1047,7 +938,10 @@ let AgentsService = class AgentsService {
         return config;
     }
     async validateConfig(raw) {
-        const parsed = api_types_1.AgentJsonConfigSchema.safeParse(raw);
+        if (hasNodeToolInputSchema(raw)) {
+            return { valid: false, error: 'Node tool configs must not include inputSchema.' };
+        }
+        const parsed = api_types_1.AgentJsonConfigSchema.safeParse((0, api_types_1.sanitizeAgentJsonConfig)(raw));
         if (!parsed.success) {
             return { valid: false, error: parsed.error.message };
         }
@@ -1058,15 +952,6 @@ 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);
         }
@@ -1094,23 +979,19 @@ let AgentsService = class AgentsService {
         const entity = await this.agentRepository.findByIdAndProjectId(agentId, projectId);
         if (!entity)
             throw new not_found_error_1.NotFoundError('Agent not found');
-        const result = await this.validateConfig(config);
+        const credentialProvider = this.createCredentialProvider(projectId);
+        const accessibleCredentialIds = new Set((await credentialProvider.list()).map((credential) => credential.id));
+        const sanitizedConfig = (0, sanitize_unknown_agent_credentials_1.sanitizeUnknownAgentCredentials)((0, api_types_1.sanitizeAgentJsonConfig)(config), accessibleCredentialIds);
+        const result = await this.validateConfig(sanitizedConfig);
         if (!result.valid) {
             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 resolvedSubAgents = await this.removeMissingConfigRefs(result.config, entity, new Set(existingTaskIds));
+        this.validateSubAgentRefs(resolvedSubAgents, entity);
         const previousIntegrations = entity.integrations ?? [];
         const previousSchema = entity.schema ?? null;
         const integrationsProvided = result.config.integrations !== undefined;
@@ -1119,6 +1000,7 @@ let AgentsService = class AgentsService {
         const descriptionProvided = result.config.description !== undefined;
         const credentialProvided = result.config.credential !== undefined;
         const memoryProvided = result.config.memory !== undefined;
+        const subAgentsProvided = result.config.subAgents !== undefined;
         const providerToolsProvided = result.config.providerTools !== undefined;
         const configBlockProvided = result.config.config !== undefined;
         const mcpServersProvided = result.config.mcpServers !== undefined;
@@ -1132,6 +1014,7 @@ let AgentsService = class AgentsService {
             ...(descriptionProvided ? { description: decomposedSchema.description } : {}),
             ...(credentialProvided ? { credential: decomposedSchema.credential } : {}),
             ...(memoryProvided ? { memory: decomposedSchema.memory } : {}),
+            ...(subAgentsProvided ? { subAgents: decomposedSchema.subAgents } : {}),
             ...(toolsProvided ? { tools: decomposedSchema.tools } : {}),
             ...(skillsProvided ? { skills: decomposedSchema.skills } : {}),
             ...(tasksProvided ? { tasks: decomposedSchema.tasks } : {}),
@@ -1187,6 +1070,9 @@ let AgentsService = class AgentsService {
         }
         const validated = parseResult.data;
         const { type, credentialId } = validated;
+        if (credentialId === '') {
+            throw new n8n_workflow_1.UserError('Credential integration requires a credential ID.');
+        }
         const existing = agent.integrations ?? [];
         const alreadyExists = existing.some((i) => i.type === type && i.credentialId === credentialId);
         agent.integrations = alreadyExists
@@ -1294,14 +1180,50 @@ let AgentsService = class AgentsService {
         }
         return errors.length > 0 ? errors.join('\n') : null;
     }
-    validateConfigRefs(config, entity) {
-        const missingSkillIds = this.agentSkillsService.getMissingSkillIds(config, entity.skills ?? {});
-        if (missingSkillIds.length > 0) {
-            throw new n8n_workflow_1.UserError(`Invalid agent config: Missing skill bodies: ${missingSkillIds.join(', ')}`);
+    async removeMissingConfigRefs(config, entity, existingTaskIds) {
+        if (config.skills !== undefined) {
+            const skills = entity.skills ?? {};
+            config.skills = config.skills.filter((ref) => Boolean(skills[ref.id]));
+        }
+        if (config.tools !== undefined) {
+            const tools = entity.tools ?? {};
+            config.tools = config.tools.filter((ref) => ref.type !== 'custom' || Boolean(tools[ref.id]));
         }
-        const missingToolIds = this.getMissingCustomToolIds(config, entity.tools ?? {});
-        if (missingToolIds.length > 0) {
-            throw new n8n_workflow_1.UserError(`Invalid agent config: Missing custom tool definitions: ${missingToolIds.join(', ')}`);
+        if (config.tasks !== undefined) {
+            config.tasks = config.tasks.filter((ref) => existingTaskIds.has(ref.id));
+        }
+        if (config.subAgents?.agents !== undefined) {
+            const resolvedSubAgents = await this.fetchUniqueSubAgents(config.subAgents.agents, entity.projectId);
+            const existingSubAgentIds = new Set(resolvedSubAgents.filter(({ agent }) => agent !== null).map(({ agentId }) => agentId));
+            config.subAgents.agents = config.subAgents.agents.filter(({ agentId }) => existingSubAgentIds.has(agentId));
+            return resolvedSubAgents;
+        }
+        return [];
+    }
+    async fetchUniqueSubAgents(refs, projectId) {
+        const seen = new Set();
+        const resolved = [];
+        for (const { agentId } of refs) {
+            if (seen.has(agentId))
+                continue;
+            seen.add(agentId);
+            resolved.push({
+                agentId,
+                agent: await this.agentRepository.findByIdAndProjectId(agentId, projectId),
+            });
+        }
+        return resolved;
+    }
+    validateSubAgentRefs(resolvedSubAgents, entity) {
+        for (const { agentId, agent } of resolvedSubAgents) {
+            if (!agent)
+                continue;
+            if (agentId === entity.id) {
+                throw new n8n_workflow_1.UserError('Invalid agent config: An agent cannot use itself as a subagent');
+            }
+            if (!agent.activeVersionId) {
+                throw new n8n_workflow_1.UserError(`Invalid agent config: Subagent "${agentId}" must be published`);
+            }
         }
     }
     getMissingCustomToolIds(config, tools) {
@@ -1390,50 +1312,7 @@ let AgentsService = class AgentsService {
         }
     }
     async reconstructFromConfig(agentEntity, credentialProvider, userId, integrationType) {
-        const config = agentEntity.schema;
-        if (!config) {
-            throw new n8n_workflow_1.UserError('Agent has no JSON config.');
-        }
-        const toolsByName = {};
-        for (const [_toolId, toolEntry] of Object.entries(agentEntity.tools ?? {})) {
-            toolsByName[toolEntry.descriptor.name] = toolEntry.code;
-        }
-        const toolDescriptors = {};
-        for (const [toolId, toolEntry] of Object.entries(agentEntity.tools ?? {})) {
-            toolDescriptors[toolId] = toolEntry.descriptor;
-        }
-        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,
-            resolveTool: async (ref) => {
-                const resolved = await toolResolver(ref);
-                if (resolved)
-                    resolvedTools.push(resolved);
-                return resolved;
-            },
-            skills: agentEntity.skills ?? {},
-            memoryFactory: this.getMemoryFactory(agentEntity.id),
-            buildMcpClient,
-        });
-        await this.injectRuntimeDependencies({
-            agent: reconstructed,
-            agentId: agentEntity.id,
-            projectId: agentEntity.projectId,
-            credentialProvider,
-            nodeToolsEnabled: this.shouldAttachNodeTools(config.config),
-            credentialIntegrations: agentEntity.integrations ?? [],
-            integrationType,
-        });
-        const toolRegistry = (0, tool_registry_1.buildToolRegistry)(resolvedTools);
-        return { agent: reconstructed, toolRegistry };
+        return await this.agentRuntimeReconstructionService.reconstructFromAgentEntity(agentEntity, credentialProvider, userId, integrationType);
     }
 };
 exports.AgentsService = AgentsService;
@@ -1448,17 +1327,7 @@ exports.AgentsService = AgentsService = __decorate([
     __metadata("design:paramtypes", [backend_common_1.Logger,
         agent_repository_1.AgentRepository,
         db_1.ProjectRelationRepository,
-        workflow_runner_1.WorkflowRunner,
-        active_executions_1.ActiveExecutions,
-        db_1.ExecutionRepository,
-        db_1.WorkflowRepository,
-        db_1.UserRepository,
-        workflow_finder_service_1.WorkflowFinderService,
-        url_service_1.UrlService,
         n8n_checkpoint_storage_1.N8NCheckpointStorage,
-        agent_secure_runtime_1.AgentSecureRuntime,
-        node_execution_1.EphemeralNodeExecutor,
-        agents_tools_service_1.AgentsToolsService,
         n8n_memory_1.N8nMemory,
         agent_execution_service_1.AgentExecutionService,
         agent_history_repository_1.AgentHistoryRepository,
@@ -1471,11 +1340,14 @@ exports.AgentsService = AgentsService = __decorate([
         telemetry_1.Telemetry,
         chat_integration_service_1.ChatIntegrationService,
         agent_knowledge_service_1.AgentKnowledgeService,
-        agent_knowledge_command_service_1.AgentKnowledgeCommandService,
-        oauth_service_1.OauthService])
+        agent_runtime_reconstruction_service_1.AgentRuntimeReconstructionService])
 ], AgentsService);
-function getProviderPrefix(modelId) {
-    const slashIdx = modelId.indexOf('/');
-    return slashIdx === -1 ? '' : modelId.slice(0, slashIdx);
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function hasNodeToolInputSchema(raw) {
+    if (!isRecord(raw) || !Array.isArray(raw.tools))
+        return false;
+    return raw.tools.some((tool) => isRecord(tool) && tool.type === 'node' && 'inputSchema' in tool);
 }
 //# sourceMappingURL=agents.service.js.map