n8n 2.40.5 → 2.41.1

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

@@ -25,7 +25,9 @@ const agent_runtime_cache_service_1 = require("./agent-runtime-cache.service");
 const agent_sandbox_principal_1 = require("./agent-sandbox-principal");
 const agent_sandbox_runtime_service_1 = require("./agent-sandbox-runtime.service");
 const agent_telemetry_1 = require("./agent-telemetry");
-const execution_recorder_1 = require("./execution-recorder");
+const agent_turn_execution_service_1 = require("./agent-turn-execution.service");
+const agent_execution_recording_error_1 = require("./agent-execution-recording.error");
+const integration_message_context_1 = require("./integrations/integration-message-context");
 const integration_message_context_service_1 = require("./integrations/integration-message-context.service");
 const n8n_checkpoint_storage_1 = require("./integrations/n8n-checkpoint-storage");
 const model_stream_stall_options_1 = require("./model-stream-stall-options");
@@ -33,42 +35,7 @@ const agent_repository_1 = require("./repositories/agent.repository");
 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 agent_stream_1 = require("./utils/agent-stream");
-const mcp_attribution_1 = require("./utils/mcp-attribution");
 const execution_to_message_mapper_1 = require("./utils/execution-to-message-mapper");
-function withApprovalToolDetails(chunk, toolRegistry) {
-    if (chunk.type !== 'tool-call-suspended' || !(0, is_record_1.isRecord)(chunk.suspendPayload))
-        return chunk;
-    if (chunk.suspendPayload.type !== 'approval')
-        return chunk;
-    const toolName = chunk.suspendPayload.toolName;
-    if (typeof toolName !== 'string' || toolName.length === 0)
-        return chunk;
-    return {
-        ...chunk,
-        suspendPayload: {
-            ...chunk.suspendPayload,
-            details: (0, execution_recorder_1.buildToolCallDetails)(toolRegistry, toolName, chunk.suspendPayload.args),
-        },
-    };
-}
-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 },
-    ];
-}
-function normalizeAbortedMessageRecord(record, abortSignal) {
-    if (!abortSignal?.aborted)
-        return record;
-    return { ...record, finishReason: 'cancelled', error: null };
-}
 function getDelegatedChildCheckpoints(checkpoint, parentAgentId) {
     const childCheckpoints = [];
     const seen = new Set();
@@ -109,10 +76,11 @@ function getDelegatedChildCheckpoints(checkpoint, parentAgentId) {
     return childCheckpoints;
 }
 let AgentExecutionOrchestratorService = class AgentExecutionOrchestratorService {
-    constructor(logger, n8nCheckpointStorage, agentExecutionService, telemetry, runtimeCacheService, integrationMessageContextService, agentRunTracingService, externalHooks, agentSandboxRuntimeService, agentRepository, aiConfig) {
+    constructor(logger, n8nCheckpointStorage, agentExecutionService, turnExecutionService, telemetry, runtimeCacheService, integrationMessageContextService, agentRunTracingService, externalHooks, agentSandboxRuntimeService, agentRepository, aiConfig) {
         this.logger = logger;
         this.n8nCheckpointStorage = n8nCheckpointStorage;
         this.agentExecutionService = agentExecutionService;
+        this.turnExecutionService = turnExecutionService;
         this.telemetry = telemetry;
         this.runtimeCacheService = runtimeCacheService;
         this.integrationMessageContextService = integrationMessageContextService;
@@ -150,8 +118,8 @@ let AgentExecutionOrchestratorService = class AgentExecutionOrchestratorService
         await this.n8nCheckpointStorage.delete(params.runId, params.agentId);
         return true;
     }
-    async *resumeForChat(config) {
-        const { agentId, projectId, runId, toolCallId, resumeData, expectedMemory, source, integrationType, user, usePublishedVersion = true, onExecutionRecorded, abortSignal, } = config;
+    async loadResumeCheckpoint(params) {
+        const { agentId, projectId, runId, expectedMemory, user, usePublishedVersion } = params;
         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`);
@@ -184,8 +152,20 @@ let AgentExecutionOrchestratorService = class AgentExecutionOrchestratorService
                             (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 };
+    }
+    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;
-        const runtime = await this.runtimeCacheService.getRuntime({
+        yield* this.withRuntimeLease(async () => await this.getRuntimeOrRecordFailure({
             agentId,
             projectId,
             usePublishedVersion,
@@ -193,113 +173,78 @@ let AgentExecutionOrchestratorService = class AgentExecutionOrchestratorService
             user: usePublishedVersion ? undefined : user,
             ...(sandboxPrincipalHash ? { sandboxPrincipalHash } : {}),
             previewChat: config.previewChat,
-        });
-        const { agent: agentInstance, toolRegistry } = runtime;
-        let executionId;
-        let recorder;
-        let startedAt;
-        let runType;
-        let executionSource;
-        try {
-            recorder = this.createRecorder(toolRegistry, () => executionId, {
-                projectId,
-                agentId,
-                threadId,
-            });
-            startedAt = recorder.startedAt;
-            runType = usePublishedVersion ? 'production' : 'test';
-            executionSource = source;
-        }
-        catch (error) {
-            this.runtimeCacheService.releaseRuntimeLease(agentInstance);
-            throw error;
-        }
-        try {
-            const suspendedExecution = this.agentRunTracingService.enabled && source === undefined
-                ? await this.agentExecutionService.findLatestSuspendedRun(threadId)
-                : undefined;
-            executionSource ??= 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)(agentInstance.snapshot.model),
-            });
-            const resultStream = await agentInstance.resume('stream', resumeData, {
-                runId,
-                toolCallId,
-                executionCounter: (0, agent_execution_counter_1.createAgentExecutionCounter)(this.telemetry, {
+        }, { 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,
-                    runType,
-                }),
-                ...(0, model_stream_stall_options_1.modelStreamStallOptions)(this.aiConfig),
-                ...(tracing ? { telemetry: tracing } : {}),
-                ...(abortSignal ? { abortSignal } : {}),
-            });
-            recorder.recordHitlResponse(toolCallId, resumeData);
-            const startParams = {
-                threadId,
-                agentId,
-                agentName: agentInstance.name,
-                projectId,
-                userMessage: null,
-                ...(executionSource !== undefined ? { source: executionSource } : {}),
-                telemetry: {
-                    userId: user?.id,
-                    runType,
-                    configuration: runtime.telemetryConfiguration,
-                },
-            };
-            executionId = await this.tryStartExecution(startParams, startedAt, 'Failed to start resumed agent execution recording');
-            const attributionTracker = (0, mcp_attribution_1.createAttributionTracker)(runtime.mcpServerAttributions);
-            for await (const value of (0, agent_stream_1.streamAgentChunks)(resultStream.stream)) {
-                const chunk = usePublishedVersion ? value : withApprovalToolDetails(value, toolRegistry);
-                recorder.record(chunk);
-                for (const attributionChunk of attributionTracker.observe(chunk)) {
-                    recorder.record(attributionChunk);
-                    yield attributionChunk;
+                    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);
                 }
-                yield chunk;
-            }
-        }
-        catch (error) {
-            recorder.record({ type: 'error', error });
-            recorder.record({ type: 'finish', finishReason: 'error' });
-            throw error;
-        }
-        finally {
-            try {
-                const messageRecord = normalizeAbortedMessageRecord(recorder.getMessageRecord(), abortSignal);
-                await this.persistRecordedExecution({
-                    executionId,
-                    onExecutionRecorded,
-                    failureMessage: 'Failed to record resumed agent execution',
-                    params: {
+                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: agentInstance.name,
+                        agentName: runtime.agent.name,
                         projectId,
                         userMessage: null,
                         ...(executionSource !== undefined ? { source: executionSource } : {}),
-                        record: messageRecord,
-                        hitlStatus: recorder.suspended ? 'suspended' : 'resumed',
                         telemetry: {
                             userId: user?.id,
                             runType,
                             configuration: runtime.telemetryConfiguration,
                         },
                     },
-                });
-                if (!recorder.suspended)
-                    await this.requestPendingBackgroundWake(threadId);
-            }
-            finally {
-                this.runtimeCacheService.releaseRuntimeLease(agentInstance);
-            }
-        }
+                };
+            },
+        }));
     }
     async *executeForChat(config) {
         const { agentId, projectId, message, user, memory, attachments, source, previewChat, onExecutionRecorded, abortSignal, } = config;
@@ -307,23 +252,31 @@ let AgentExecutionOrchestratorService = class AgentExecutionOrchestratorService
             type: 'n8n-user',
             userId: user.id,
         });
-        const runtime = await this.runtimeCacheService.getRuntime({
+        yield* this.withRuntimeLease(async () => await this.getRuntimeOrRecordFailure({
             agentId,
             projectId,
             integrationType: api_types_1.N8N_CHAT_INTEGRATION_TYPE,
             user,
             sandboxPrincipalHash,
             previewChat,
-        });
-        try {
-            await this.integrationMessageContextService.setLatest(memory.threadId, memory.resourceId, {
+        }, {
+            threadId: memory.threadId,
+            userMessage: message,
+            attachments,
+            source,
+            onExecutionRecorded,
+            abortSignal,
+        }), 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(),
-            });
-            yield* this.streamChatResponse({
+            };
+            await this.integrationMessageContextService.setLatest(memory.threadId, memory.resourceId, messageContext);
+            return this.streamChatResponse({
+                messageContext,
                 agentInstance: runtime.agent,
                 toolRegistry: runtime.toolRegistry,
                 mcpServerAttributions: runtime.mcpServerAttributions,
@@ -343,15 +296,12 @@ let AgentExecutionOrchestratorService = class AgentExecutionOrchestratorService
                 includeHitlToolDetails: true,
                 sandboxPrincipalHash,
             });
-        }
-        finally {
-            this.runtimeCacheService.releaseRuntimeLease(runtime.agent);
-        }
+        });
     }
     async *executeForChatPublished(config) {
         const { agentId, projectId, message, modelMessage, author, memory, integrationType, attachments, sandboxPrincipalHash, } = config;
         await this.externalHooks.run('agent.preExecute', [agentId]);
-        const runtime = await this.getPublishedRuntimeOrRecordFailure({
+        yield* this.withRuntimeLease(async () => await this.getRuntimeOrRecordFailure({
             agentId,
             projectId,
             integrationType,
@@ -363,9 +313,14 @@ let AgentExecutionOrchestratorService = class AgentExecutionOrchestratorService
             author,
             attachments,
             source: integrationType,
-        });
-        try {
-            yield* this.streamChatResponse({
+        }), 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);
+            }
+            return this.streamChatResponse({
+                messageContext,
                 agentInstance: runtime.agent,
                 toolRegistry: runtime.toolRegistry,
                 mcpServerAttributions: runtime.mcpServerAttributions,
@@ -383,45 +338,42 @@ let AgentExecutionOrchestratorService = class AgentExecutionOrchestratorService
                 },
                 sandboxPrincipalHash,
             });
-        }
-        finally {
-            this.runtimeCacheService.releaseRuntimeLease(runtime.agent);
-        }
+        });
     }
     async *executeForTaskPublished(config) {
         const { agentId, projectId, message, memory, taskId, taskVersionId } = config;
         await this.externalHooks.run('agent.preExecute', [agentId]);
         const sandboxPrincipalHash = (0, agent_sandbox_principal_1.hashAgentSandboxPrincipal)({ type: 'scheduled-task', taskId });
-        const runtime = await this.getPublishedRuntimeOrRecordFailure({
+        yield* this.withRuntimeLease(async () => await this.getRuntimeOrRecordFailure({
             agentId,
             projectId,
             integrationType: 'task',
             usePublishedVersion: true,
             sandboxPrincipalHash,
             allowBackgroundTasks: false,
-        }, { threadId: memory.threadId, userMessage: message, source: 'task', taskId, taskVersionId });
-        try {
-            yield* this.streamChatResponse({
-                agentInstance: runtime.agent,
-                toolRegistry: runtime.toolRegistry,
-                mcpServerAttributions: runtime.mcpServerAttributions,
-                agentId,
-                message,
-                memory,
-                projectId: runtime.projectId,
-                source: 'task',
-                taskId,
-                taskVersionId,
-                telemetry: {
-                    runType: 'production',
-                    configuration: runtime.telemetryConfiguration,
-                },
-                sandboxPrincipalHash,
-            });
-        }
-        finally {
-            this.runtimeCacheService.releaseRuntimeLease(runtime.agent);
-        }
+        }, {
+            threadId: memory.threadId,
+            userMessage: message,
+            source: 'task',
+            taskId,
+            taskVersionId,
+        }), (runtime) => this.streamChatResponse({
+            agentInstance: runtime.agent,
+            toolRegistry: runtime.toolRegistry,
+            mcpServerAttributions: runtime.mcpServerAttributions,
+            agentId,
+            message,
+            memory,
+            projectId: runtime.projectId,
+            source: 'task',
+            taskId,
+            taskVersionId,
+            telemetry: {
+                runType: 'production',
+                configuration: runtime.telemetryConfiguration,
+            },
+            sandboxPrincipalHash,
+        }));
     }
     async *executeForTaskNow(config) {
         const { agentId, projectId, user, message, memory, taskId } = config;
@@ -429,35 +381,29 @@ let AgentExecutionOrchestratorService = class AgentExecutionOrchestratorService
             type: 'n8n-user',
             userId: user.id,
         });
-        const runtime = await this.runtimeCacheService.getRuntime({
+        yield* this.withRuntimeLease(async () => await this.getRuntimeOrRecordFailure({
             agentId,
             projectId,
             user,
             sandboxPrincipalHash,
             allowBackgroundTasks: false,
-        });
-        try {
-            yield* this.streamChatResponse({
-                agentInstance: runtime.agent,
-                toolRegistry: runtime.toolRegistry,
-                mcpServerAttributions: runtime.mcpServerAttributions,
-                agentId,
-                userId: user.id,
-                message,
-                memory,
-                projectId: runtime.projectId,
-                source: 'task',
-                taskId,
-                telemetry: {
-                    runType: 'test',
-                    configuration: runtime.telemetryConfiguration,
-                },
-                sandboxPrincipalHash,
-            });
-        }
-        finally {
-            this.runtimeCacheService.releaseRuntimeLease(runtime.agent);
-        }
+        }, { threadId: memory.threadId, userMessage: message, source: 'task', taskId }), (runtime) => this.streamChatResponse({
+            agentInstance: runtime.agent,
+            toolRegistry: runtime.toolRegistry,
+            mcpServerAttributions: runtime.mcpServerAttributions,
+            agentId,
+            userId: user.id,
+            message,
+            memory,
+            projectId: runtime.projectId,
+            source: 'task',
+            taskId,
+            telemetry: {
+                runType: 'test',
+                configuration: runtime.telemetryConfiguration,
+            },
+            sandboxPrincipalHash,
+        }));
     }
     async executeForWake(config) {
         const { agentId, projectId, message, memory, identity, abortSignal } = config;
@@ -465,64 +411,62 @@ let AgentExecutionOrchestratorService = class AgentExecutionOrchestratorService
         if (!isDraft)
             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
             ? undefined
-            : await this.getWakeDelivery(agentId, integrationType, memory.threadId);
-        const runtime = await this.runtimeCacheService.getRuntime({
+            : 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,
-        });
-        try {
-            const stream = this.streamChatResponse({
-                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,
-            });
-            const chunks = [];
-            let runError;
-            for await (const chunk of stream) {
-                if (delivery)
-                    chunks.push(chunk);
-                if (chunk.type === 'error')
-                    runError = chunk.error;
-                if (chunk.type === 'finish' && chunk.finishReason === 'error')
-                    runError ??= chunk;
-            }
-            if (runError !== undefined) {
-                throw new n8n_workflow_1.OperationalError('Background job wake failed', {
-                    cause: runError,
-                });
-            }
-            abortSignal.throwIfAborted();
-            if (delivery)
-                await delivery.bridge.deliverWakeResponse(delivery.threadId, chunks);
-        }
-        finally {
-            this.runtimeCacheService.releaseRuntimeLease(runtime.agent);
+        }, { 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));
+        for await (const _chunk of stream) {
         }
     }
-    async getWakeDelivery(agentId, integrationType, threadId) {
-        const context = await this.integrationMessageContextService.getLatest(threadId);
+    async *streamWakeResponse(stream, abortSignal, delivery) {
+        const chunks = [];
+        let runError;
+        for await (const chunk of stream) {
+            if (delivery)
+                chunks.push(chunk);
+            if (chunk.type === 'error')
+                runError = chunk.error;
+            if (chunk.type === 'finish' && chunk.finishReason === 'error')
+                runError ??= chunk;
+            yield chunk;
+        }
+        if (runError !== undefined) {
+            throw new n8n_workflow_1.OperationalError('Background job wake failed', { cause: runError });
+        }
+        abortSignal.throwIfAborted();
+        if (delivery)
+            await delivery.bridge.deliverWakeResponse(delivery.threadId, chunks);
+    }
+    async getWakeDelivery(agentId, integrationType, context) {
         const target = context?.replyTarget ?? context?.target;
         const [platform, credentialId] = context?.integrationConnectionId.split(':') ?? [];
         if (context?.platform !== integrationType ||
@@ -541,106 +485,77 @@ let AgentExecutionOrchestratorService = class AgentExecutionOrchestratorService
     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;
-        let executionId;
-        const recorder = this.createRecorder(toolRegistry, () => executionId, { projectId, agentId, threadId }, backgroundJobSignal);
-        const startedAt = recorder.startedAt;
-        try {
-            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 hostMetadata = (0, agent_sandbox_principal_1.encodeAgentSandboxHostMetadata)({
-                projectId,
-                principalHash: sandboxPrincipalHash,
-            });
-            const resultStream = await agentInstance.stream(input, {
-                persistence: { threadId, resourceId, hostMetadata },
-                executionCounter: (0, agent_execution_counter_1.createAgentExecutionCounter)(this.telemetry, {
+        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,
-                    runType: telemetry.runType,
-                }),
-                ...(0, model_stream_stall_options_1.modelStreamStallOptions)(this.aiConfig),
-                ...(tracing ? { telemetry: tracing } : {}),
-                ...(abortSignal ? { abortSignal } : {}),
-            });
-            const startParams = {
-                ...(backgroundJobSignal
-                    ? { initialTimeline: structuredClone(recorder.getMessageRecord().timeline) }
-                    : {}),
-                threadId,
-                agentId,
-                agentName: agentInstance.name,
-                projectId,
-                userMessage: hideUserMessageFromTranscript ? null : message,
-                author,
-                attachments,
-                source,
-                taskId,
-                taskVersionId,
-                telemetry: { ...telemetry, userId },
-            };
-            executionId = await this.tryStartExecution(startParams, startedAt, 'Failed to start agent execution recording');
-            const attributionTracker = (0, mcp_attribution_1.createAttributionTracker)(mcpServerAttributions);
-            for await (const value of (0, agent_stream_1.streamAgentChunks)(resultStream.stream)) {
-                const chunk = includeHitlToolDetails ? withApprovalToolDetails(value, toolRegistry) : value;
-                recorder.record(chunk);
-                if (chunk.type === 'tool-call-suspended') {
-                    this.logger.info('Chat: tool-call-suspended chunk received', {
+                    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,
-                        toolCallId: chunk.toolCallId,
-                        toolName: chunk.toolName,
-                    });
-                }
-                if (chunk.type === 'finish' && chunk.finishReason === 'max-iterations') {
-                    for (const chunk of getMaxIterationsChunks()) {
-                        recorder.record(chunk);
-                        yield chunk;
-                    }
-                }
-                for (const attributionChunk of attributionTracker.observe(chunk)) {
-                    recorder.record(attributionChunk);
-                    yield attributionChunk;
-                }
-                yield chunk;
-            }
-        }
-        catch (error) {
-            recorder.record({ type: 'error', error });
-            recorder.record({ type: 'finish', finishReason: 'error' });
-            throw error;
+                        agentName: agentInstance.name,
+                        projectId,
+                        userMessage: hideUserMessageFromTranscript ? null : message,
+                        author,
+                        attachments,
+                        source,
+                        taskId,
+                        taskVersionId,
+                        telemetry: { ...telemetry, userId },
+                    },
+                };
+            },
+        });
+    }
+    async *withRuntimeLease(acquire, use) {
+        const runtime = await acquire();
+        try {
+            yield* await use(runtime);
         }
         finally {
-            const messageRecord = normalizeAbortedMessageRecord(recorder.getMessageRecord(), abortSignal);
-            await this.persistRecordedExecution({
-                executionId,
-                onExecutionRecorded,
-                failureMessage: 'Failed to record agent execution',
-                params: {
-                    threadId,
-                    agentId,
-                    agentName: agentInstance.name,
-                    projectId,
-                    userMessage: hideUserMessageFromTranscript ? null : message,
-                    author,
-                    attachments,
-                    record: messageRecord,
-                    hitlStatus: recorder.suspended ? 'suspended' : undefined,
-                    source,
-                    taskId,
-                    taskVersionId,
-                    telemetry: { ...telemetry, userId },
-                },
-            });
-            if (!isWakeRun)
-                await this.requestPendingBackgroundWake(threadId);
+            this.runtimeCacheService.releaseRuntimeLease(runtime.agent);
         }
     }
     async requestPendingBackgroundWake(threadId) {
@@ -652,94 +567,46 @@ let AgentExecutionOrchestratorService = class AgentExecutionOrchestratorService
             this.logger.warn('Failed to request pending background job delivery', { threadId, error });
         }
     }
-    async getPublishedRuntimeOrRecordFailure(params, session) {
+    async getRuntimeOrRecordFailure(params, session) {
+        const { onExecutionRecorded, abortSignal, ...recording } = session;
+        abortSignal?.throwIfAborted();
         try {
             return await this.runtimeCacheService.getRuntime(params);
         }
         catch (error) {
+            abortSignal?.throwIfAborted();
+            const { agentId, projectId } = params;
+            let agent;
             try {
-                await this.recordFailedStart(params, session, error);
+                agent = await this.agentRepository.findByIdAndProjectId(agentId, projectId);
             }
-            catch (recordError) {
-                this.logger.warn('Failed to record agent execution', {
-                    agentId: params.agentId,
-                    threadId: session.threadId,
-                    error: recordError instanceof Error ? recordError.message : String(recordError),
-                });
+            catch (cause) {
+                throw new agent_execution_recording_error_1.AgentExecutionRecordingError({ phase: 'create', cause, executionError: error });
             }
-            throw error;
-        }
-    }
-    async recordFailedStart({ agentId, projectId }, session, error) {
-        const agent = await this.agentRepository.findByIdAndProjectId(agentId, projectId);
-        if (!agent)
-            return;
-        const published = agent.activeVersion?.schema ? (0, agent_published_snapshot_1.getPublishedAgentSnapshot)(agent) : agent;
-        const recorder = new execution_recorder_1.ExecutionRecorder();
-        recorder.record({ type: 'error', error });
-        recorder.record({ type: 'finish', finishReason: 'error' });
-        const startParams = {
-            ...session,
-            agentId,
-            agentName: published.schema?.name ?? agent.name,
-            projectId,
-            telemetry: {
-                runType: 'production',
-                configuration: (0, agent_telemetry_1.buildAgentConfigurationTelemetry)(published),
-            },
-        };
-        const executionId = await this.tryStartExecution(startParams, recorder.startedAt, 'Failed to start agent execution recording');
-        await this.persistRecordedExecution({
-            executionId,
-            params: { ...startParams, record: recorder.getMessageRecord() },
-            failureMessage: 'Failed to record agent execution',
-        });
-    }
-    createRecorder(toolRegistry, getExecutionId, context, backgroundJobSignal) {
-        return new execution_recorder_1.ExecutionRecorder(toolRegistry, (timeline) => {
-            const executionId = getExecutionId();
-            if (executionId) {
-                this.agentExecutionService.recordTimelineSnapshot({
-                    ...context,
-                    executionId,
-                    timeline,
-                });
+            abortSignal?.throwIfAborted();
+            if (agent) {
+                const selected = params.usePublishedVersion && agent.activeVersion?.schema
+                    ? (0, agent_published_snapshot_1.getPublishedAgentSnapshot)(agent)
+                    : agent;
+                await this.turnExecutionService.recordFailedStart({
+                    ...recording,
+                    agentId,
+                    agentName: selected.schema?.name ?? agent.name,
+                    projectId,
+                    telemetry: {
+                        userId: params.user?.id,
+                        runType: params.usePublishedVersion ? 'production' : 'test',
+                        configuration: (0, agent_telemetry_1.buildAgentConfigurationTelemetry)(selected),
+                    },
+                }, error, onExecutionRecorded);
             }
-        }, backgroundJobSignal);
-    }
-    async tryStartExecution(params, startedAt, failureMessage) {
-        try {
-            return await this.agentExecutionService.startExecutionRecording(params, startedAt);
-        }
-        catch (error) {
-            this.logger.warn(failureMessage, {
-                agentId: params.agentId,
-                threadId: params.threadId,
-                error: error instanceof Error ? error.message : String(error),
-            });
-            return undefined;
-        }
-    }
-    async persistRecordedExecution(args) {
-        const { executionId, onExecutionRecorded, params, failureMessage } = args;
-        if (!executionId)
-            return;
-        try {
-            const recordedId = await this.agentExecutionService.finalizeExecution(executionId, params);
-            onExecutionRecorded?.(recordedId);
-        }
-        catch (error) {
-            this.logger.warn(failureMessage, {
-                agentId: params.agentId,
-                threadId: params.threadId,
-                error: error instanceof Error ? error.message : String(error),
-            });
+            throw error;
         }
     }
 };
 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, 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])
 ], AgentExecutionOrchestratorService);
 //# sourceMappingURL=agent-execution-orchestrator.service.js.map