n8n 2.41.2 → 2.42.0

package/dist/modules/agents/agent-runtime-reconstruction.service.js

@@ -53,6 +53,7 @@ const environment_tool_1 = require("./tools/environment-tool");
 const workflow_tool_unavailable_error_1 = require("./tools/workflow-tool-unavailable-error");
 const workflow_tool_workflow_resolver_1 = require("./tools/workflow-tool-workflow-resolver");
 const workflow_tool_workflow_loader_service_1 = require("./tools/workflow-tool-workflow-loader.service");
+const agent_runtime_assets_1 = require("./utils/agent-runtime-assets");
 const sub_agent_resolver_1 = require("./utils/sub-agent-resolver");
 async function getChatIntegrationToolServices() {
     const { IntegrationMessageContextService } = await import('./integrations/integration-message-context.service.js');
@@ -95,7 +96,7 @@ let AgentRuntimeReconstructionService = class AgentRuntimeReconstructionService
         this.workflowFinderService = workflowFinderService;
         this.agentChatAttachmentService = agentChatAttachmentService;
     }
-    async reconstructFromAgentEntity(agentEntity, credentialProvider, runType, integrationType, user, instrumentation, workflowToolExecutionMode = 'manual', sandboxPrincipalHash, { supportsHitl, previewChat, allowBackgroundTasks = true, } = {}) {
+    async reconstructFromAgentEntity(agentEntity, credentialProvider, runType, integrationType, user, instrumentation, workflowToolExecutionMode = 'manual', sandboxPrincipalHash, { supportsHitl, previewChat, allowBackgroundTasks = true, attributionUserId, } = {}) {
         let config = agentEntity.schema;
         if (!config) {
             throw new n8n_workflow_1.UserError('Agent has no JSON config.');
@@ -108,12 +109,7 @@ let AgentRuntimeReconstructionService = class AgentRuntimeReconstructionService
             userToolAccessSnapshot = filtered.snapshot;
             unavailableTools = filtered.unavailable;
         }
-        const toolsByName = {};
-        const toolDescriptors = {};
-        for (const [_toolId, toolEntry] of Object.entries(agentEntity.tools ?? {})) {
-            toolsByName[toolEntry.descriptor.name] = toolEntry.code;
-            toolDescriptors[_toolId] = toolEntry.descriptor;
-        }
+        const { toolDescriptors, toolCodeByName } = (0, agent_runtime_assets_1.getAgentRuntimeAssets)(agentEntity);
         const subAgentDelegation = await this.createSubAgentDelegationConfig(config, agentEntity.projectId);
         const runtime = await this.reconstructRuntime({
             config,
@@ -121,7 +117,7 @@ let AgentRuntimeReconstructionService = class AgentRuntimeReconstructionService
             projectId: agentEntity.projectId,
             credentialProvider,
             toolDescriptors,
-            toolCodeByName: toolsByName,
+            toolCodeByName,
             skills: agentEntity.skills ?? {},
             runtimeProfile: 'top-level',
             supportsHitl,
@@ -132,6 +128,7 @@ let AgentRuntimeReconstructionService = class AgentRuntimeReconstructionService
             credentialIntegrations: agentEntity.integrations ?? [],
             subAgentDelegation,
             user,
+            attributionUserId,
             instrumentation,
             sandboxPrincipalHash,
             unavailableTools,
@@ -150,46 +147,24 @@ let AgentRuntimeReconstructionService = class AgentRuntimeReconstructionService
         const grantedCredentialIds = new Set();
         const grantedWorkflowIds = new Set();
         let keptGatedTool = false;
-        const drop = (ref, reason, message) => unavailable.push({ toolName: toolRefName(ref), toolType: ref.type, reason, message });
         for (const ref of tools) {
             if (ref.type === 'custom') {
                 filtered.push(ref);
                 continue;
             }
-            if (!canExecute) {
-                drop(ref, 'no_access', 'The user lacks workflow:execute on the project');
-                continue;
-            }
-            if (ref.type === 'node') {
-                const credentialIds = Object.values(ref.node.credentials ?? {})
-                    .map((credential) => credential.id)
-                    .filter((id) => Boolean(id));
-                const accessibleCredentials = await Promise.all(credentialIds.map(async (id) => await this.credentialsFinderService.findCredentialForUser(id, user, [
-                    'credential:read',
-                ])));
-                if (accessibleCredentials.some((credential) => credential === null)) {
-                    drop(ref, 'no_access', 'The user cannot read a credential the tool uses');
-                    continue;
-                }
-                for (const id of credentialIds)
-                    grantedCredentialIds.add(id);
-                keptGatedTool = true;
-                filtered.push(ref);
-                continue;
-            }
-            const workflow = await (0, workflow_tool_workflow_resolver_1.findWorkflowToolWorkflow)(this.workflowRepository, ref, projectId);
-            if (!workflow) {
-                filtered.push(ref);
+            const access = await this.checkToolAccess(ref, projectId, user, canExecute);
+            if (access && 'reason' in access) {
+                unavailable.push(access);
                 continue;
             }
-            const accessibleWorkflow = await this.workflowFinderService.findWorkflowForUser(workflow.id, user, ['workflow:execute']);
-            if (!accessibleWorkflow) {
-                drop(ref, 'no_access', `The user cannot execute workflow "${workflow.name}"`);
+            filtered.push(ref);
+            if (!access)
                 continue;
-            }
-            grantedWorkflowIds.add(workflow.id);
             keptGatedTool = true;
-            filtered.push(ref);
+            for (const id of access.credentialIds)
+                grantedCredentialIds.add(id);
+            for (const id of access.workflowIds)
+                grantedWorkflowIds.add(id);
         }
         return {
             tools: filtered,
@@ -204,6 +179,36 @@ let AgentRuntimeReconstructionService = class AgentRuntimeReconstructionService
                 : {}),
         };
     }
+    async checkToolAccess(ref, projectId, user, canExecute) {
+        const denied = (message) => ({
+            toolName: toolRefName(ref),
+            toolType: ref.type,
+            reason: 'no_access',
+            message,
+        });
+        if (!canExecute)
+            return denied('The user lacks workflow:execute on the project');
+        if (ref.type === 'node') {
+            const credentialIds = Object.values(ref.node.credentials ?? {})
+                .map((credential) => credential.id)
+                .filter((id) => Boolean(id));
+            const credentials = await Promise.all(credentialIds.map(async (id) => await this.credentialsFinderService.findCredentialForUser(id, user, [
+                'credential:read',
+            ])));
+            if (credentials.some((credential) => credential === null)) {
+                return denied('The user cannot read a credential the tool uses');
+            }
+            return { credentialIds, workflowIds: [] };
+        }
+        const workflow = await (0, workflow_tool_workflow_resolver_1.findWorkflowToolWorkflow)(this.workflowRepository, ref, projectId);
+        if (!workflow)
+            return undefined;
+        const accessibleWorkflow = await this.workflowFinderService.findWorkflowForUser(workflow.id, user, ['workflow:execute']);
+        if (!accessibleWorkflow) {
+            return denied(`The user cannot execute workflow "${workflow.name}"`);
+        }
+        return { credentialIds: [], workflowIds: [workflow.id] };
+    }
     async userStillHasToolAccess(snapshot, projectId, user) {
         if (!(await (0, check_access_1.userHasScopes)(user, ['workflow:execute'], false, { projectId })))
             return false;
@@ -231,30 +236,84 @@ let AgentRuntimeReconstructionService = class AgentRuntimeReconstructionService
         });
     }
     async reconstructRuntime(options) {
-        const { config, memoryOwnerAgentId, projectId, credentialProvider, toolDescriptors, toolCodeByName, skills, runtimeProfile, runType, workflowToolExecutionMode = 'manual', supportsHitl, parentAgentIdForDelegation, integrationType, credentialIntegrations, subAgentDelegation, user, instrumentation, sandboxPrincipalHash, parentWorkspace, allowBackgroundTasks = true, previewChat, } = options;
         const unavailable = [...(options.unavailableTools ?? [])];
-        const backgroundTasksEnabled = runtimeProfile === 'top-level' &&
-            allowBackgroundTasks &&
+        const backgroundTasksEnabled = options.runtimeProfile === 'top-level' &&
+            (options.allowBackgroundTasks ?? true) &&
             di_1.Container.get(config_1.AgentsConfig).backgroundTasksEnabled;
+        const runtime = await this.buildConfiguredRuntime(options, backgroundTasksEnabled, unavailable);
+        if (unavailable.length > 0) {
+            this.logger.warn('Agent runtime built with unavailable tools', {
+                agentId: options.memoryOwnerAgentId,
+                runType: options.runType,
+                tools: unavailable,
+            });
+        }
+        await this.injectRuntimeDependencies({
+            ...options,
+            agent: runtime.agent,
+            agentId: options.memoryOwnerAgentId,
+            workflowToolExecutionMode: options.workflowToolExecutionMode ?? 'manual',
+            parentAgentIdForDelegation: options.parentAgentIdForDelegation ?? options.memoryOwnerAgentId,
+            backgroundTasksEnabled,
+        });
+        return {
+            agent: runtime.agent,
+            toolRegistry: (0, tool_registry_1.buildToolRegistry)(runtime.resolvedTools),
+            mcpServerAttributions: runtime.mcpServerAttributions,
+        };
+    }
+    async buildConfiguredRuntime(options, backgroundTasksEnabled, unavailable) {
+        const { config, memoryOwnerAgentId, projectId, credentialProvider, toolDescriptors, toolCodeByName, skills, instrumentation, previewChat, } = options;
         const toolExecutor = this.secureRuntime.createToolExecutor(toolCodeByName);
+        const toolResolver = this.createRuntimeToolResolver(options, backgroundTasksEnabled, unavailable);
+        const resolvedTools = [];
+        const mcpServerAttributions = new Map();
+        const aiProxyFetch = (0, ai_proxy_fetch_1.createAiProxyFetch)(this.outboundHttp);
+        const aiMcpFetch = instrumentation?.mcpFetch ?? (0, ai_proxy_fetch_1.createAiMcpFetch)(this.outboundHttp);
+        const webSearchFetch = (0, ai_proxy_fetch_1.createWebSearchFetch)(this.outboundHttp);
+        const buildMcpClient = this.makeMcpClientFactory(options, aiMcpFetch, mcpServerAttributions);
+        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,
+            memoryFactory: this.getMemoryFactory(memoryOwnerAgentId),
+            buildMcpClient,
+            resolveManagedEmbeddingProviderOptions: async () => await this.resolveManagedEmbeddingProviderOptions(projectId),
+            modelFetch: instrumentation?.modelFetch ?? aiProxyFetch,
+            fallbackWebSearch: instrumentation?.webSearch,
+            attachAuthPendingMcpServers: instrumentation?.mcpFetch !== undefined,
+            webSearchFetch,
+            previewChat,
+        });
+        return { agent: reconstructed, resolvedTools, mcpServerAttributions };
+    }
+    createRuntimeToolResolver(options, backgroundTasksEnabled, unavailable) {
+        const { projectId, workflowToolExecutionMode = 'manual', runType, memoryOwnerAgentId, integrationType, user, attributionUserId, previewChat, supportsHitl, runtimeProfile, instrumentation, } = options;
         const canResume = supportsHitl ?? runtimeProfile === 'top-level';
-        const toolResolver = this.makeToolResolver({
+        return this.makeToolResolver({
             projectId,
             workflowToolExecutionMode,
             usePublishedWorkflowVersion: runType === 'production',
             agentId: memoryOwnerAgentId,
             integrationType,
-            userId: user?.id,
+            userId: attributionUserId ?? user?.id,
             previewChat,
+            publishedN8nChat: runType === 'production' &&
+                integrationType === api_types_1.N8N_CHAT_INTEGRATION_TYPE &&
+                attributionUserId !== undefined,
             supportsHitl: canResume,
             backgroundTasksEnabled: backgroundTasksEnabled && canResume,
         }, instrumentation, unavailable);
-        const resolvedTools = [];
-        const mcpServerAttributions = new Map();
-        const aiProxyFetch = (0, ai_proxy_fetch_1.createAiProxyFetch)(this.outboundHttp);
-        const aiMcpFetch = instrumentation?.mcpFetch ?? (0, ai_proxy_fetch_1.createAiMcpFetch)(this.outboundHttp);
-        const webSearchFetch = (0, ai_proxy_fetch_1.createWebSearchFetch)(this.outboundHttp);
-        const buildMcpClient = async (server) => await (0, mcp_client_factory_1.buildMcpClientForServer)(server, {
+    }
+    makeMcpClientFactory(options, aiMcpFetch, mcpServerAttributions) {
+        const { credentialProvider, projectId, memoryOwnerAgentId, instrumentation } = options;
+        return async (server) => await (0, mcp_client_factory_1.buildMcpClientForServer)(server, {
             credentialProvider,
             oauthService: this.oauthService,
             projectId,
@@ -280,56 +339,6 @@ let AgentRuntimeReconstructionService = class AgentRuntimeReconstructionService
                 }),
             }),
         });
-        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,
-            memoryFactory: this.getMemoryFactory(memoryOwnerAgentId),
-            buildMcpClient,
-            resolveManagedEmbeddingProviderOptions: async () => await this.resolveManagedEmbeddingProviderOptions(projectId),
-            modelFetch: instrumentation?.modelFetch ?? aiProxyFetch,
-            fallbackWebSearch: instrumentation?.webSearch,
-            attachAuthPendingMcpServers: instrumentation?.mcpFetch !== undefined,
-            webSearchFetch,
-            previewChat,
-        });
-        if (unavailable.length > 0) {
-            this.logger.warn('Agent runtime built with unavailable tools', {
-                agentId: memoryOwnerAgentId,
-                runType,
-                tools: unavailable,
-            });
-        }
-        await this.injectRuntimeDependencies({
-            agent: reconstructed,
-            agentId: memoryOwnerAgentId,
-            projectId,
-            credentialProvider,
-            runtimeProfile,
-            runType,
-            workflowToolExecutionMode,
-            config,
-            subAgentDelegation,
-            parentAgentIdForDelegation: parentAgentIdForDelegation ?? memoryOwnerAgentId,
-            integrationType,
-            credentialIntegrations,
-            parentWorkspace,
-            user,
-            instrumentation,
-            sandboxPrincipalHash,
-            backgroundTasksEnabled,
-        });
-        return {
-            agent: reconstructed,
-            toolRegistry: (0, tool_registry_1.buildToolRegistry)(resolvedTools),
-            mcpServerAttributions,
-        };
     }
     async createSubAgentDelegationConfig(config, projectId) {
         const configuredAgents = config.subAgents?.agents ?? [];
@@ -380,172 +389,188 @@ let AgentRuntimeReconstructionService = class AgentRuntimeReconstructionService
         };
     }
     makeToolResolver(runIdentity, instrumentation, unavailable) {
-        const { projectId, workflowToolExecutionMode, usePublishedWorkflowVersion, agentId, integrationType, userId, supportsHitl, backgroundTasksEnabled, } = runIdentity;
         const instrumentToolAdditionalData = instrumentation?.configureToolAdditionalData;
         return async (ref) => {
             if (ref.type === 'workflow') {
-                const { resolveWorkflowTool, buildUnavailableWorkflowTool } = await import('./tools/workflow-tool-factory.js');
-                const context = {
-                    workflowLoader: di_1.Container.get(workflow_tool_workflow_loader_service_1.WorkflowToolWorkflowLoader),
-                    workflowRunner: await getWorkflowRunner(),
-                    subworkflowPolicyChecker: di_1.Container.get(pre_execution_checks_1.SubworkflowPolicyChecker),
-                    activeExecutions: this.activeExecutions,
-                    projectId,
-                    executionMode: workflowToolExecutionMode,
-                    usePublishedWorkflowVersion,
-                    instrumentToolAdditionalData,
-                    agentId,
-                    integrationType,
-                    userId,
-                    supportsHitl,
-                    backgroundTasksEnabled,
-                };
-                try {
-                    return await resolveWorkflowTool(ref, context);
-                }
-                catch (error) {
-                    if (!(error instanceof workflow_tool_unavailable_error_1.WorkflowToolUnavailableError))
-                        throw error;
-                    unavailable.push({
-                        toolName: toolRefName(ref),
-                        toolType: 'workflow',
-                        reason: error.reason,
-                        message: error.message,
-                    });
-                    return buildUnavailableWorkflowTool(ref, context);
-                }
+                return await this.resolveWorkflowTool(ref, runIdentity, instrumentToolAdditionalData, unavailable);
             }
             if (ref.type === 'node') {
                 const { resolveNodeTool } = await import('./tools/node-tool-factory.js');
                 return await resolveNodeTool(ref, {
                     executor: this.ephemeralNodeExecutor,
-                    projectId,
+                    projectId: runIdentity.projectId,
                     instrumentToolAdditionalData,
                 });
             }
             return null;
         };
     }
