n8n 2.41.4 → 2.42.1

package/dist/modules/agents/agent-execution-orchestrator.service.js

@@ -10,16 +10,17 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AgentExecutionOrchestratorService = void 0;
-const agents_1 = require("@n8n/agents");
 const api_types_1 = require("@n8n/api-types");
 const backend_common_1 = require("@n8n/backend-common");
 const config_1 = require("@n8n/config");
 const di_1 = require("@n8n/di");
-const is_record_1 = require("@n8n/utils/is-record");
 const n8n_workflow_1 = require("n8n-workflow");
 const external_hooks_1 = require("../../external-hooks");
 const telemetry_1 = require("../../telemetry");
 const agent_execution_service_1 = require("./agent-execution.service");
+const agent_chat_execution_service_1 = require("./agent-chat-execution.service");
+const agent_memory_scope_1 = require("./utils/agent-memory-scope");
+const agent_thread_access_1 = require("./utils/agent-thread-access");
 const agent_run_tracing_service_1 = require("./agent-run-tracing.service");
 const agent_runtime_cache_service_1 = require("./agent-runtime-cache.service");
 const agent_sandbox_principal_1 = require("./agent-sandbox-principal");
@@ -36,47 +37,8 @@ const agent_execution_counter_1 = require("./utils/agent-execution-counter");
 const agent_published_snapshot_1 = require("./utils/agent-published-snapshot");
 const inbound_attachments_1 = require("./utils/inbound-attachments");
 const execution_to_message_mapper_1 = require("./utils/execution-to-message-mapper");
