n8n 2.28.4 → 2.29.1

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

@@ -43,187 +43,22 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AgentsService = void 0;
-exports.chatThreadId = chatThreadId;
-const api_types_1 = require("@n8n/api-types");
-const fromai_helpers_1 = require("@n8n/ai-utilities/fromai-helpers");
 const backend_common_1 = require("@n8n/backend-common");
-const config_1 = require("@n8n/config");
-const constants_1 = require("@n8n/constants");
-const utils_1 = require("@n8n/utils");
 const db_1 = require("@n8n/db");
-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 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 publisher_service_1 = require("../../scaling/pubsub/publisher.service");
-const telemetry_1 = require("../../telemetry");
-const ttl_map_1 = require("../../utils/ttl-map");
-const agents_credential_provider_1 = require("./adapters/agents-credential-provider");
-const agent_telemetry_1 = require("./agent-telemetry");
-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 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_message_context_service_1 = require("./integrations/integration-message-context.service");
-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 agent_config_composition_1 = require("./json-config/agent-config-composition");
-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 chat_integration_service_1 = require("./integrations/chat-integration.service");
 const agent_knowledge_service_1 = require("./agent-knowledge.service");
-const agent_knowledge_gate_1 = require("./agent-knowledge-gate");
-function chatThreadId(agentId, userId) {
-    const baseThreadId = `${builder_tool_names_1.AGENT_THREAD_PREFIX.TEST}${agentId}`;
-    return userId ? `${baseThreadId}:${userId}` : baseThreadId;
-}
-function getMaxIterationsChunks() {
-    const id = crypto.randomUUID();
-    return [
-        { type: 'text-start', id },
-        {
-            type: 'text-delta',
-            id,
-            delta: 'The agent has reached the maximum number of iterations and has stopped.',
-        },
-        { type: 'text-end', id },
-    ];
-}
+const agent_runtime_cache_service_1 = require("./agent-runtime-cache.service");
+const agent_test_chat_service_1 = require("./agent-test-chat.service");
+const agent_repository_1 = require("./repositories/agent.repository");
 let AgentsService = class AgentsService {
-    computeRuntimeCacheKey(params) {
-        if (params.usePublishedVersion) {
-            const parts = [params.agentId, 'published'];
-            if (params.integrationType)
-                parts.push(params.integrationType);
-            return parts.join(':');
-        }
-        const parts = [params.agentId, 'draft'];
-        if (params.n8nUserId)
-            parts.push(params.n8nUserId);
-        if (params.integrationType)
-            parts.push(params.integrationType);
-        return parts.join(':');
-    }
-    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)
-            return;
-        if (!this.globalConfig.multiMainSetup.enabled)
-            return;
-        void this.publisher
-            .publishCommand({
-            command: 'agent-config-changed',
-            payload: { agentId },
-        })
-            .catch((error) => {
-            this.logger.warn(`[AgentsService] Failed to publish agent-config-changed for ${agentId}`, {
-                error: error instanceof Error ? error.message : String(error),
-            });
-        });
-    }
-    clearRuntimeCacheForAgent(agentId) {
-        this.clearRuntimes(agentId);
-    }
-    handleAgentConfigChanged(payload) {
-        this.clearRuntimes(payload.agentId, { skipBroadcast: true });
-    }
-    constructor(logger, agentRepository, projectRelationRepository, n8nCheckpointStorage, n8nMemory, agentExecutionService, agentHistoryRepository, agentSkillsService, agentTaskRepository, agentTaskSnapshotRepository, publisher, agentsConfig, globalConfig, telemetry, chatIntegrationService, agentKnowledgeService, agentRuntimeReconstructionService, integrationMessageContextService) {
+    constructor(logger, agentRepository, projectRelationRepository, agentKnowledgeService, runtimeCacheService, testChatService) {
         this.logger = logger;
         this.agentRepository = agentRepository;
         this.projectRelationRepository = projectRelationRepository;
-        this.n8nCheckpointStorage = n8nCheckpointStorage;
-        this.n8nMemory = n8nMemory;
-        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.agentRuntimeReconstructionService = agentRuntimeReconstructionService;
-        this.integrationMessageContextService = integrationMessageContextService;
-        this.runtimes = new ttl_map_1.TtlMap(30 * constants_1.Time.minutes.toMilliseconds);
-    }
-    isNodeToolsModuleEnabled() {
-        return this.agentsConfig.modules.includes('node-tools-searcher');
-    }
-    isKnowledgeBaseEnabled() {
-        return (0, agent_knowledge_gate_1.isAgentKnowledgeBaseEnabled)(this.agentsConfig);
-    }
-    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 {
-            incrementMessageCount: () => this.telemetry.trackAgentExecution({
-                agent_id: agentId,
-                ...attribution,
-                message_count: 1,
-            }),
-            incrementTokenCount: (tokenCount) => this.telemetry.trackAgentExecution({
-                agent_id: agentId,
-                ...attribution,
-                token_count: tokenCount,
-            }),
-            incrementToolCallCount: () => this.telemetry.trackAgentExecution({
-                agent_id: agentId,
-                ...attribution,
-                tool_call_count: 1,
-            }),
-        };
-    }
-    listChatIntegrations() {
-        return di_1.Container.get(agent_chat_integration_1.ChatIntegrationRegistry)
-            .listPublic()
-            .map((i) => ({
-            type: i.type,
-            label: i.displayLabel,
-            icon: i.displayIcon,
-            credentialTypes: i.credentialTypes,
-            ...(i.builderGuidance
-                ? {
-                    capabilities: i.builderGuidance.capabilities,
-                    useIntegrationWhen: i.builderGuidance.useIntegrationWhen,
-                    useNodeToolWhen: i.builderGuidance.useNodeToolWhen,
-                }
-                : {}),
-        }));
+        this.runtimeCacheService = runtimeCacheService;
+        this.testChatService = testChatService;
     }
     async create(projectId, name) {
         const defaultConfig = {
@@ -252,37 +87,6 @@ let AgentsService = class AgentsService {
     async findById(agentId, projectId) {
         return await this.agentRepository.findByIdAndProjectId(agentId, projectId);
     }
-    async updateName(agentId, projectId, name) {
-        const agent = await this.agentRepository.findByIdAndProjectId(agentId, projectId);
-        if (!agent) {
-            return null;
-        }
-        agent.name = name;
-        if (agent.schema) {
-            agent.schema = { ...agent.schema, name };
-        }
-        (0, agent_draft_utils_1.markAgentDraftDirty)(agent);
-        const saved = await this.agentRepository.save(agent);
-        this.logger.debug('Updated SDK agent name', { agentId, projectId, name });
-        return saved;
-    }
-    async updateDescription(agentId, projectId, description, updatedAt) {
-        const agent = await this.agentRepository.findByIdAndProjectId(agentId, projectId);
-        if (!agent) {
-            return null;
-        }
-        if (updatedAt && agent.updatedAt.toISOString() !== updatedAt) {
-            throw new conflict_error_1.ConflictError('Agent has been modified');
-        }
-        agent.description = description;
-        if (agent.schema) {
-            agent.schema = { ...agent.schema, description };
-        }
-        (0, agent_draft_utils_1.markAgentDraftDirty)(agent);
-        const saved = await this.agentRepository.save(agent);
-        this.logger.debug('Updated SDK agent description', { agentId, projectId });
-        return saved;
-    }
     async findByUser(userId) {
         const projectRelations = await this.projectRelationRepository.findAllByUser(userId);
         const projectIds = projectRelations.map((pr) => pr.projectId);
@@ -310,152 +114,6 @@ let AgentsService = class AgentsService {
         });
         return agents.filter((agent) => agent.activeVersionId !== null);
     }
-    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`);
-        }
-        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);
-                if (!existing) {
-                    throw new not_found_error_1.NotFoundError(`Version "${versionId}" not found for agent "${agentId}"`);
-                }
-                agent.activeVersionId = existing.versionId;
-                agent.activeVersion = existing;
-                agent.versionId = (0, uuid_1.v4)();
-            }
-            else {
-                agent.versionId ??= (0, uuid_1.v4)();
-                agent.activeVersion = await this.agentHistoryRepository.saveVersion({
-                    versionId: agent.versionId,
-                    agentId: agent.id,
-                    schema: agent.schema,
-                    tools: this.snapshotConfiguredTools(agent.schema, agent.tools ?? {}),
-                    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 ?? [];
-        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)
-                .catch((error) => this.logger.warn('Failed to connect integrations on publish', {
-                agentId,
-                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;
-    }
-    async unpublishAgent(agentId, projectId) {
-        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) => {
-            agent.activeVersionId = null;
-            agent.activeVersion = null;
-            agent.versionId = (0, uuid_1.v4)();
-            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 { 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;
-    }
-    async revertToPublishedAgent(agentId, projectId) {
-        const agent = await this.agentRepository.findByIdAndProjectId(agentId, projectId);
-        if (!agent) {
-            throw new not_found_error_1.NotFoundError(`Agent "${agentId}" not found`);
-        }
-        const activeVersion = agent.activeVersion;
-        if (!activeVersion) {
-            throw new conflict_error_1.ConflictError(`Agent "${agentId}" is not published`);
-        }
-        await this.agentRepository.manager.transaction(async (trx) => {
-            agent.schema = activeVersion.schema ? (0, n8n_workflow_1.deepCopy)(activeVersion.schema) : null;
-            agent.tools = (0, n8n_workflow_1.deepCopy)(activeVersion.tools ?? {});
-            agent.skills = (0, n8n_workflow_1.deepCopy)(activeVersion.skills ?? {});
-            agent.versionId = activeVersion.versionId;
-            if (agent.schema) {
-                agent.name = agent.schema.name;
-                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, userId) {
         const agent = await this.agentRepository.findByIdAndProjectId(agentId, projectId);
         if (!agent) {
@@ -471,7 +129,7 @@ let AgentsService = class AgentsService {
             });
         }
         await this.agentRepository.remove(agent);
-        this.clearRuntimes(agentId);
+        this.runtimeCacheService.clearRuntimes(agentId);
         try {
             const { AgentTaskService } = await Promise.resolve().then(() => __importStar(require('./agent-task.service')));
             await di_1.Container.get(AgentTaskService).requestReconcile(agentId);
@@ -483,7 +141,7 @@ let AgentsService = class AgentsService {
             });
         }
         try {
-            await this.clearAllTestChatMessages(agentId);
+            await this.testChatService.clearAllTestChatMessages(agentId);
         }
         catch (error) {
             this.logger.warn('Failed to clear test chat on agent delete', {
@@ -494,950 +152,15 @@ let AgentsService = class AgentsService {
         this.logger.debug('Deleted SDK agent', { agentId, projectId });
         return true;
     }
-    async getConversationHistory(params) {
-        const { threadId, projectId, agentId } = params;
-        const detail = await this.agentExecutionService.getThreadDetail(threadId, projectId, agentId);
-        if (!detail)
-            return null;
-        return (0, execution_to_message_mapper_1.executionsToMessagesDto)(detail.executions);
-    }
-    createCredentialProvider(projectId) {
-        return new agents_credential_provider_1.AgentsCredentialProvider(di_1.Container.get(credentials_service_1.CredentialsService), projectId);
-    }
-    async getRuntime(params) {
-        const { agentId, projectId, integrationType, usePublishedVersion } = params;
-        const cacheKey = this.computeRuntimeCacheKey(params);
-        const cached = this.runtimes.get(cacheKey);
-        if (cached)
-            return cached;
-        const agentEntity = await this.agentRepository.findByIdAndProjectId(agentId, projectId);
-        if (!agentEntity)
-            throw new not_found_error_1.NotFoundError(`Agent ${agentId} not found`);
-        let n8nUserId = params.n8nUserId;
-        let agentData = agentEntity;
-        if (usePublishedVersion) {
-            agentData = this.getPublishedAgent(agentEntity);
-            n8nUserId ??= agentEntity.activeVersion?.publishedById ?? undefined;
-        }
-        if (!n8nUserId) {
-            throw new n8n_workflow_1.UserError('Agent user owner id is required');
-        }
-        const credentialProvider = this.createCredentialProvider(projectId);
-        const { agent: agentInstance, toolRegistry } = await this.reconstructFromConfig(agentData, credentialProvider, n8nUserId, integrationType);
-        this.runtimes.set(cacheKey, {
-            agent: agentInstance,
-            agentId,
-            toolRegistry,
-            projectId,
-            telemetryConfiguration: (0, agent_telemetry_1.buildAgentConfigurationTelemetry)(agentData),
-        });
-        const runtime = this.runtimes.get(cacheKey);
-        if (!runtime)
-            throw new Error(`Agent ${agentId} failed to reconstruct`);
-        return runtime;
-    }
-    async *resumeForChat(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`);
-        }
-        if (checkpointStatus.status === 'not-found') {
-            throw new n8n_workflow_1.UserError(`Checkpoint ${runId} not found and cannot be resumed`);
-        }
-        const memoryScope = checkpointStatus.checkpoint?.persistence;
-        if (!memoryScope) {
-            throw new n8n_workflow_1.UserError(`Checkpoint ${runId} has no memory data and cannot be resumed`);
-        }
-        const threadId = memoryScope.threadId;
-        const runtime = await this.getRuntime({
-            agentId,
-            projectId,
-            ...(userId ? { n8nUserId: userId } : {}),
-            usePublishedVersion,
-            integrationType,
-        });
-        const { agent: agentInstance, toolRegistry } = runtime;
-        const recorder = new execution_recorder_1.ExecutionRecorder(toolRegistry);
-        const runType = usePublishedVersion ? 'production' : 'test';
-        try {
-            const resultStream = await agentInstance.resume('stream', resumeData, {
-                runId,
-                toolCallId,
-                executionCounter: this.createAgentExecutionCounter({ agentId, userId }),
-            });
-            for await (const value of (0, agent_stream_1.streamAgentChunks)(resultStream.stream)) {
-                recorder.record(value);
-                yield value;
-            }
-        }
-        catch (error) {
-            recorder.record({ type: 'error', error });
-            recorder.record({ type: 'finish', finishReason: 'error' });
-            throw error;
-        }
-        finally {
-            const messageRecord = recorder.getMessageRecord();
-            void this.agentExecutionService
-                .recordMessage({
-                threadId,
-                agentId,
-                agentName: agentInstance.name,
-                projectId,
-                userMessage: '',
-                record: messageRecord,
-                telemetry: {
-                    runType,
-                    configuration: runtime.telemetryConfiguration,
-                },
-                hitlStatus: recorder.suspended ? 'suspended' : 'resumed',
-            })
-                .catch((error) => {
-                this.logger.warn('Failed to record resumed agent execution', {
-                    agentId,
-                    threadId,
-                    error: error instanceof Error ? error.message : String(error),
-                });
-            });
-        }
-    }
-    async validateAgentIsRunnable(agentId, projectId, credentialProvider) {
-        const agentEntity = await this.agentRepository.findByIdAndProjectId(agentId, projectId);
-        if (!agentEntity) {
-            return { missing: ['agent'] };
-        }
-        const config = agentEntity.schema;
-        const missing = [];
-        if (!config) {
-            return { missing: ['instructions', 'model', 'credential'] };
-        }
-        if (!config.instructions?.trim()) {
-            missing.push('instructions');
-        }
-        if (!config.model?.trim() || !api_types_1.AgentModelSchema.safeParse(config.model).success) {
-            missing.push('model');
-        }
-        let credentialList;
-        const findCredential = async (credentialId) => {
-            credentialList ??= await credentialProvider.list();
-            return credentialList.find((credential) => credential.id === credentialId);
-        };
-        const credentialExists = async (credentialId) => {
-            return (await findCredential(credentialId)) !== undefined;
-        };
-        if (!config.credential?.trim()) {
-            missing.push('credential');
-        }
-        else {
-            try {
-                const credentialId = config.credential.trim();
-                if (!(await credentialExists(credentialId)))
-                    missing.push('credential');
-            }
-            catch {
-            }
-        }
-        const episodicMemory = config.memory?.episodicMemory;
-        if (config.memory?.enabled) {
-            try {
-                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 {
-                }
-            }
-        }
-        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}`));
-        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 === (0, model_id_1.getProviderPrefix)(model);
-    }
-    async *executeForChat(config) {
-        const { agentId, projectId, message, userId, memory } = config;
-        const runtime = await this.getRuntime({
-            agentId,
-            projectId,
-            n8nUserId: userId,
-            integrationType: api_types_1.N8N_CHAT_INTEGRATION_TYPE,
-        });
-        await this.integrationMessageContextService.setLatest(memory.threadId, memory.resourceId, {
-            integrationConnectionId: api_types_1.N8N_CHAT_INTEGRATION_TYPE,
-            platform: api_types_1.N8N_CHAT_INTEGRATION_TYPE,
-            target: { type: 'dm', userId, threadId: memory.threadId },
-            interactingUserId: userId,
-            updatedAt: new Date().toISOString(),
-        });
-        yield* this.streamChatResponse({
-            agentInstance: runtime.agent,
-            toolRegistry: runtime.toolRegistry,
-            agentId,
-            userId,
-            message,
-            memory,
-            projectId: runtime.projectId,
-            telemetry: {
-                runType: 'test',
-                configuration: runtime.telemetryConfiguration,
-            },
-        });
-    }
-    async getTestChatMessages(agentId, userId) {
-        return await this.n8nMemory
-            .getImplementation(agentId)
-            .getMessages(chatThreadId(agentId, userId), {
-            resourceId: (0, agent_memory_scope_1.draftChatMemoryResourceId)(userId),
-        });
-    }
-    async clearTestChatMessages(agentId, userId) {
-        await this.n8nMemory.getImplementation(agentId).deleteThread(chatThreadId(agentId, userId));
-    }
-    async clearAllTestChatMessages(agentId) {
-        const threadId = chatThreadId(agentId);
-        const memory = this.n8nMemory.getImplementation(agentId);
-        await memory.deleteThreadsByPrefix(threadId);
-        await memory.deleteMessagesByThread(threadId);
-        await memory.deleteThread(threadId);
-    }
-    async *executeForChatPublished(config) {
-        const { agentId, projectId, message, memory, integrationType } = config;
-        const runtime = await this.getRuntime({
-            agentId,
-            projectId,
-            integrationType,
-            usePublishedVersion: true,
-        });
-        yield* this.streamChatResponse({
-            agentInstance: runtime.agent,
-            toolRegistry: runtime.toolRegistry,
-            agentId,
-            message,
-            memory,
-            projectId: runtime.projectId,
-            source: integrationType,
-            telemetry: {
-                runType: 'production',
-                configuration: runtime.telemetryConfiguration,
-            },
-        });
-    }
-    async *executeForTaskPublished(config) {
-        const { agentId, projectId, message, memory, taskId, taskVersionId } = config;
-        const runtime = await this.getRuntime({
-            agentId,
-            projectId,
-            integrationType: 'task',
-            usePublishedVersion: true,
-        });
-        yield* this.streamChatResponse({
-            agentInstance: runtime.agent,
-            toolRegistry: runtime.toolRegistry,
-            agentId,
-            message,
-            memory,
-            projectId: runtime.projectId,
-            source: 'task',
-            taskId,
-            taskVersionId,
-            telemetry: {
-                runType: 'production',
-                configuration: runtime.telemetryConfiguration,
-            },
-        });
-    }
-    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,
-            telemetry: {
-                runType: 'test',
-                configuration: runtime.telemetryConfiguration,
-            },
-        });
-    }
-    async *streamChatResponse(config) {
-        const { agentInstance, toolRegistry, agentId, userId, message, memory, projectId, source, taskId, taskVersionId, telemetry, } = config;
-        const { threadId, resourceId } = memory;
-        const recorder = new execution_recorder_1.ExecutionRecorder(toolRegistry);
-        try {
-            const resultStream = await agentInstance.stream(message, {
-                persistence: { threadId, resourceId },
-                executionCounter: this.createAgentExecutionCounter({ agentId, userId }),
-            });
-            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;
-            }
-        }
-        catch (error) {
-            recorder.record({ type: 'error', error });
-            recorder.record({ type: 'finish', finishReason: 'error' });
-            throw error;
-        }
-        finally {
-            const messageRecord = recorder.getMessageRecord();
-            void this.agentExecutionService
-                .recordMessage({
-                threadId,
-                agentId,
-                agentName: agentInstance.name,
-                projectId,
-                userMessage: message,
-                record: messageRecord,
-                hitlStatus: recorder.suspended ? 'suspended' : undefined,
-                source,
-                taskId,
-                taskVersionId,
-                telemetry,
-            })
-                .catch((error) => {
-                this.logger.warn('Failed to record agent execution', {
-                    agentId,
-                    threadId,
-                    error: error instanceof Error ? error.message : String(error),
-                });
-            });
-        }
-    }
-    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) {
-            return {
-                ok: false,
-                error: e instanceof Error ? e.message : 'Unknown compilation error',
-            };
-        }
-    }
-    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.');
-        }
-        const credentialProvider = new agents_credential_provider_1.AgentsCredentialProvider(di_1.Container.get(credentials_service_1.CredentialsService), projectId);
-        let agentData = agentEntity;
-        if (!useDraftVersion) {
-            agentData = this.getPublishedAgent(agentEntity);
-        }
-        const telemetryConfiguration = (0, agent_telemetry_1.buildAgentConfigurationTelemetry)(agentData);
-        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'}`);
-        }
-        const agentInstance = compiled.agent;
-        const recorder = new execution_recorder_1.ExecutionRecorder();
-        let structuredOutput = null;
-        const toolCalls = [];
-        const toolInputs = new Map();
-        let streamError;
-        try {
-            const resultStream = await agentInstance.stream(message, {
-                persistence: { resourceId: executionId, threadId },
-                executionCounter: this.createAgentExecutionCounter({ agentId, userId: telemetryUserId }),
-            });
-            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;
-                }
-            }
-        }
-        catch (error) {
-            recorder.record({ type: 'error', error });
-            recorder.record({ type: 'finish', finishReason: 'error' });
-            streamError = error instanceof Error ? error : new Error(String(error));
-        }
-        const messageRecord = recorder.getMessageRecord();
-        void this.agentExecutionService
-            .recordMessage({
-            threadId,
-            agentId,
-            agentName: agentInstance.name,
-            projectId,
-            userMessage: message,
-            record: messageRecord,
-            source: api_types_1.AGENT_WORKFLOW_TRIGGER_TYPE,
-            telemetry: {
-                runType: useDraftVersion ? 'test' : 'production',
-                configuration: telemetryConfiguration,
-            },
-        })
-            .catch((error) => {
-            this.logger.warn('Failed to record agent execution from workflow', {
-                agentId,
-                threadId,
-                error: error instanceof Error ? error.message : String(error),
-            });
-        });
-        if (streamError !== undefined) {
-            throw streamError;
-        }
-        if (recorder.suspended) {
-            throw new n8n_workflow_1.OperationalError('Agent execution suspended waiting for tool approval. ' +
-                '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(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,
-            structuredOutput: structuredOutput ?? null,
-            usage: messageRecord.usage
-                ? {
-                    promptTokens: messageRecord.usage.promptTokens,
-                    completionTokens: messageRecord.usage.completionTokens,
-                    totalTokens: messageRecord.usage.totalTokens,
-                }
-                : null,
-            toolCalls,
-            finishReason: messageRecord.finishReason,
-            session: {
-                agentId,
-                projectId,
-                sessionId: threadId,
-            },
-        };
-    }
-    async getConfig(agentId, projectId) {
-        const entity = await this.agentRepository.findByIdAndProjectId(agentId, projectId);
-        if (!entity)
-            throw new not_found_error_1.NotFoundError('Agent not found');
-        const config = (0, agent_config_composition_1.composeJsonConfig)(entity);
-        if (!config) {
-            throw new n8n_workflow_1.UserError('Agent has no JSON config yet.');
-        }
-        return config;
-    }
-    async validateConfig(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 };
-        }
-        const config = parsed.data;
-        if ((0, api_types_1.isNodeToolsEnabled)(config.config) && !this.isNodeToolsModuleEnabled()) {
-            return {
-                valid: false,
-                error: 'config.nodeTools.enabled requires the node-tools-searcher agents module to be enabled.',
-            };
-        }
-        try {
-            this.validateNodeToolExpressions(config);
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            return {
-                valid: false,
-                error: `Invalid $fromAI expression in node tool config: ${message}`,
-            };
-        }
-        const nodeError = await this.validateNodeToolConfigs(config);
-        if (nodeError) {
-            return { valid: false, error: nodeError };
-        }
-        return { valid: true, config };
-    }
-    validateNodeToolExpressions(config) {
-        for (const tool of config.tools ?? []) {
-            if (tool.type !== 'node')
-                continue;
-            (0, fromai_helpers_1.extractFromAIParameters)((tool.node.nodeParameters ?? {}));
-        }
-    }
-    async updateConfig(agentId, projectId, config) {
-        const entity = await this.agentRepository.findByIdAndProjectId(agentId, projectId);
-        if (!entity)
-            throw new not_found_error_1.NotFoundError('Agent not found');
-        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}`);
-        }
-        const tasksProvided = result.config.tasks !== undefined;
-        const existingTaskIds = tasksProvided
-            ? (await this.agentTaskRepository.findByAgentId(agentId)).map((task) => task.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;
-        const toolsProvided = result.config.tools !== undefined;
-        const skillsProvided = result.config.skills !== undefined;
-        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;
-        const { schemaConfig: decomposedSchema, integrations: decomposedIntegrations } = (0, agent_config_composition_1.decomposeJsonConfig)(result.config);
-        const nextIntegrations = integrationsProvided ? decomposedIntegrations : previousIntegrations;
-        const nextSchema = {
-            ...(previousSchema ?? {}),
-            name: decomposedSchema.name,
-            model: decomposedSchema.model,
-            instructions: decomposedSchema.instructions,
-            ...(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 } : {}),
-            ...(providerToolsProvided ? { providerTools: decomposedSchema.providerTools } : {}),
-            ...(configBlockProvided ? { config: decomposedSchema.config } : {}),
-            ...(mcpServersProvided ? { mcpServers: decomposedSchema.mcpServers } : {}),
-        };
-        entity.schema = nextSchema;
-        entity.name = result.config.name;
-        if (descriptionProvided)
-            entity.description = result.config.description ?? null;
-        entity.integrations = nextIntegrations;
-        (0, agent_draft_utils_1.markAgentDraftDirty)(entity);
-        if (toolsProvided) {
-            const referencedIds = new Set((result.config.tools ?? [])
-                .filter((t) => t.type === 'custom')
-                .map((t) => t.id));
-            const orphanIds = Object.keys(entity.tools).filter((id) => !referencedIds.has(id));
-            if (orphanIds.length > 0) {
-                const tools = { ...entity.tools };
-                for (const id of orphanIds) {
-                    delete tools[id];
-                }
-                entity.tools = tools;
-            }
-        }
-        if (skillsProvided) {
-            this.agentSkillsService.removeUnreferencedSkills(entity, result.config);
-        }
-        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);
-        }
-        return {
-            config: (0, agent_config_composition_1.composeJsonConfig)(saved) ?? result.config,
-            updatedAt: saved.updatedAt.toISOString(),
-            versionId: saved.versionId,
-        };
-    }
-    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;
-        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
-            ? 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);
-        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) => 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;
-    }
-    async buildCustomTool(agentId, projectId, code, descriptor) {
-        const entity = await this.agentRepository.findByIdAndProjectId(agentId, projectId);
-        if (!entity)
-            throw new not_found_error_1.NotFoundError('Agent not found');
-        const toolId = (0, agent_resource_id_1.generateAgentResourceId)('tool', Object.keys(entity.tools ?? {}));
-        entity.tools = {
-            ...entity.tools,
-            [toolId]: { code, descriptor },
-        };
-        (0, agent_draft_utils_1.markAgentDraftDirty)(entity);
-        this.clearRuntimes(agentId);
-        await this.agentRepository.save(entity);
-        this.logger.debug('Built custom tool', { agentId, projectId, toolId });
-        return { ok: true, id: toolId, descriptor };
-    }
-    async listSkills(agentId, projectId) {
-        return await this.agentSkillsService.listSkills(agentId, projectId);
-    }
-    async getSkill(agentId, projectId, skillId) {
-        return await this.agentSkillsService.getSkill(agentId, projectId, skillId);
-    }
-    async createSkill(agentId, projectId, skill) {
-        const result = await this.agentSkillsService.createSkill(agentId, projectId, skill);
-        this.clearRuntimes(agentId);
-        return result;
-    }
-    async createAndAttachSkill(agentId, projectId, skill) {
-        const result = await this.agentSkillsService.createAndAttachSkill(agentId, projectId, skill);
-        this.clearRuntimes(agentId);
-        return result;
-    }
-    async updateSkill(agentId, projectId, skillId, updates) {
-        const result = await this.agentSkillsService.updateSkill(agentId, projectId, skillId, updates);
-        this.clearRuntimes(agentId);
-        return result;
-    }
-    async deleteCustomTool(agentId, projectId, toolId) {
-        const entity = await this.agentRepository.findByIdAndProjectId(agentId, projectId);
-        if (!entity)
-            throw new not_found_error_1.NotFoundError('Agent not found');
-        const tools = { ...entity.tools };
-        delete tools[toolId];
-        entity.tools = tools;
-        if (entity.schema?.tools) {
-            entity.schema.tools = entity.schema.tools.filter((t) => !(t.type === 'custom' && 'id' in t && t.id === toolId));
-        }
-        (0, agent_draft_utils_1.markAgentDraftDirty)(entity);
-        this.clearRuntimes(agentId);
-        await this.agentRepository.save(entity);
-        this.logger.debug('Deleted custom tool', { agentId, projectId, toolId });
-    }
-    async deleteSkill(agentId, projectId, skillId) {
-        await this.agentSkillsService.deleteSkill(agentId, projectId, skillId);
-        this.clearRuntimes(agentId);
-    }
-    async validateNodeToolConfigs(config) {
-        const nodeTools = (config.tools ?? []).filter((t) => t.type === 'node');
-        if (nodeTools.length === 0)
-            return null;
-        const { setSchemaBaseDirs, validateNodeConfig } = await Promise.resolve().then(() => __importStar(require('@n8n/workflow-sdk')));
-        const dirs = (0, node_definition_resolver_1.resolveBuiltinNodeDefinitionDirs)();
-        if (dirs.length > 0) {
-            setSchemaBaseDirs(dirs);
-        }
-        const errors = [];
-        for (const tool of nodeTools) {
-            const nodeType = tool.node.nodeType;
-            const nodeTypeVersion = tool.node.nodeTypeVersion;
-            const nodeParameters = tool.node.nodeParameters ?? {};
-            const result = validateNodeConfig(nodeType, nodeTypeVersion, { parameters: nodeParameters }, { isToolNode: true });
-            if (!result.valid) {
-                const messages = result.errors
-                    .map((e) => e.message)
-                    .join('; ');
-                errors.push(`Node tool "${tool.name}" (${nodeType}@${nodeTypeVersion}): ${messages}`);
-            }
-        }
-        return errors.length > 0 ? errors.join('\n') : null;
-    }
-    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]));
-        }
-        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) {
-        const refs = (config?.tools ?? []).filter((ref) => ref.type === 'custom');
-        const seen = new Set();
-        const missing = [];
-        for (const ref of refs) {
-            if (seen.has(ref.id))
-                continue;
-            seen.add(ref.id);
-            if (!tools[ref.id])
-                missing.push(ref.id);
-        }
-        return missing;
-    }
-    snapshotConfiguredTools(config, tools) {
-        if (!config)
-            return null;
-        const missing = this.getMissingCustomToolIds(config, tools);
-        if (missing.length > 0) {
-            throw new n8n_workflow_1.UserError(`Cannot publish agent with missing custom tools: ${missing.join(', ')}`);
-        }
-        const snapshot = {};
-        for (const ref of config.tools ?? []) {
-            if (ref.type !== 'custom')
-                continue;
-            const tool = tools[ref.id];
-            if (tool)
-                snapshot[ref.id] = tool;
-        }
-        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) {
-        return await this.agentRuntimeReconstructionService.reconstructFromAgentEntity(agentEntity, credentialProvider, userId, integrationType);
-    }
 };
 exports.AgentsService = AgentsService;
-__decorate([
-    (0, decorators_1.OnPubSubEvent)('agent-config-changed', { instanceType: 'main' }),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object]),
-    __metadata("design:returntype", void 0)
-], AgentsService.prototype, "handleAgentConfigChanged", null);
 exports.AgentsService = AgentsService = __decorate([
     (0, di_1.Service)(),
     __metadata("design:paramtypes", [backend_common_1.Logger,
         agent_repository_1.AgentRepository,
         db_1.ProjectRelationRepository,
-        n8n_checkpoint_storage_1.N8NCheckpointStorage,
-        n8n_memory_1.N8nMemory,
-        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,
         agent_knowledge_service_1.AgentKnowledgeService,
-        agent_runtime_reconstruction_service_1.AgentRuntimeReconstructionService,
-        integration_message_context_service_1.IntegrationMessageContextService])
+        agent_runtime_cache_service_1.AgentRuntimeCacheService,
+        agent_test_chat_service_1.AgentTestChatService])
 ], AgentsService);
-function hasNodeToolInputSchema(raw) {
-    if (!(0, utils_1.isRecord)(raw) || !Array.isArray(raw.tools))
-        return false;
-    return raw.tools.some((tool) => (0, utils_1.isRecord)(tool) && tool.type === 'node' && 'inputSchema' in tool);
-}
 //# sourceMappingURL=agents.service.js.map