+    async resolveWorkflowTool(ref, runIdentity, instrumentToolAdditionalData, unavailable) {
+        const { projectId, workflowToolExecutionMode, usePublishedWorkflowVersion, agentId, integrationType, userId, previewChat, publishedN8nChat, supportsHitl, backgroundTasksEnabled, } = runIdentity;
+        const { resolveWorkflowTool, buildUnavailableWorkflowTool } = await import('./tools/workflow-tool-factory.js');
+        const context = {
+            workflowLoader: di_1.Container.get(workflow_tool_workflow_loader_service_1.WorkflowToolWorkflowLoader),
+            workflowRunner: await getWorkflowRunner(),
+            subworkflowPolicyChecker: di_1.Container.get(pre_execution_checks_1.SubworkflowPolicyChecker),
+            activeExecutions: this.activeExecutions,
+            projectId,
+            executionMode: workflowToolExecutionMode,
+            usePublishedWorkflowVersion,
+            instrumentToolAdditionalData,
+            agentId,
+            integrationType,
+            userId,
+            previewChat,
+            publishedN8nChat,
+            supportsHitl,
+            backgroundTasksEnabled,
+        };
+        try {
+            return await resolveWorkflowTool(ref, context);
+        }
+        catch (error) {
+            if (!(error instanceof workflow_tool_unavailable_error_1.WorkflowToolUnavailableError))
+                throw error;
+            unavailable.push({
+                toolName: toolRefName(ref),
+                toolType: 'workflow',
+                reason: error.reason,
+                message: error.message,
+            });
+            return buildUnavailableWorkflowTool(ref, context);
+        }
+    }
     async injectRuntimeDependencies(params) {
-        const { agent, agentId, projectId, credentialProvider, runtimeProfile, runType, workflowToolExecutionMode, config, subAgentDelegation, parentAgentIdForDelegation, integrationType, credentialIntegrations, user, instrumentation, sandboxPrincipalHash, backgroundTasksEnabled, parentWorkspace, } = params;
+        const { agent, agentId, projectId, runtimeProfile, config } = params;
         agent.tool((0, environment_tool_1.createGetEnvironmentTool)());
-        let parentWorkspaceHandle;
-        if (runtimeProfile !== 'inline' && this.agentSandboxRuntimeService.isEnabled()) {
-            if (runtimeProfile === 'sub-agent') {
-                if (parentWorkspace) {
-                    agent.workspace(this.agentWorkspaceService.getDelegatedAgentWorkspace(parentWorkspace.handle, parentWorkspace.delegationThreadId));
-                }
-            }
-            else {
-                if (!sandboxPrincipalHash) {
-                    throw new n8n_workflow_1.UserError('Agent workspace scope is missing and the runtime cannot be reconstructed');
-                }
-                try {
-                    const { workspace, handle } = await this.agentWorkspaceService.getAgentWorkspace(projectId, agentId, sandboxPrincipalHash);
-                    agent.workspace(workspace);
-                    parentWorkspaceHandle = handle;
-                }
-                catch (error) {
-                    this.logger.warn('Failed to attach agent workspace', {
-                        projectId,
-                        agentId,
-                        error: (0, agent_sandbox_runtime_service_1.sanitizeSandboxErrorDetail)(error instanceof Error ? error.message : String(error)),
-                    });
-                }
-            }
-            if (await this.agentFileRepository.hasFilesForAgent(agentId)) {
-                const { createKnowledgeRetrievalTools } = await import('./tools/knowledge/search-knowledge.tool.js');
-                agent.tool(createKnowledgeRetrievalTools({
-                    projectId,
-                    agentId,
-                    knowledgeMirrorService: this.agentKnowledgeMirrorService,
-                }));
-            }
-        }
+        const parentWorkspaceHandle = await this.attachWorkspaceAndKnowledge(params);
         if (runtimeProfile === 'top-level') {
-            const includeN8nChat = integrationType === api_types_1.N8N_CHAT_INTEGRATION_TYPE;
-            if (credentialIntegrations.length > 0 || includeN8nChat) {
-                const integrationRegistry = di_1.Container.get(agent_chat_integration_1.ChatIntegrationRegistry);
-                const { messageContextStore, actionExecutor, queryExecutor } = await getChatIntegrationToolServices();
-                const descriptors = (0, integration_tools_1.getIntegrationToolConnectionDescriptors)(credentialIntegrations, agentId, (integrationConfig) => {
-                    const integrationDef = integrationRegistry.get(integrationConfig.type);
-                    return {
-                        contextToolDefinitions: integrationDef?.contextToolDefinitions,
-                        actionToolDefinitions: integrationDef?.actionToolDefinitions,
-                        contextQueries: integrationDef?.contextQueries,
-                        actions: integrationDef?.actions,
-                        contextToolGuidance: integrationDef?.contextToolGuidance,
-                        actionToolGuidance: integrationDef?.actionToolGuidance,
-                    };
-                });
-                if (includeN8nChat) {
-                    const n8nChat = integrationRegistry.require(api_types_1.N8N_CHAT_INTEGRATION_TYPE);
-                    const n8nChatIntegration = {
-                        type: api_types_1.N8N_CHAT_INTEGRATION_TYPE,
-                    };
-                    descriptors.push({
-                        agentId,
-                        integration: n8nChatIntegration,
-                        integrationConnectionId: api_types_1.N8N_CHAT_INTEGRATION_TYPE,
-                        contextToolName: api_types_1.N8N_CHAT_CONTEXT_TOOL_NAME,
-                        actionToolName: api_types_1.N8N_CHAT_ACTION_TOOL_NAME,
-                        contextQueries: [...n8nChat.contextQueries],
-                        actions: [...n8nChat.actions],
-                        contextToolDefinitions: [...n8nChat.contextToolDefinitions],
-                        actionToolDefinitions: [...n8nChat.actionToolDefinitions],
-                        contextToolGuidance: n8nChat.contextToolGuidance,
-                        actionToolGuidance: n8nChat.actionToolGuidance,
-                    });
-                }
-                for (const descriptor of descriptors) {
-                    agent.tool((0, integration_tools_1.createIntegrationContextTool)({ descriptor, queryExecutor }));
-                    agent.tool((0, integration_tools_1.createIntegrationActionTool)({ descriptor, messageContextStore, actionExecutor }));
-                }
+            await this.attachIntegrationTools(params);
+            await this.attachTopLevelTools(params, parentWorkspaceHandle);
+        }
+        if (runtimeProfile === 'inline')
+            return;
+        if (!agent.hasCheckpointStorage()) {
+            agent.checkpoint(this.n8nCheckpointStorage.getStorage(agentId));
+        }
+        agent.fileStore(this.agentChatAttachmentService.getFileStore({ agentId, projectId }, (0, agent_config_1.getProviderPrefix)(config.model)));
+    }
+    async attachWorkspaceAndKnowledge(params) {
+        if (params.runtimeProfile === 'inline' || !this.agentSandboxRuntimeService.isEnabled())
+            return undefined;
+        const parentWorkspaceHandle = await this.attachWorkspace(params);
+        const { agent, agentId, projectId } = params;
+        if (await this.agentFileRepository.hasFilesForAgent(agentId)) {
+            const { createKnowledgeRetrievalTools } = await import('./tools/knowledge/search-knowledge.tool.js');
+            agent.tool(createKnowledgeRetrievalTools({
+                projectId,
+                agentId,
+                knowledgeMirrorService: this.agentKnowledgeMirrorService,
+            }));
+        }
+        return parentWorkspaceHandle;
+    }
+    async attachWorkspace(params) {
+        const { agent, agentId, projectId, runtimeProfile, parentWorkspace, sandboxPrincipalHash } = params;
+        if (runtimeProfile === 'sub-agent') {
+            if (parentWorkspace) {
+                agent.workspace(this.agentWorkspaceService.getDelegatedAgentWorkspace(parentWorkspace.handle, parentWorkspace.delegationThreadId));
             }
+            return undefined;
         }
-        if (runtimeProfile === 'top-level') {
-            await this.attachSubAgentDelegationTool({
-                agent,
-                config,
-                parentAgentId: parentAgentIdForDelegation,
+        if (!sandboxPrincipalHash) {
+            throw new n8n_workflow_1.UserError('Agent workspace scope is missing and the runtime cannot be reconstructed');
+        }
+        try {
+            const { workspace, handle } = await this.agentWorkspaceService.getAgentWorkspace(projectId, agentId, sandboxPrincipalHash);
+            agent.workspace(workspace);
+            return handle;
+        }
+        catch (error) {
+            this.logger.warn('Failed to attach agent workspace', {
                 projectId,
-                credentialProvider,
-                runType,
-                workflowToolExecutionMode,
-                delegation: subAgentDelegation,
-                parentWorkspaceHandle,
-                user,
-                instrumentation,
+                agentId,
+                error: (0, agent_sandbox_runtime_service_1.sanitizeSandboxErrorDetail)(error instanceof Error ? error.message : String(error)),
             });
-            this.attachWriteTodosTool(agent, agentId);
-            if (backgroundTasksEnabled) {
-                await this.attachBackgroundJobTools({
-                    agent,
-                    parentAgentId: parentAgentIdForDelegation,
-                    projectId,
-                    credentialProvider,
-                    runType,
-                    workflowToolExecutionMode,
-                    delegation: subAgentDelegation,
-                    user,
-                    instrumentation,
-                    ...(parentWorkspaceHandle !== undefined ? { parentWorkspaceHandle } : {}),
-                });
-                agent.volatileInstructionsProvider(async ({ persistence }) => {
-                    if (!persistence?.threadId)
-                        return undefined;
-                    const { AgentWakeService } = await import('./background/agent-wake.service.js');
-                    return await di_1.Container.get(AgentWakeService).getBackgroundUpdates(persistence.threadId, persistence.resourceId);
-                });
-            }
         }
-        if (runtimeProfile !== 'inline' && !agent.hasCheckpointStorage()) {
-            agent.checkpoint(this.n8nCheckpointStorage.getStorage(agentId));
+        return undefined;
+    }
+    async attachIntegrationTools(params) {
+        const { agent, agentId, integrationType, credentialIntegrations } = params;
+        const includeN8nChat = integrationType === api_types_1.N8N_CHAT_INTEGRATION_TYPE;
+        if (credentialIntegrations.length === 0 && !includeN8nChat)
+            return;
+        const integrationRegistry = di_1.Container.get(agent_chat_integration_1.ChatIntegrationRegistry);
+        const { messageContextStore, actionExecutor, queryExecutor } = await getChatIntegrationToolServices();
+        const descriptors = this.createIntegrationDescriptors(agentId, credentialIntegrations.filter(api_types_1.isCredentialAgentIntegration), integrationRegistry);
+        if (includeN8nChat) {
+            descriptors.push(this.createN8nChatDescriptor(agentId, integrationRegistry));
         }
-        if (runtimeProfile !== 'inline') {
-            agent.fileStore(this.agentChatAttachmentService.getFileStore({ agentId, projectId }, (0, agent_config_1.getProviderPrefix)(config.model)));
+        for (const descriptor of descriptors) {
+            agent.tool((0, integration_tools_1.createIntegrationContextTool)({ descriptor, queryExecutor }));
+            agent.tool((0, integration_tools_1.createIntegrationActionTool)({ descriptor, messageContextStore, actionExecutor }));
         }
     }
+    createIntegrationDescriptors(agentId, credentialIntegrations, integrationRegistry) {
+        return (0, integration_tools_1.getIntegrationToolConnectionDescriptors)(credentialIntegrations, agentId, (integrationConfig) => {
+            const integrationDef = integrationRegistry.get(integrationConfig.type);
+            return {
+                contextToolDefinitions: integrationDef?.contextToolDefinitions,
+                actionToolDefinitions: integrationDef?.actionToolDefinitions,
+                contextQueries: integrationDef?.contextQueries,
+                actions: integrationDef?.actions,
+                contextToolGuidance: integrationDef?.contextToolGuidance,
+                actionToolGuidance: integrationDef?.actionToolGuidance,
+            };
+        });
+    }
+    createN8nChatDescriptor(agentId, integrationRegistry) {
+        const n8nChat = integrationRegistry.require(api_types_1.N8N_CHAT_INTEGRATION_TYPE);
+        const n8nChatIntegration = {
+            type: api_types_1.N8N_CHAT_INTEGRATION_TYPE,
+        };
+        return {
+            agentId,
+            integration: n8nChatIntegration,
+            integrationConnectionId: api_types_1.N8N_CHAT_INTEGRATION_TYPE,
+            contextToolName: api_types_1.N8N_CHAT_CONTEXT_TOOL_NAME,
+            actionToolName: api_types_1.N8N_CHAT_ACTION_TOOL_NAME,
+            contextQueries: [...n8nChat.contextQueries],
+            actions: [...n8nChat.actions],
+            contextToolDefinitions: [...n8nChat.contextToolDefinitions],
+            actionToolDefinitions: [...n8nChat.actionToolDefinitions],
+            contextToolGuidance: n8nChat.contextToolGuidance,
+            actionToolGuidance: n8nChat.actionToolGuidance,
+        };
+    }
+    async attachTopLevelTools(params, parentWorkspaceHandle) {
+        const { agent, agentId, config, parentAgentIdForDelegation, projectId, credentialProvider, runType, workflowToolExecutionMode, subAgentDelegation, user, instrumentation, backgroundTasksEnabled, } = params;
+        const delegationParams = {
+            agent,
+            parentAgentId: parentAgentIdForDelegation,
+            projectId,
+            credentialProvider,
+            runType,
+            workflowToolExecutionMode,
+            delegation: subAgentDelegation,
+            user,
+            instrumentation,
+        };
+        await this.attachSubAgentDelegationTool({ ...delegationParams, config, parentWorkspaceHandle });
+        this.attachWriteTodosTool(agent, agentId);
+        if (!backgroundTasksEnabled)
+            return;
+        await this.attachBackgroundJobTools({
+            ...delegationParams,
+            ...(parentWorkspaceHandle !== undefined ? { parentWorkspaceHandle } : {}),
+        });
+        agent.volatileInstructionsProvider(async ({ persistence }) => {
+            if (!persistence?.threadId)
+                return undefined;
+            const { AgentWakeService } = await import('./background/agent-wake.service.js');
+            return await di_1.Container.get(AgentWakeService).getBackgroundUpdates(persistence.threadId, persistence.resourceId);
+        });
+    }
     async attachSubAgentDelegationTool(params) {
         const { agent, config, parentAgentId, projectId, credentialProvider, runType, workflowToolExecutionMode, delegation, parentWorkspaceHandle, user, instrumentation, } = params;
         const inlineSubAgentModelsByDifficulty = await this.resolveInlineSubAgentModelsByDifficulty(config, credentialProvider);