-function getDelegatedChildCheckpoints(checkpoint, parentAgentId) {
-    const childCheckpoints = [];
-    const seen = new Set();
-    for (const pendingToolCall of Object.values(checkpoint.pendingToolCalls)) {
-        if (!pendingToolCall.suspended)
-            continue;
-        const childCheckpoint = (0, agents_1.parseDelegateSubAgentContinuation)(pendingToolCall.continuation);
-        if (!childCheckpoint)
-            continue;
-        let ownerAgentId;
-        if (childCheckpoint.resumeContext === undefined) {
-            if (childCheckpoint.subAgentId !== agents_1.INLINE_SUB_AGENT_ID)
-                continue;
-            ownerAgentId = parentAgentId;
-        }
-        else {
-            if (!(0, is_record_1.isRecord)(childCheckpoint.resumeContext) ||
-                typeof childCheckpoint.resumeContext.agentId !== 'string' ||
-                childCheckpoint.resumeContext.agentId.length === 0 ||
-                (childCheckpoint.resumeContext.versionId !== undefined &&
-                    (typeof childCheckpoint.resumeContext.versionId !== 'string' ||
-                        childCheckpoint.resumeContext.versionId.length === 0))) {
-                continue;
-            }
-            const expectedOwnerAgentId = childCheckpoint.subAgentId === agents_1.INLINE_SUB_AGENT_ID
-                ? parentAgentId
-                : childCheckpoint.subAgentId;
-            if (childCheckpoint.resumeContext.agentId !== expectedOwnerAgentId)
-                continue;
-            ownerAgentId = expectedOwnerAgentId;
-        }
-        const identity = `${ownerAgentId}\0${childCheckpoint.runId}`;
-        if (seen.has(identity))
-            continue;
-        seen.add(identity);
-        childCheckpoints.push({ runId: childCheckpoint.runId, agentId: ownerAgentId });
-    }
-    return childCheckpoints;
-}
 let AgentExecutionOrchestratorService = class AgentExecutionOrchestratorService {
-    constructor(logger, n8nCheckpointStorage, agentExecutionService, turnExecutionService, telemetry, runtimeCacheService, integrationMessageContextService, agentRunTracingService, externalHooks, agentSandboxRuntimeService, agentRepository, aiConfig) {
+    constructor(logger, n8nCheckpointStorage, agentExecutionService, turnExecutionService, telemetry, runtimeCacheService, integrationMessageContextService, agentRunTracingService, externalHooks, agentSandboxRuntimeService, agentRepository, aiConfig, chatExecutionService) {
         this.logger = logger;
         this.n8nCheckpointStorage = n8nCheckpointStorage;
         this.agentExecutionService = agentExecutionService;
@@ -89,37 +51,31 @@ let AgentExecutionOrchestratorService = class AgentExecutionOrchestratorService
         this.agentSandboxRuntimeService = agentSandboxRuntimeService;
         this.agentRepository = agentRepository;
         this.aiConfig = aiConfig;
+        this.chatExecutionService = chatExecutionService;
+    }
+    async getSessionMode(threadId) {
+        return await this.agentExecutionService.getSessionMode(threadId);
     }
     async getConversationHistory(params) {
-        const { threadId, projectId, agentId } = params;
-        const detail = await this.agentExecutionService.getThreadDetail(threadId, projectId, agentId);
+        const { threadId, projectId, agentId, userId } = params;
+        const detail = await this.agentExecutionService.getThreadDetail(threadId, projectId, agentId, userId);
         if (!detail)
             return null;
-        return (0, execution_to_message_mapper_1.executionsToMessagesDto)(detail.executions);
+        return {
+            messages: (0, execution_to_message_mapper_1.executionsToMessagesDto)(detail.executions),
+            activeExecutionId: detail.executions.findLast((execution) => execution.status === 'running')?.id ?? null,
+        };
     }
     async cancelChatRun(params) {
-        const checkpointStatus = await this.n8nCheckpointStorage.getStatus(params.runId, params.agentId);
-        if (checkpointStatus.status === 'not-found' || checkpointStatus.checkpoint === undefined) {
-            return false;
-        }
-        const { checkpoint } = checkpointStatus;
-        if (checkpoint.status !== 'suspended' ||
-            checkpoint.persistence?.delegated === true ||
-            checkpoint.persistence?.resourceId !== params.resourceId) {
-            return false;
-        }
-        const childCheckpoints = getDelegatedChildCheckpoints(checkpoint, params.agentId);
-        if (checkpointStatus.status === 'active') {
-            const cancelled = await this.n8nCheckpointStorage.cancelSuspended(params.runId, checkpoint, params.agentId);
-            if (!cancelled)
-                return false;
-        }
-        await Promise.all(childCheckpoints.map(async ({ runId, agentId }) => await this.n8nCheckpointStorage.delete(runId, agentId)));
-        await this.n8nCheckpointStorage.delete(params.runId, params.agentId);
-        return true;
+        return await this.chatExecutionService.cancelSuspended(params);
+    }
+    async loadResumeCheckpoint(config) {
+        const memoryScope = await this.loadResumeMemory(config);
+        const access = await this.resolveResumeAccess(config, memoryScope);
+        const sandboxPrincipalHash = this.validateResumeSandbox(config, memoryScope);
+        return { memoryScope, sandboxPrincipalHash, access };
     }
-    async loadResumeCheckpoint(params) {
-        const { agentId, projectId, runId, expectedMemory, user, usePublishedVersion } = params;
+    async loadResumeMemory({ agentId, runId, expectedMemory }) {
         const checkpointStatus = await this.n8nCheckpointStorage.getStatus(runId, agentId);
         if (checkpointStatus.status === 'expired') {
             throw new n8n_workflow_1.UserError(`Checkpoint ${runId} is expired and cannot be resumed`);
@@ -140,203 +96,182 @@ let AgentExecutionOrchestratorService = class AgentExecutionOrchestratorService
                 memoryScope.resourceId !== expectedMemory.resourceId)) {
             throw new n8n_workflow_1.UserError(`Checkpoint ${runId} does not belong to this chat`);
         }
+        return memoryScope;
+    }
+    async resolveResumeAccess({ agentId, projectId, runId, user, usePublishedVersion, previewChat, source }, memoryScope) {
+        const isPreview = !usePublishedVersion && !(0, agent_memory_scope_1.isTaskRunMemoryResourceId)(memoryScope.resourceId);
+        const isProductionChat = source === agent_thread_access_1.N8N_CHAT_PRODUCTION_SOURCE;
+        let access = { accessScope: 'project', ownerId: null };
+        if (isPreview || isProductionChat) {
+            if (!user ||
+                memoryScope.resourceId !==
+                    (isPreview
+                        ? (0, agent_memory_scope_1.draftChatMemoryResourceId)(user.id)
+                        : (0, agent_memory_scope_1.productionChatMemoryResourceId)(user.id)) ||
+                (isPreview
+                    ? !(await this.agentExecutionService.canUseDraftThread(memoryScope.threadId, projectId, agentId, user.id, { previewChat, sessionMode: 'existing' }))
+                    : !(await this.agentExecutionService.canUseProductionChatThread(memoryScope.threadId, projectId, agentId, user.id, 'existing')))) {
+                throw new n8n_workflow_1.UserError(`Checkpoint ${runId} does not belong to this chat`);
+            }
+            access = { accessScope: 'user', ownerId: user.id };
+        }
+        else {
+            const thread = await this.agentExecutionService.findThreadById(memoryScope.threadId);
+            if ((0, agent_memory_scope_1.userIdFromDraftChatMemoryResourceId)(memoryScope.resourceId) ||
+                (0, agent_memory_scope_1.userIdFromProductionChatMemoryResourceId)(memoryScope.resourceId) ||
+                !thread ||
+                thread.projectId !== projectId ||
+                thread.agentId !== agentId ||
+                thread.accessScope !== 'project') {
+                throw new n8n_workflow_1.UserError(`Checkpoint ${runId} does not belong to this chat`);
+            }
+        }
+        return access;
+    }
+    validateResumeSandbox({ projectId, runId, user, usePublishedVersion, source }, memoryScope) {
         const sandboxScope = (0, agent_sandbox_principal_1.decodeAgentSandboxHostMetadata)(memoryScope.hostMetadata);
         const sandboxPrincipalHash = sandboxScope?.principalHash;
-        if (this.agentSandboxRuntimeService.isEnabled() &&
+        if ((this.agentSandboxRuntimeService.isEnabled() || source === agent_thread_access_1.N8N_CHAT_PRODUCTION_SOURCE) &&
             (!sandboxScope ||
                 sandboxScope.projectId !== projectId ||
                 !sandboxPrincipalHash ||
-                (!usePublishedVersion &&
+                ((!usePublishedVersion || source === agent_thread_access_1.N8N_CHAT_PRODUCTION_SOURCE) &&
                     (!user ||
                         sandboxPrincipalHash !==
                             (0, agent_sandbox_principal_1.hashAgentSandboxPrincipal)({ type: 'n8n-user', userId: user.id }))))) {
             throw new n8n_workflow_1.UserError(`Checkpoint ${runId} is unavailable and cannot be resumed`);
         }
-        return { memoryScope, sandboxPrincipalHash };
+        return sandboxPrincipalHash;
     }
     async *resumeForChat(config) {
-        const { agentId, projectId, runId, toolCallId, resumeData, expectedMemory, source, integrationType, user, usePublishedVersion = true, onExecutionRecorded, abortSignal, } = config;
-        const { memoryScope, sandboxPrincipalHash } = await this.loadResumeCheckpoint({
-            agentId,
-            projectId,
-            runId,
-            expectedMemory,
-            user,
-            usePublishedVersion,
-        });
-        const threadId = memoryScope.threadId;
-        yield* this.withRuntimeLease(async () => await this.getRuntimeOrRecordFailure({
-            agentId,
-            projectId,
-            usePublishedVersion,
-            integrationType,
-            user: usePublishedVersion ? undefined : user,
-            ...(sandboxPrincipalHash ? { sandboxPrincipalHash } : {}),
-            previewChat: config.previewChat,
-        }, { threadId, userMessage: null, source, onExecutionRecorded, abortSignal }), (runtime) => this.turnExecutionService.execute({
-            agentInstance: runtime.agent,
-            toolRegistry: runtime.toolRegistry,
-            mcpServerAttributions: runtime.mcpServerAttributions,
-            context: { projectId, agentId, threadId },
-            includeHitlToolDetails: !usePublishedVersion,
-            onExecutionRecorded,
-            onSettled: async (suspended) => {
-                if (!suspended)
-                    await this.requestPendingBackgroundWake(threadId);
-            },
-            prepare: async () => {
-                const suspendedExecution = this.agentRunTracingService.enabled && source === undefined
-                    ? await this.agentExecutionService.findLatestSuspendedRun(threadId)
-                    : undefined;
-                const executionSource = source ?? suspendedExecution?.source ?? undefined;
-                const runType = usePublishedVersion ? 'production' : 'test';
-                const tracing = await this.agentRunTracingService.build({
-                    agentId,
-                    projectId,
-                    threadId,
-                    userId: user?.id,
-                    source: executionSource ?? 'unknown',
-                    modelId: (0, agent_run_tracing_service_1.modelIdFromSnapshot)(runtime.agent.snapshot.model),
-                });
-                let messageContext = config.messageContext;
-                if (messageContext === undefined) {
-                    messageContext =
-                        await this.integrationMessageContextService.getForResume(memoryScope);
-                }
-                else if (messageContext && config.contextConversation) {
-                    messageContext = (0, integration_message_context_1.inheritIntegrationMessageContext)(messageContext, await this.integrationMessageContextService.getForResume(memoryScope));
-                }
-                const selectedContext = messageContext;
-                const conversation = config.contextConversation;
-                return {
-                    type: 'resume',
-                    resumeData,
-                    options: {
-                        runId,
-                        toolCallId,
-                        hostMetadata: (0, integration_message_context_1.encodeIntegrationMessageContext)(selectedContext),
-                        ...(selectedContext && conversation
-                            ? {
-                                onResumeClaimed: async () => await this.integrationMessageContextService.installIncoming(selectedContext, memoryScope, conversation),
-                            }
-                            : {}),
-                        executionCounter: (0, agent_execution_counter_1.createAgentExecutionCounter)(this.telemetry, {
-                            agentId,
-                            userId: user?.id,
-                            runType,
-                        }),
-                        ...(0, model_stream_stall_options_1.modelStreamStallOptions)(this.aiConfig),
-                        ...(tracing ? { telemetry: tracing } : {}),
-                        ...(abortSignal ? { abortSignal } : {}),
-                    },
-                    recording: {
-                        threadId,
-                        agentId,
-                        agentName: runtime.agent.name,
-                        projectId,
-                        userMessage: null,
-                        ...(executionSource !== undefined ? { source: executionSource } : {}),
-                        telemetry: {
-                            userId: user?.id,
-                            runType,
-                            configuration: runtime.telemetryConfiguration,
-                        },
-                    },
-                };
-            },
-        }));
+        const resume = { ...config, usePublishedVersion: config.usePublishedVersion ?? true };
+        if (resume.source === agent_thread_access_1.N8N_CHAT_PRODUCTION_SOURCE &&
+            !(await this.agentRepository.isN8nChatPublished(resume.agentId, resume.projectId))) {
+            throw new n8n_workflow_1.UserError('This agent is not available in n8n Chat');
+        }
+        const checkpoint = await this.loadResumeCheckpoint(resume);
+        yield* this.withRuntimeLease(async () => await this.getResumeRuntime(resume, checkpoint), (runtime) => this.resumeRuntimeTurn(resume, checkpoint, runtime));
     }
     async *executeForChat(config) {
-        const { agentId, projectId, message, user, memory, attachments, source, previewChat, onExecutionRecorded, abortSignal, } = config;
+        const draft = { ...config, sessionMode: config.sessionMode ?? 'new' };
         const sandboxPrincipalHash = (0, agent_sandbox_principal_1.hashAgentSandboxPrincipal)({
             type: 'n8n-user',
-            userId: user.id,
+            userId: config.user.id,
         });
+        await this.assertDraftChatAccess(draft);
+        const access = { accessScope: 'user', ownerId: config.user.id };
+        yield* this.withRuntimeLease(async () => await this.getDraftChatRuntime(draft, access, sandboxPrincipalHash), async (runtime) => await this.streamDraftChatResponse(draft, runtime, access, sandboxPrincipalHash));
+    }
+    async *executeForChatPublished(config) {
+        const { agentId, projectId, message, modelMessage, author, memory, integrationType, attachments, sandboxPrincipalHash, sessionMode = 'new', } = config;
+        await this.externalHooks.run('agent.preExecute', [agentId]);
         yield* this.withRuntimeLease(async () => await this.getRuntimeOrRecordFailure({
             agentId,
             projectId,
-            integrationType: api_types_1.N8N_CHAT_INTEGRATION_TYPE,
-            user,
+            integrationType,
+            usePublishedVersion: true,
             sandboxPrincipalHash,
-            previewChat,
         }, {
             threadId: memory.threadId,
+            resourceId: memory.resourceId,
             userMessage: message,
+            author,
             attachments,
-            source,
-            onExecutionRecorded,
-            abortSignal,
+            messageOrigin: {
+                integrationConnectionId: config.messageContext?.integrationConnectionId,
+                platformMessageId: config.messageContext?.messageId,
+            },
+            source: integrationType,
+            access: { accessScope: 'project', ownerId: null },
+            sessionMode,
+            admittedExecution: config.admittedExecution,
         }), async (runtime) => {
-            const messageContext = {
-                integrationConnectionId: api_types_1.N8N_CHAT_INTEGRATION_TYPE,
-                platform: api_types_1.N8N_CHAT_INTEGRATION_TYPE,
-                target: { type: 'dm', userId: user.id, threadId: memory.threadId },
-                interactingUserId: user.id,
-                updatedAt: new Date().toISOString(),
-            };
-            await this.integrationMessageContextService.setLatest(memory.threadId, memory.resourceId, messageContext);
+            let messageContext = config.messageContext;
+            if (messageContext && config.contextConversation) {
+                messageContext = (0, integration_message_context_1.inheritIntegrationMessageContext)(messageContext, await this.integrationMessageContextService.getLatestForIncoming(memory.threadId));
+            }
+            const selectedContext = messageContext;
+            const conversation = config.contextConversation;
             return this.streamChatResponse({
+                admittedExecution: config.admittedExecution,
+                abortSignal: config.abortSignal,
+                onAdmitted: selectedContext && conversation
+                    ? async () => await this.integrationMessageContextService.installIncoming(selectedContext, memory, conversation)
+                    : undefined,
                 messageContext,
+                access: { accessScope: 'project', ownerId: null },
                 agentInstance: runtime.agent,
                 toolRegistry: runtime.toolRegistry,
                 mcpServerAttributions: runtime.mcpServerAttributions,
                 agentId,
-                userId: user.id,
                 message,
+                modelMessage,
+                author,
                 attachments,
                 memory,
                 projectId: runtime.projectId,
-                source,
+                source: integrationType,
                 telemetry: {
-                    runType: 'test',
+                    runType: 'production',
                     configuration: runtime.telemetryConfiguration,
                 },
-                onExecutionRecorded,
-                abortSignal,
-                includeHitlToolDetails: true,
                 sandboxPrincipalHash,
+                sessionMode,
             });
         });
     }
-    async *executeForChatPublished(config) {
-        const { agentId, projectId, message, modelMessage, author, memory, integrationType, attachments, sandboxPrincipalHash, } = config;
+    async *executeForN8nChatPublished(config) {
+        const { agentId, projectId, message, memory, attachments, user, abortSignal, sessionMode = 'new', } = config;
+        if (!(await this.agentRepository.isN8nChatPublished(agentId, projectId))) {
+            throw new n8n_workflow_1.UserError('This agent is not available in n8n Chat');
+        }
+        if (memory.resourceId !== (0, agent_memory_scope_1.productionChatMemoryResourceId)(user.id) ||
+            !(await this.agentExecutionService.canUseProductionChatThread(memory.threadId, projectId, agentId, user.id, sessionMode))) {
+            throw new n8n_workflow_1.UserError('Session not found');
+        }
+        const sandboxPrincipalHash = (0, agent_sandbox_principal_1.hashAgentSandboxPrincipal)({ type: 'n8n-user', userId: user.id });
         await this.externalHooks.run('agent.preExecute', [agentId]);
         yield* this.withRuntimeLease(async () => await this.getRuntimeOrRecordFailure({
             agentId,
             projectId,
-            integrationType,
+            integrationType: api_types_1.N8N_CHAT_INTEGRATION_TYPE,
             usePublishedVersion: true,
             sandboxPrincipalHash,
+            allowBackgroundTasks: false,
+            attributionUserId: user.id,
         }, {
             threadId: memory.threadId,
+            resourceId: memory.resourceId,
             userMessage: message,
-            author,
             attachments,
-            source: integrationType,
+            source: agent_thread_access_1.N8N_CHAT_PRODUCTION_SOURCE,
+            access: { accessScope: 'user', ownerId: user.id },
+            sessionMode,
+            abortSignal,
         }), async (runtime) => {
-            let messageContext = config.messageContext;
-            if (messageContext && config.contextConversation) {
-                messageContext = (0, integration_message_context_1.inheritIntegrationMessageContext)(messageContext, await this.integrationMessageContextService.getLatestForIncoming(memory.threadId));
-                await this.integrationMessageContextService.installIncoming(messageContext, memory, config.contextConversation);
-            }
+            const messageContext = this.createN8nChatMessageContext(memory, user.id);
             return this.streamChatResponse({
+                access: { accessScope: 'user', ownerId: user.id },
                 messageContext,
+                onAdmitted: async () => await this.integrationMessageContextService.setLatest(memory.threadId, memory.resourceId, messageContext),
                 agentInstance: runtime.agent,
                 toolRegistry: runtime.toolRegistry,
                 mcpServerAttributions: runtime.mcpServerAttributions,
                 agentId,
+                projectId,
                 message,
-                modelMessage,
-                author,
-                attachments,
                 memory,
-                projectId: runtime.projectId,
-                source: integrationType,
-                telemetry: {
-                    runType: 'production',
-                    configuration: runtime.telemetryConfiguration,
-                },
+                attachments,
+                userId: user.id,
+                productionN8nChat: true,
+                source: agent_thread_access_1.N8N_CHAT_PRODUCTION_SOURCE,
+                telemetry: { runType: 'production', configuration: runtime.telemetryConfiguration },
+                includeHitlToolDetails: true,
                 sandboxPrincipalHash,
+                sessionMode,
+                abortSignal,
+                onExecutionStarted: config.onExecutionStarted,
+                onExecutionRecorded: config.onExecutionRecorded,
             });
         });
     }
@@ -353,10 +288,12 @@ let AgentExecutionOrchestratorService = class AgentExecutionOrchestratorService
             allowBackgroundTasks: false,
         }, {
             threadId: memory.threadId,
+            resourceId: memory.resourceId,
             userMessage: message,
             source: 'task',
             taskId,
             taskVersionId,
+            access: { accessScope: 'project', ownerId: null },
         }), (runtime) => this.streamChatResponse({
             agentInstance: runtime.agent,
             toolRegistry: runtime.toolRegistry,
@@ -368,6 +305,7 @@ let AgentExecutionOrchestratorService = class AgentExecutionOrchestratorService
             source: 'task',
             taskId,
             taskVersionId,
+            access: { accessScope: 'project', ownerId: null },
             telemetry: {
                 runType: 'production',
                 configuration: runtime.telemetryConfiguration,
@@ -387,7 +325,14 @@ let AgentExecutionOrchestratorService = class AgentExecutionOrchestratorService
             user,
             sandboxPrincipalHash,
             allowBackgroundTasks: false,
-        }, { threadId: memory.threadId, userMessage: message, source: 'task', taskId }), (runtime) => this.streamChatResponse({
+        }, {
+            threadId: memory.threadId,
+            resourceId: memory.resourceId,
+            userMessage: message,
+            source: 'task',
+            taskId,
+            access: { accessScope: 'project', ownerId: null },
+        }), (runtime) => this.streamChatResponse({
             agentInstance: runtime.agent,
             toolRegistry: runtime.toolRegistry,
             mcpServerAttributions: runtime.mcpServerAttributions,
@@ -398,6 +343,7 @@ let AgentExecutionOrchestratorService = class AgentExecutionOrchestratorService
             projectId: runtime.projectId,
             source: 'task',
             taskId,
+            access: { accessScope: 'project', ownerId: null },
             telemetry: {
                 runType: 'test',
                 configuration: runtime.telemetryConfiguration,
@@ -406,48 +352,40 @@ let AgentExecutionOrchestratorService = class AgentExecutionOrchestratorService
         }));
     }
     async executeForWake(config) {
-        const { agentId, projectId, message, memory, identity, abortSignal } = config;
+        const { agentId, memory, identity, abortSignal } = config;
         const isDraft = identity.type === 'draft';
-        if (!isDraft)
+        const productionUserId = isDraft
+            ? undefined
+            : (0, agent_memory_scope_1.userIdFromProductionChatMemoryResourceId)(memory.resourceId);
+        if (productionUserId &&
+            (isDraft ||
+                identity.integrationType !== api_types_1.N8N_CHAT_INTEGRATION_TYPE ||
+                identity.principalHash !==
+                    (0, agent_sandbox_principal_1.hashAgentSandboxPrincipal)({ type: 'n8n-user', userId: productionUserId }) ||
+                !(await this.agentRepository.isN8nChatPublished(agentId, config.projectId)) ||
+                !(await this.agentExecutionService.canUseProductionChatThread(memory.threadId, config.projectId, agentId, productionUserId, 'existing'))))
+            return;
+        const access = isDraft
+            ? { accessScope: 'user', ownerId: identity.user.id }
+            : productionUserId
+                ? { accessScope: 'user', ownerId: productionUserId }
+                : { accessScope: 'project', ownerId: null };
+        if (isDraft) {
+            await this.assertDraftChatAccess({ ...config, user: identity.user, sessionMode: 'existing' });
+        }
+        else {
             await this.externalHooks.run('agent.preExecute', [agentId]);
+        }
         const integrationType = isDraft ? api_types_1.N8N_CHAT_INTEGRATION_TYPE : identity.integrationType;
         const messageContext = await this.integrationMessageContextService.getLatest(memory.threadId);
-        const delivery = isDraft
+        const delivery = isDraft || productionUserId
             ? undefined
             : await this.getWakeDelivery(agentId, integrationType, messageContext);
-        const stream = this.withRuntimeLease(async () => await this.getRuntimeOrRecordFailure({
-            agentId,
-            projectId,
-            integrationType,
-            usePublishedVersion: !isDraft,
-            ...(isDraft ? { user: identity.user } : {}),
-            sandboxPrincipalHash: identity.principalHash,
-        }, { threadId: memory.threadId, userMessage: null, source: integrationType, abortSignal }), (runtime) => this.streamWakeResponse(this.streamChatResponse({
-            messageContext,
-            agentInstance: runtime.agent,
-            toolRegistry: runtime.toolRegistry,
-            mcpServerAttributions: runtime.mcpServerAttributions,
-            agentId,
-            ...(isDraft ? { userId: identity.user.id } : {}),
-            message,
-            memory,
-            projectId: runtime.projectId,
-            source: integrationType,
-            telemetry: {
-                runType: isDraft ? 'test' : 'production',
-                configuration: runtime.telemetryConfiguration,
-            },
-            abortSignal,
-            includeHitlToolDetails: isDraft,
-            sandboxPrincipalHash: identity.principalHash,
-            hideUserMessageFromTranscript: true,
-            isWakeRun: true,
-            backgroundJobSignal: config.backgroundJobSignal,
-        }), abortSignal, delivery));
+        const stream = this.withRuntimeLease(async () => await this.getWakeRuntime(config, access, integrationType, productionUserId), (runtime) => this.streamWakeResponse(this.streamWakeTurn(config, runtime, access, integrationType, messageContext, productionUserId), abortSignal, delivery, messageContext?.interactingUserId));
         for await (const _chunk of stream) {
         }
     }
-    async *streamWakeResponse(stream, abortSignal, delivery) {
+    async *streamWakeResponse(stream, abortSignal, delivery, cardRecipientId) {
         const chunks = [];
         let runError;
         for await (const chunk of stream) {
@@ -464,7 +402,7 @@ let AgentExecutionOrchestratorService = class AgentExecutionOrchestratorService
         }
         abortSignal.throwIfAborted();
         if (delivery)
-            await delivery.bridge.deliverWakeResponse(delivery.threadId, chunks);
+            await delivery.bridge.deliverWakeResponse(delivery.threadId, chunks, cardRecipientId);
     }
     async getWakeDelivery(agentId, integrationType, context) {
         const target = context?.replyTarget ?? context?.target;
@@ -483,70 +421,27 @@ let AgentExecutionOrchestratorService = class AgentExecutionOrchestratorService
         return { bridge, threadId: target.threadId };
     }
     async *streamChatResponse(config) {
-        const { agentInstance, toolRegistry, mcpServerAttributions, agentId, userId, message, modelMessage = message, author, attachments, memory, projectId, source, taskId, taskVersionId, telemetry, onExecutionRecorded, abortSignal, includeHitlToolDetails, sandboxPrincipalHash, hideUserMessageFromTranscript, isWakeRun, backgroundJobSignal, } = config;
-        const { threadId, resourceId } = memory;
         yield* this.turnExecutionService.execute({
-            agentInstance,
-            toolRegistry,
-            mcpServerAttributions,
-            context: { projectId, agentId, threadId },
-            backgroundJobSignal,
-            includeHitlToolDetails,
-            onExecutionRecorded,
-            onSettled: isWakeRun
-                ? undefined
-                : async () => await this.requestPendingBackgroundWake(threadId),
-            prepare: async () => {
-                const tracing = await this.agentRunTracingService.build({
-                    agentId,
-                    projectId,
-                    threadId,
-                    userId,
-                    source: source ?? 'test',
-                    modelId: (0, agent_run_tracing_service_1.modelIdFromSnapshot)(agentInstance.snapshot.model),
-                });
-                const input = attachments?.length
-                    ? (0, inbound_attachments_1.buildInboundUserMessage)(modelMessage, attachments)
-                    : modelMessage;
-                const messageContext = config.messageContext === undefined
-                    ? await this.integrationMessageContextService.getLatest(threadId)
-                    : config.messageContext;
-                const hostMetadata = {
-                    ...(0, agent_sandbox_principal_1.encodeAgentSandboxHostMetadata)({
-                        projectId,
-                        principalHash: sandboxPrincipalHash,
-                    }),
-                    ...(0, integration_message_context_1.encodeIntegrationMessageContext)(messageContext),
-                };
-                return {
-                    type: 'start',
-                    input,
-                    options: {
-                        persistence: { threadId, resourceId, hostMetadata },
-                        executionCounter: (0, agent_execution_counter_1.createAgentExecutionCounter)(this.telemetry, {
-                            agentId,
-                            userId,
-                            runType: telemetry.runType,
-                        }),
-                        ...(0, model_stream_stall_options_1.modelStreamStallOptions)(this.aiConfig),
-                        ...(tracing ? { telemetry: tracing } : {}),
-                        ...(abortSignal ? { abortSignal } : {}),
-                    },
-                    recording: {
-                        threadId,
-                        agentId,
-                        agentName: agentInstance.name,
-                        projectId,
-                        userMessage: hideUserMessageFromTranscript ? null : message,
-                        author,
-                        attachments,
-                        source,
-                        taskId,
-                        taskVersionId,
-                        telemetry: { ...telemetry, userId },
-                    },
-                };
+            admittedExecution: config.admittedExecution,
+            onAdmitted: config.onAdmitted,
+            agentInstance: config.agentInstance,
+            toolRegistry: config.toolRegistry,
+            mcpServerAttributions: config.mcpServerAttributions,
+            context: {
+                projectId: config.projectId,
+                agentId: config.agentId,
+                threadId: config.memory.threadId,
             },
+            backgroundJobSignal: config.backgroundJobSignal,
+            includeHitlToolDetails: config.includeHitlToolDetails,
+            onExecutionRecorded: config.onExecutionRecorded,
+            previewChat: config.previewChat,
+            productionN8nChat: config.source === agent_thread_access_1.N8N_CHAT_PRODUCTION_SOURCE,
+            onExecutionStarted: config.onExecutionStarted,
+            onSettled: config.isWakeRun
+                ? undefined
+                : async () => await this.requestPendingBackgroundWake(config.memory.threadId),
+            prepare: async () => await this.prepareChatTurn(config),
         });
     }
     async *withRuntimeLease(acquire, use) {
@@ -568,12 +463,14 @@ let AgentExecutionOrchestratorService = class AgentExecutionOrchestratorService
         }
     }
     async getRuntimeOrRecordFailure(params, session) {
-        const { onExecutionRecorded, abortSignal, ...recording } = session;
+        const { onExecutionRecorded, abortSignal, automaticContinuationRunId, admittedExecution, ...recording } = session;
         abortSignal?.throwIfAborted();
         try {
             return await this.runtimeCacheService.getRuntime(params);
         }
         catch (error) {
+            if (admittedExecution)
+                throw error;
             abortSignal?.throwIfAborted();
             const { agentId, projectId } = params;
             let agent;
@@ -594,19 +491,335 @@ let AgentExecutionOrchestratorService = class AgentExecutionOrchestratorService
                     agentName: selected.schema?.name ?? agent.name,
                     projectId,
                     telemetry: {
-                        userId: params.user?.id,
+                        userId: params.attributionUserId ?? params.user?.id,
                         runType: params.usePublishedVersion ? 'production' : 'test',
                         configuration: (0, agent_telemetry_1.buildAgentConfigurationTelemetry)(selected),
                     },
-                }, error, onExecutionRecorded);
+                }, error, onExecutionRecorded, { previewChat: params.previewChat, automaticContinuationRunId });
             }
             throw error;
         }
     }
+    async getResumeRuntime(config, checkpoint) {
+        const { agentId, projectId, runId, source, integrationType, user, usePublishedVersion, onExecutionRecorded, abortSignal, previewChat, } = config;
+        const { memoryScope, sandboxPrincipalHash, access } = checkpoint;
+        return await this.getRuntimeOrRecordFailure({
+            agentId,
+            projectId,
+            usePublishedVersion,
+            integrationType,
+            user: usePublishedVersion ? undefined : user,
+            attributionUserId: source === agent_thread_access_1.N8N_CHAT_PRODUCTION_SOURCE ? user?.id : undefined,
+            allowBackgroundTasks: source === agent_thread_access_1.N8N_CHAT_PRODUCTION_SOURCE ? false : undefined,
+            ...(sandboxPrincipalHash ? { sandboxPrincipalHash } : {}),
+            previewChat,
+        }, {
+            threadId: memoryScope.threadId,
+            resourceId: memoryScope.resourceId,
+            resumeRunId: runId,
+            userMessage: null,
+            source,
+            onExecutionRecorded,
+            abortSignal,
+            access,
+            automaticContinuationRunId: previewChat && config.automaticPreviewContinuation ? runId : undefined,
+            sessionMode: 'existing',
+        });
+    }
+    resumeRuntimeTurn(config, checkpoint, runtime) {
+        const threadId = checkpoint.memoryScope.threadId;
+        return this.turnExecutionService.execute({
+            agentInstance: runtime.agent,
+            toolRegistry: runtime.toolRegistry,
+            mcpServerAttributions: runtime.mcpServerAttributions,
+            context: { projectId: config.projectId, agentId: config.agentId, threadId },
+            includeHitlToolDetails: !config.usePublishedVersion || config.source === agent_thread_access_1.N8N_CHAT_PRODUCTION_SOURCE,
+            previewChat: config.previewChat,
+            productionN8nChat: config.source === agent_thread_access_1.N8N_CHAT_PRODUCTION_SOURCE,
+            automaticPreviewContinuation: config.automaticPreviewContinuation,
+            onExecutionStarted: config.onExecutionStarted,
+            onExecutionRecorded: config.onExecutionRecorded,
+            onSettled: async (suspended) => {
+                if (!suspended)
+                    await this.requestPendingBackgroundWake(threadId);
+            },
+            prepare: async () => await this.prepareChatResume(config, checkpoint, runtime),
+        });
+    }
+    async prepareChatResume(config, checkpoint, runtime) {
+        const { memoryScope } = checkpoint;
+        const { executionSource, tracing } = await this.getResumeTracing(config, memoryScope.threadId, runtime);
+        const messageContext = await this.resolveResumeMessageContext(config, memoryScope);
+        return {
+            type: 'resume',
+            resumeData: config.resumeData,
+            options: this.createResumeOptions(config, memoryScope, messageContext, tracing),
+            recording: this.createResumeRecording(config, checkpoint, runtime, executionSource),
+        };
+    }
+    async getResumeTracing(config, threadId, runtime) {
+        const { agentId, projectId, source, user } = config;
+        const suspendedExecution = this.agentRunTracingService.enabled && source === undefined
+            ? await this.agentExecutionService.findLatestSuspendedRun(threadId)
+            : undefined;
+        const executionSource = source ?? suspendedExecution?.source ?? undefined;
+        const tracing = await this.agentRunTracingService.build({
+            agentId,
+            projectId,
+            threadId,
+            userId: user?.id,
+            source: executionSource ?? 'unknown',
+            modelId: (0, agent_run_tracing_service_1.modelIdFromSnapshot)(runtime.agent.snapshot.model),
+        });
+        return { executionSource, tracing };
+    }
+    createResumeOptions(config, memoryScope, selectedContext, tracing) {
+        const { runId, toolCallId, agentId, user, usePublishedVersion, abortSignal } = config;
+        const runType = usePublishedVersion ? 'production' : 'test';
+        const conversation = config.contextConversation;
+        return {
+            runId,
+            toolCallId,
+            hostMetadata: (0, integration_message_context_1.encodeIntegrationMessageContext)(selectedContext),
+            ...(selectedContext && conversation
+                ? {
+                    onResumeClaimed: async () => await this.integrationMessageContextService.installIncoming(selectedContext, memoryScope, conversation),
+                }
+                : {}),
+            executionCounter: (0, agent_execution_counter_1.createAgentExecutionCounter)(this.telemetry, {
+                agentId,
+                userId: user?.id,
+                runType,
+            }),
+            ...(0, model_stream_stall_options_1.modelStreamStallOptions)(this.aiConfig),
+            ...(tracing ? { telemetry: tracing } : {}),
+            ...(abortSignal ? { abortSignal } : {}),
+        };
+    }
+    createResumeRecording(config, { memoryScope, access }, runtime, executionSource) {
+        const { agentId, projectId, user, usePublishedVersion } = config;
+        const threadId = memoryScope.threadId;
+        const runType = usePublishedVersion ? 'production' : 'test';
+        return {
+            access,
+            threadId,
+            agentId,
+            agentName: runtime.agent.name,
+            resourceId: memoryScope.resourceId,
+            projectId,
+            userMessage: null,
+            sessionMode: 'existing',
+            ...(executionSource !== undefined ? { source: executionSource } : {}),
+            telemetry: {
+                userId: user?.id,
+                runType,
+                configuration: runtime.telemetryConfiguration,
+            },
+        };
+    }
+    async resolveResumeMessageContext(config, memoryScope) {
+        let messageContext = config.messageContext;
+        if (messageContext === undefined) {
+            messageContext = await this.integrationMessageContextService.getForResume(memoryScope);
+        }
+        else if (messageContext && config.contextConversation) {
+            messageContext = (0, integration_message_context_1.inheritIntegrationMessageContext)(messageContext, await this.integrationMessageContextService.getForResume(memoryScope));
+        }
+        return messageContext;
+    }
+    async assertDraftChatAccess({ agentId, projectId, memory, user, previewChat, sessionMode, }) {
+        if (memory.resourceId !== (0, agent_memory_scope_1.draftChatMemoryResourceId)(user.id) ||
+            !(await this.agentExecutionService.canUseDraftThread(memory.threadId, projectId, agentId, user.id, { previewChat, sessionMode }))) {
+            throw new n8n_workflow_1.UserError('Session not found');
+        }
+    }
+    async getDraftChatRuntime(config, access, sandboxPrincipalHash) {
+        const { agentId, projectId, user, previewChat, memory, message, attachments, source, onExecutionRecorded, abortSignal, sessionMode, } = config;
+        return await this.getRuntimeOrRecordFailure({
+            agentId,
+            projectId,
+            integrationType: api_types_1.N8N_CHAT_INTEGRATION_TYPE,
+            user,
+            sandboxPrincipalHash,
+            previewChat,
+        }, {
+            threadId: memory.threadId,
+            resourceId: memory.resourceId,
+            access,
+            admittedExecution: config.admittedExecution,
+            userMessage: message,
+            attachments,
+            source,
+            onExecutionRecorded,
+            abortSignal,
+            sessionMode,
+        });
+    }
+    async streamDraftChatResponse(config, runtime, access, sandboxPrincipalHash) {
+        const { agentId, user, message, attachments, memory, source, onExecutionRecorded, abortSignal, previewChat, sessionMode, } = config;
+        const messageContext = this.createN8nChatMessageContext(memory, user.id);
+        return this.streamChatResponse({
+            admittedExecution: config.admittedExecution,
+            onAdmitted: async () => await this.integrationMessageContextService.setLatest(memory.threadId, memory.resourceId, messageContext),
+            access,
+            messageContext,
+            agentInstance: runtime.agent,
+            toolRegistry: runtime.toolRegistry,
+            mcpServerAttributions: runtime.mcpServerAttributions,
+            agentId,
+            userId: user.id,
+            message,
+            attachments,
+            memory,
+            projectId: runtime.projectId,
+            source,
+            telemetry: { runType: 'test', configuration: runtime.telemetryConfiguration },
+            onExecutionRecorded,
+            abortSignal,
+            includeHitlToolDetails: true,
+            previewChat,
+            onExecutionStarted: config.onExecutionStarted,
+            sandboxPrincipalHash,
+            sessionMode,
+        });
+    }
+    createN8nChatMessageContext(memory, userId) {
+        return {
+            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(),
+        };
+    }
+    async prepareChatTurn(config) {
+        const { agentInstance, agentId, userId, message, modelMessage = message, attachments, memory, projectId, source, telemetry, abortSignal, sandboxPrincipalHash, } = config;
+        const { threadId, resourceId } = memory;
+        const tracing = await this.agentRunTracingService.build({
+            agentId,
+            projectId,
+            threadId,
+            userId,
+            source: source ?? 'test',
+            modelId: (0, agent_run_tracing_service_1.modelIdFromSnapshot)(agentInstance.snapshot.model),
+        });
+        const input = attachments?.length
+            ? (0, inbound_attachments_1.buildInboundUserMessage)(modelMessage, attachments)
+            : modelMessage;
+        const messageContext = config.messageContext === undefined
+            ? await this.integrationMessageContextService.getLatest(threadId)
+            : config.messageContext;
+        const hostMetadata = {
+            ...(0, agent_sandbox_principal_1.encodeAgentSandboxHostMetadata)({
+                projectId,
+                principalHash: sandboxPrincipalHash,
+            }),
+            ...(0, integration_message_context_1.encodeIntegrationMessageContext)(messageContext),
+        };
+        return {
+            type: 'start',
+            input,
+            options: {
+                persistence: { threadId, resourceId, hostMetadata },
+                executionCounter: (0, agent_execution_counter_1.createAgentExecutionCounter)(this.telemetry, {
+                    agentId,
+                    userId,
+                    runType: telemetry.runType,
+                }),
+                ...(0, model_stream_stall_options_1.modelStreamStallOptions)(this.aiConfig),
+                ...(tracing ? { telemetry: tracing } : {}),
+                ...(abortSignal ? { abortSignal } : {}),
+            },
+            recording: this.createChatRecording(config),
+        };
+    }
+    createChatRecording(config) {
+        const { agentInstance, agentId, userId, message, author, attachments, memory, projectId, source, taskId, taskVersionId, telemetry, hideUserMessageFromTranscript, sessionMode, } = config;
+        const { threadId } = memory;
+        return {
+            threadId,
+            access: config.access,
+            agentId,
+            agentName: agentInstance.name,
+            projectId,
+            userMessage: message,
+            resourceId: memory.resourceId,
+            hideUserMessageFromTranscript,
+            ...(config.messageContext && {
+                messageOrigin: {
+                    integrationConnectionId: config.messageContext.integrationConnectionId,
+                    platformMessageId: config.messageContext.messageId,
+                },
+            }),
+            sessionMode,
+            author,
+            attachments,
+            source,
+            taskId,
+            taskVersionId,
+            telemetry: { ...telemetry, userId },
+        };
+    }
+    async getWakeRuntime(config, access, integrationType, productionUserId) {
+        const { agentId, projectId, memory, identity, abortSignal } = config;
+        const isDraft = identity.type === 'draft';
+        return await this.getRuntimeOrRecordFailure({
+            agentId,
+            projectId,
+            integrationType,
+            usePublishedVersion: !isDraft,
+            ...(productionUserId
+                ? { attributionUserId: productionUserId, allowBackgroundTasks: false }
+                : {}),
+            ...(isDraft ? { user: identity.user } : {}),
+            sandboxPrincipalHash: identity.principalHash,
+        }, {
+            threadId: memory.threadId,
+            resourceId: memory.resourceId,
+            userMessage: config.message,
+            hideUserMessageFromTranscript: true,
+            source: productionUserId ? agent_thread_access_1.N8N_CHAT_PRODUCTION_SOURCE : integrationType,
+            abortSignal,
+            access,
+            sessionMode: 'existing',
+        });
+    }
+    streamWakeTurn(config, runtime, access, integrationType, messageContext, productionUserId) {
+        const { agentId, message, memory, identity, abortSignal } = config;
+        const isDraft = identity.type === 'draft';
+        return this.streamChatResponse({
+            access,
+            messageContext,
+            agentInstance: runtime.agent,
+            toolRegistry: runtime.toolRegistry,
+            mcpServerAttributions: runtime.mcpServerAttributions,
+            agentId,
+            ...(isDraft
+                ? { userId: identity.user.id }
+                : productionUserId
+                    ? { userId: productionUserId }
+                    : {}),
+            message,
+            memory,
+            projectId: runtime.projectId,
+            source: productionUserId ? agent_thread_access_1.N8N_CHAT_PRODUCTION_SOURCE : integrationType,
+            telemetry: {
+                runType: isDraft ? 'test' : 'production',
+                configuration: runtime.telemetryConfiguration,
+            },
+            abortSignal,
+            includeHitlToolDetails: isDraft || Boolean(productionUserId),
+            sandboxPrincipalHash: identity.principalHash,
+            hideUserMessageFromTranscript: true,
+            isWakeRun: true,
+            sessionMode: 'existing',
+            backgroundJobSignal: config.backgroundJobSignal,
+        });
+    }
 };
 exports.AgentExecutionOrchestratorService = AgentExecutionOrchestratorService;
 exports.AgentExecutionOrchestratorService = AgentExecutionOrchestratorService = __decorate([
     (0, di_1.Service)(),
-    __metadata("design:paramtypes", [backend_common_1.Logger, n8n_checkpoint_storage_1.N8NCheckpointStorage, agent_execution_service_1.AgentExecutionService, agent_turn_execution_service_1.AgentTurnExecutionService, telemetry_1.Telemetry, agent_runtime_cache_service_1.AgentRuntimeCacheService, integration_message_context_service_1.IntegrationMessageContextService, agent_run_tracing_service_1.AgentRunTracingService, external_hooks_1.ExternalHooks, agent_sandbox_runtime_service_1.AgentSandboxRuntimeService, agent_repository_1.AgentRepository, config_1.AiConfig])
+    __metadata("design:paramtypes", [backend_common_1.Logger, n8n_checkpoint_storage_1.N8NCheckpointStorage, agent_execution_service_1.AgentExecutionService, agent_turn_execution_service_1.AgentTurnExecutionService, telemetry_1.Telemetry, agent_runtime_cache_service_1.AgentRuntimeCacheService, integration_message_context_service_1.IntegrationMessageContextService, agent_run_tracing_service_1.AgentRunTracingService, external_hooks_1.ExternalHooks, agent_sandbox_runtime_service_1.AgentSandboxRuntimeService, agent_repository_1.AgentRepository, config_1.AiConfig, agent_chat_execution_service_1.AgentChatExecutionService])
 ], AgentExecutionOrchestratorService);
 //# sourceMappingURL=agent-execution-orchestrator.service.js.map