n8n 2.19.2 → 2.20.0

package/dist/modules/instance-ai/instance-ai.service.js

@@ -46,6 +46,7 @@ exports.InstanceAiService = void 0;
 const api_types_1 = require("@n8n/api-types");
 const backend_common_1 = require("@n8n/backend-common");
 const config_1 = require("@n8n/config");
+const n8n_core_1 = require("n8n-core");
 const constants_1 = require("@n8n/constants");
 const db_1 = require("@n8n/db");
 const di_1 = require("@n8n/di");
@@ -80,6 +81,58 @@ function createInertAbortSignal() {
 const ORCHESTRATOR_AGENT_ID = 'agent-001';
 const INSTANCE_AI_FEEDBACK_NAMESPACE = 'c5be4c87-5b6e-49ed-afe1-9c5c1f99a5c0';
 const MAX_CONCURRENT_BACKGROUND_TASKS_PER_THREAD = 5;
+function estimateTokens(text) {
+    return Math.ceil(text.length / 4);
+}
+function stringifyForContextValue(value) {
+    if (typeof value === 'string')
+        return value;
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+const PLANNED_TASK_CONTEXT_VALUE_LIMIT = 1_500;
+function truncateContextValue(value) {
+    if (value.length <= PLANNED_TASK_CONTEXT_VALUE_LIMIT)
+        return value;
+    return `${value.slice(0, PLANNED_TASK_CONTEXT_VALUE_LIMIT)}...`;
+}
+function buildPlannedTaskConversationContext(task, graph) {
+    if (!graph)
+        return undefined;
+    const parts = [
+        `Approved plan task: ${task.title}`,
+        `Task id: ${task.id}`,
+        `Task kind: ${task.kind}`,
+        `Plan run id: ${graph.planRunId}`,
+    ];
+    if (task.workflowId) {
+        parts.push(`Target workflow id: ${task.workflowId}`);
+    }
+    const dependencies = graph.tasks.filter((candidate) => task.deps.includes(candidate.id));
+    if (dependencies.length > 0) {
+        parts.push('Completed dependency context:');
+        for (const dependency of dependencies) {
+            const dependencyParts = [
+                `- ${dependency.id} (${dependency.kind}, ${dependency.status}): ${dependency.title}`,
+            ];
+            if (dependency.result) {
+                dependencyParts.push(`result=${truncateContextValue(dependency.result)}`);
+            }
+            if (dependency.error) {
+                dependencyParts.push(`error=${truncateContextValue(dependency.error)}`);
+            }
+            if (dependency.outcome) {
+                dependencyParts.push(`outcome=${truncateContextValue(stringifyForContextValue(dependency.outcome))}`);
+            }
+            parts.push(dependencyParts.join(' '));
+        }
+    }
+    return parts.join('\n');
+}
 function getProxyFetch() {
     const proxyUrl = process.env.HTTPS_PROXY || process.env.HTTP_PROXY;
     if (!proxyUrl)
@@ -91,8 +144,39 @@ function getProxyFetch() {
         dispatcher,
     }));
 }
+function toConfirmationData(request) {
+    switch (request.kind) {
+        case 'approval':
+            return { approved: request.approved, userInput: request.userInput };
+        case 'domainAccessApprove':
+            return { approved: true, domainAccessAction: request.domainAccessAction };
+        case 'domainAccessDeny':
+            return { approved: false };
+        case 'questions':
+            return { approved: true, answers: request.answers };
+        case 'credentialSelection':
+            return { approved: true, credentials: request.credentials };
+        case 'resourceDecision':
+            return { approved: true, resourceDecision: request.resourceDecision };
+        case 'setupWorkflowApply':
+            return {
+                approved: true,
+                action: 'apply',
+                nodeCredentials: request.nodeCredentials,
+                nodeParameters: request.nodeParameters,
+            };
+        case 'setupWorkflowTestTrigger':
+            return {
+                approved: true,
+                action: 'test-trigger',
+                testTriggerNode: request.testTriggerNode,
+                nodeCredentials: request.nodeCredentials,
+                nodeParameters: request.nodeParameters,
+            };
+    }
+}
 let InstanceAiService = class InstanceAiService {
-    constructor(logger, globalConfig, adapterService, eventBus, settingsService, compositeStore, compactionService, aiService, push, threadRepo, urlService, dbSnapshotStorage, dbIterationLogStorage, sourceControlPreferencesService, telemetry, userRepository, aiBuilderTemporaryWorkflowRepository) {
+    constructor(logger, globalConfig, adapterService, eventBus, settingsService, compositeStore, compactionService, aiService, push, threadRepo, urlService, dbSnapshotStorage, dbIterationLogStorage, sourceControlPreferencesService, telemetry, userRepository, aiBuilderTemporaryWorkflowRepository, errorReporter) {
         this.adapterService = adapterService;
         this.eventBus = eventBus;
         this.settingsService = settingsService;
@@ -108,6 +192,7 @@ let InstanceAiService = class InstanceAiService {
         this.telemetry = telemetry;
         this.userRepository = userRepository;
         this.aiBuilderTemporaryWorkflowRepository = aiBuilderTemporaryWorkflowRepository;
+        this.errorReporter = errorReporter;
         this.mcpClientManager = new instance_ai_1.McpClientManager();
         this.runState = new instance_ai_1.RunStateRegistry();
         this.backgroundTasks = new instance_ai_1.BackgroundTaskManager(MAX_CONCURRENT_BACKGROUND_TASKS_PER_THREAD);
@@ -117,10 +202,12 @@ let InstanceAiService = class InstanceAiService {
         this.domainAccessTrackersByThread = new Map();
         this.threadPushRef = new Map();
         this.schedulerLocks = new Map();
+        this.pendingCheckpointReentries = new Map();
         this.creditedThreads = new Set();
         this.traceReplay = new trace_replay_state_1.TraceReplayState();
         this.logger = logger.scoped('instance-ai');
         this.instanceAiConfig = globalConfig.instanceAi;
+        this.builderSandboxSessions = new instance_ai_1.BuilderSandboxSessionRegistry(this.instanceAiConfig.builderSandboxTtlMs);
         this.defaultTimeZone = globalConfig.generic.timezone;
         const editorBaseUrl = globalConfig.editorBaseUrl || `http://localhost:${globalConfig.port}`;
         const restEndpoint = globalConfig.endpoints.rest;
@@ -166,6 +253,7 @@ let InstanceAiService = class InstanceAiService {
                 daytonaApiUrl: daytonaApiUrl || undefined,
                 daytonaApiKey: daytonaApiKey || undefined,
                 image: sandboxImage || undefined,
+                n8nVersion: constants_2.N8N_VERSION || undefined,
                 timeout: sandboxTimeout,
             };
         }
@@ -224,7 +312,7 @@ let InstanceAiService = class InstanceAiService {
         if (!config.enabled)
             return undefined;
         if (config.provider === 'daytona') {
-            return new instance_ai_1.BuilderSandboxFactory(config, new instance_ai_1.SnapshotManager(config.image, this.logger), this.logger);
+            return new instance_ai_1.BuilderSandboxFactory(config, new instance_ai_1.SnapshotManager(config.image, this.logger, config.n8nVersion, this.errorReporter), this.logger, this.errorReporter);
         }
         return new instance_ai_1.BuilderSandboxFactory(config, undefined, this.logger);
     }
@@ -599,6 +687,9 @@ let InstanceAiService = class InstanceAiService {
             user,
             researchMode,
         });
+        if (timeZone) {
+            this.runState.setTimeZone(threadId, timeZone);
+        }
         if (pushRef !== undefined) {
             this.threadPushRef.set(threadId, pushRef);
         }
@@ -633,6 +724,7 @@ let InstanceAiService = class InstanceAiService {
                 void this.handlePlannedTaskSettlement(user, task, 'cancelled');
             }
         }
+        void this.cancelAwaitingApprovalPlan(threadId);
         const { active, suspended } = this.runState.cancelThread(threadId);
         if (active) {
             active.abortController.abort();
@@ -763,6 +855,7 @@ let InstanceAiService = class InstanceAiService {
         this.domainAccessTrackersByThread.delete(threadId);
         this.threadPushRef.delete(threadId);
         this.deleteTraceContextsForThread(threadId);
+        await this.builderSandboxSessions.cleanupThread(threadId, 'thread_cleared');
         await this.destroySandbox(threadId);
         await this.reapAiTemporaryForThreadCleanup(threadId);
         this.eventBus.clearThread(threadId);
@@ -801,7 +894,10 @@ let InstanceAiService = class InstanceAiService {
         }
         this.gatewayRegistry.disconnectAll();
         const sandboxCleanups = [...this.sandboxes.keys()].map(async (threadId) => await this.destroySandbox(threadId));
-        await Promise.allSettled(sandboxCleanups);
+        await Promise.allSettled([
+            ...sandboxCleanups,
+            this.builderSandboxSessions.cleanupAll('service_shutdown'),
+        ]);
         this.domainAccessTrackersByThread.clear();
         this.traceContextsByRunId.clear();
         this.eventBus.clear();
@@ -846,7 +942,7 @@ let InstanceAiService = class InstanceAiService {
             })),
         };
     }
-    buildPlannedTaskFollowUpMessage(type, graph, failedTask) {
+    buildPlannedTaskFollowUpMessage(type, graph, options = {}) {
         const payload = {
             tasks: graph.tasks.map((task) => ({
                 id: task.id,
@@ -858,13 +954,31 @@ let InstanceAiService = class InstanceAiService {
                 outcome: task.outcome,
             })),
         };
-        if (failedTask) {
+        if (options.failedTask) {
             payload.failedTask = {
-                id: failedTask.id,
-                title: failedTask.title,
-                kind: failedTask.kind,
-                error: failedTask.error,
-                result: failedTask.result,
+                id: options.failedTask.id,
+                title: options.failedTask.title,
+                kind: options.failedTask.kind,
+                error: options.failedTask.error,
+                result: options.failedTask.result,
+            };
+        }
+        if (options.checkpoint) {
+            const depOutcomes = graph.tasks
+                .filter((t) => options.checkpoint.deps.includes(t.id))
+                .map((t) => ({
+                id: t.id,
+                title: t.title,
+                kind: t.kind,
+                status: t.status,
+                result: t.result,
+                outcome: t.outcome,
+            }));
+            payload.checkpoint = {
+                id: options.checkpoint.id,
+                title: options.checkpoint.title,
+                instructions: options.checkpoint.spec,
+                dependsOn: depOutcomes,
             };
         }
         return `<planned-task-follow-up type="${type}">\n${JSON.stringify(payload, null, 2)}\n</planned-task-follow-up>\n\n${internal_messages_1.AUTO_FOLLOW_UP_MESSAGE}`;
@@ -887,6 +1001,28 @@ let InstanceAiService = class InstanceAiService {
             payload: { tasks },
         });
     }
+    async cancelAwaitingApprovalPlan(threadId) {
+        try {
+            const { plannedTaskService, taskStorage } = await this.createPlannedTaskState();
+            const graph = await plannedTaskService.getGraph(threadId);
+            if (!graph || graph.status !== 'awaiting_approval')
+                return;
+            await plannedTaskService.clear(threadId);
+            await taskStorage.save(threadId, { tasks: [] });
+            this.eventBus.publish(threadId, {
+                type: 'tasks-update',
+                runId: graph.planRunId,
+                agentId: ORCHESTRATOR_AGENT_ID,
+                payload: { tasks: { tasks: [] }, planItems: [] },
+            });
+        }
+        catch (error) {
+            this.logger.warn('Failed to clean up awaiting_approval plan on cancel', {
+                threadId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
     async createExecutionEnvironment(user, threadId, runId, abortSignal, researchMode, messageGroupId, pushRef) {
         const localGatewayDisabled = await this.settingsService.isLocalGatewayDisabledForUser(user.id);
         const userGateway = this.gatewayRegistry.findGateway(user.id);
@@ -981,6 +1117,9 @@ let InstanceAiService = class InstanceAiService {
             subAgentMaxSteps: this.instanceAiConfig.subAgentMaxSteps,
             eventBus: this.eventBus,
             logger: this.logger,
+            trackTelemetry: (eventName, properties) => {
+                this.telemetry.track(eventName, properties);
+            },
             domainTools,
             abortSignal,
             taskStorage,
@@ -1014,6 +1153,7 @@ let InstanceAiService = class InstanceAiService {
             workflowTaskService: workflowTasks,
             workspace: sandboxEntry?.workspace,
             builderSandboxFactory: await this.createBuilderFactory(user),
+            builderSandboxSessionRegistry: this.builderSandboxSessions,
             nodeDefinitionDirs: nodeDefDirs.length > 0 ? nodeDefDirs : undefined,
             domainContext: context,
             tracingProxyConfig,
@@ -1032,8 +1172,9 @@ let InstanceAiService = class InstanceAiService {
             sandboxEntry,
         };
     }
-    async dispatchPlannedTask(task, context) {
+    async dispatchPlannedTask(task, context, graph) {
         const taskContext = this.createPlannedTaskContext(task.kind, context);
+        const conversationContext = buildPlannedTaskConversationContext(task, graph);
         let started = null;
         switch (task.kind) {
             case 'build-workflow':
@@ -1041,12 +1182,14 @@ let InstanceAiService = class InstanceAiService {
                     task: task.spec,
                     workflowId: task.workflowId,
                     plannedTaskId: task.id,
+                    conversationContext,
                 });
                 break;
             case 'manage-data-tables':
                 started = await (0, instance_ai_1.startDataTableAgentTask)(taskContext, {
                     task: task.spec,
                     plannedTaskId: task.id,
+                    conversationContext,
                 });
                 break;
             case 'research':
@@ -1054,6 +1197,7 @@ let InstanceAiService = class InstanceAiService {
                     goal: task.title,
                     constraints: task.spec,
                     plannedTaskId: task.id,
+                    conversationContext,
                 });
                 break;
             case 'delegate':
@@ -1062,6 +1206,7 @@ let InstanceAiService = class InstanceAiService {
                     spec: task.spec,
                     tools: task.tools ?? [],
                     plannedTaskId: task.id,
+                    conversationContext,
                 });
                 break;
         }
@@ -1092,6 +1237,34 @@ let InstanceAiService = class InstanceAiService {
             domainTools: (0, instance_ai_1.createAllTools)(taskDomainContext),
         };
     }
+    async getCheckpointAllowedWorkflowIds(threadId, checkpointTaskId) {
+        try {
+            const { plannedTaskService } = await this.createPlannedTaskState();
+            const graph = await plannedTaskService.getGraph(threadId);
+            const checkpoint = graph?.tasks.find((t) => t.id === checkpointTaskId);
+            if (!graph || !checkpoint)
+                return new Set();
+            const deps = new Set(checkpoint.deps);
+            const allowed = new Set();
+            for (const task of graph.tasks) {
+                if (!deps.has(task.id))
+                    continue;
+                const workflowId = task.outcome?.workflowId;
+                if (typeof workflowId === 'string' && workflowId.length > 0) {
+                    allowed.add(workflowId);
+                }
+            }
+            return allowed;
+        }
+        catch (error) {
+            this.logger.warn('Failed to resolve checkpoint allowed workflow IDs', {
+                threadId,
+                checkpointTaskId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return new Set();
+        }
+    }
     async handlePlannedTaskSettlement(user, task, status) {
         if (!task.plannedTaskId)
             return;
@@ -1118,7 +1291,7 @@ let InstanceAiService = class InstanceAiService {
         }
         await this.schedulePlannedTasks(user, task.threadId);
     }
-    async startInternalFollowUpRun(user, threadId, message, researchMode, messageGroupId, isReplanFollowUp = false) {
+    async startInternalFollowUpRun(user, threadId, message, researchMode, messageGroupId, isReplanFollowUp = false, checkpoint) {
         if (this.runState.hasLiveRun(threadId)) {
             this.logger.warn('Skipping internal follow-up: active run exists', { threadId });
             return '';
@@ -1129,7 +1302,8 @@ let InstanceAiService = class InstanceAiService {
             researchMode,
             messageGroupId,
         });
-        void this.executeRun(user, threadId, runId, message, abortController, researchMode, undefined, messageGroupId, undefined, isReplanFollowUp);
+        const timeZone = this.runState.getTimeZone(threadId) ?? this.defaultTimeZone;
+        void this.executeRun(user, threadId, runId, message, abortController, researchMode, undefined, messageGroupId, timeZone, isReplanFollowUp, checkpoint);
         return runId;
     }
     async schedulePlannedTasks(user, threadId) {
@@ -1151,22 +1325,50 @@ let InstanceAiService = class InstanceAiService {
             return;
         if (action.type === 'replan') {
             await this.syncPlannedTasksToUi(threadId, action.graph);
-            await this.startInternalFollowUpRun(user, threadId, this.buildPlannedTaskFollowUpMessage('replan', action.graph, action.failedTask), this.runState.getThreadResearchMode(threadId), action.graph.messageGroupId, true);
+            const startedRunId = await this.startInternalFollowUpRun(user, threadId, this.buildPlannedTaskFollowUpMessage('replan', action.graph, {
+                failedTask: action.failedTask,
+            }), this.runState.getThreadResearchMode(threadId), action.graph.messageGroupId, true);
+            if (!startedRunId) {
+                await plannedTaskService.revertToActive(threadId);
+            }
             return;
         }
         if (action.type === 'synthesize') {
             await this.syncPlannedTasksToUi(threadId, action.graph);
-            await this.startInternalFollowUpRun(user, threadId, this.buildPlannedTaskFollowUpMessage('synthesize', action.graph), this.runState.getThreadResearchMode(threadId), action.graph.messageGroupId);
+            const startedRunId = await this.startInternalFollowUpRun(user, threadId, this.buildPlannedTaskFollowUpMessage('synthesize', action.graph), this.runState.getThreadResearchMode(threadId), action.graph.messageGroupId);
+            if (!startedRunId) {
+                await plannedTaskService.revertToActive(threadId);
+            }
+            return;
+        }
+        if (action.type === 'orchestrate-checkpoint') {
+            if (this.runState.hasLiveRun(threadId)) {
+                return;
+            }
+            const checkpoint = action.tasks[0];
+            await plannedTaskService.markRunning(threadId, checkpoint.id, {
+                agentId: ORCHESTRATOR_AGENT_ID,
+            });
+            const graphAfterMark = (await plannedTaskService.getGraph(threadId)) ?? action.graph;
+            await this.syncPlannedTasksToUi(threadId, graphAfterMark);
+            const checkpointRecord = graphAfterMark.tasks.find((t) => t.id === checkpoint.id) ?? checkpoint;
+            const startedRunId = await this.startInternalFollowUpRun(user, threadId, this.buildPlannedTaskFollowUpMessage('checkpoint', graphAfterMark, {
+                checkpoint: checkpointRecord,
+            }), this.runState.getThreadResearchMode(threadId), action.graph.messageGroupId, false, { isCheckpointFollowUp: true, checkpointTaskId: checkpoint.id });
+            if (!startedRunId) {
+                this.logger.warn('Checkpoint follow-up run did not start — reverting checkpoint to planned for retry', { threadId, checkpointTaskId: checkpoint.id });
+                await plannedTaskService.revertCheckpointToPlanned(threadId, checkpoint.id);
+            }
             return;
         }
         const environment = await this.createExecutionEnvironment(user, threadId, action.graph.planRunId, createInertAbortSignal(), this.runState.getThreadResearchMode(threadId), action.graph.messageGroupId);
         environment.orchestrationContext.tracing = this.getTraceContext(action.graph.planRunId);
         for (const task of action.tasks) {
-            await this.dispatchPlannedTask(task, environment.orchestrationContext);
+            await this.dispatchPlannedTask(task, environment.orchestrationContext, action.graph);
         }
         await this.doSchedulePlannedTasks(user, threadId);
     }
-    async executeRun(user, threadId, runId, message, abortController, researchMode, attachments, messageGroupId, timeZone, isReplanFollowUp = false) {
+    async executeRun(user, threadId, runId, message, abortController, researchMode, attachments, messageGroupId, timeZone, isReplanFollowUp = false, checkpoint) {
         const signal = abortController.signal;
         let mastraRunId = '';
         let tracing;
@@ -1197,6 +1399,15 @@ let InstanceAiService = class InstanceAiService {
             orchestrationContext.currentUserMessage = message;
             orchestrationContext.isReplanFollowUp = isReplanFollowUp;
             orchestrationContext.timeZone = timeZone ?? this.defaultTimeZone;
+            if (checkpoint?.isCheckpointFollowUp) {
+                orchestrationContext.isCheckpointFollowUp = true;
+                orchestrationContext.checkpointTaskId = checkpoint.checkpointTaskId;
+                context.permissions = {
+                    ...context.permissions,
+                    ...(instance_ai_1.PLANNED_TASK_PERMISSION_OVERRIDES.checkpoint ?? {}),
+                };
+                context.allowedRunWorkflowIds = await this.getCheckpointAllowedWorkflowIds(threadId, checkpoint.checkpointTaskId);
+            }
             if (attachments && attachments.length > 0) {
                 context.currentUserAttachments = attachments;
             }
@@ -1257,10 +1468,25 @@ let InstanceAiService = class InstanceAiService {
                 mcpServers,
                 memoryConfig,
                 memory,
-                workspace: orchestrationContext.workspace,
                 disableDeferredTools: true,
                 timeZone: timeZone ?? this.defaultTimeZone,
             });
+            const enrichedMessage = await this.buildMessageWithRunningTasks(threadId, message);
+            let nonStructuredAttachments = [];
+            let attachmentManifest = '';
+            let hasParseableAttachment = false;
+            if (attachments && attachments.length > 0) {
+                const classifiedAttachments = (0, instance_ai_1.classifyAttachments)(attachments);
+                nonStructuredAttachments = attachments.filter((attachment) => !(0, instance_ai_1.isStructuredAttachment)(attachment));
+                hasParseableAttachment = classifiedAttachments.some((attachment) => attachment.parseable);
+                attachmentManifest = (0, instance_ai_1.buildAttachmentManifest)(classifiedAttachments);
+            }
+            const messageWithoutSummary = !message && hasParseableAttachment
+                ? `The user attached file(s) without a message. Inspect the first parseable attachment with parse-file and provide a concise summary.\n\n${attachmentManifest}`
+                : attachmentManifest
+                    ? `${enrichedMessage}\n\n${attachmentManifest}`
+                    : enrichedMessage;
+            const messageWithoutSummaryTokens = estimateTokens(messageWithoutSummary);
             this.eventBus.publish(threadId, {
                 type: 'status',
                 runId,
@@ -1275,17 +1501,22 @@ let InstanceAiService = class InstanceAiService {
                     inputs: {
                         threadId,
                         lastMessages: this.instanceAiConfig.lastMessages ?? 20,
+                        currentInputTokens: messageWithoutSummaryTokens,
                     },
                 })
                 : undefined;
             let conversationSummary;
             try {
-                conversationSummary = await this.compactionService.prepareCompactedContext(threadId, memory, modelId, this.instanceAiConfig.lastMessages ?? 20);
+                conversationSummary = await this.compactionService.prepareCompactedContext(threadId, memory, modelId, this.instanceAiConfig.lastMessages ?? 20, 0.8, {
+                    label: 'orchestrator-current-input',
+                    text: messageWithoutSummary,
+                });
                 if (contextCompactionRun && tracing) {
                     await tracing.finishRun(contextCompactionRun, {
                         outputs: {
                             summarized: Boolean(conversationSummary),
                             summary: conversationSummary ?? '',
+                            currentInputTokens: messageWithoutSummaryTokens,
                         },
                         metadata: { final_status: 'completed' },
                     });
@@ -1319,41 +1550,23 @@ let InstanceAiService = class InstanceAiService {
                 : undefined;
             let streamInput;
             try {
-                const enrichedMessage = await this.buildMessageWithRunningTasks(threadId, message);
-                let fullMessage = conversationSummary
-                    ? `${conversationSummary}\n\n${enrichedMessage}`
-                    : enrichedMessage;
-                if (attachments && attachments.length > 0) {
-                    const classified = (0, instance_ai_1.classifyAttachments)(attachments);
-                    const nonStructured = attachments.filter((a) => !(0, instance_ai_1.isStructuredAttachment)(a));
-                    const hasParseable = classified.some((c) => c.parseable);
-                    const manifest = (0, instance_ai_1.buildAttachmentManifest)(classified);
-                    if (!message && hasParseable) {
-                        fullMessage = conversationSummary
-                            ? `${conversationSummary}\n\nThe user attached file(s) without a message. Inspect the first parseable attachment with parse-file and provide a concise summary.\n\n${manifest}`
-                            : `The user attached file(s) without a message. Inspect the first parseable attachment with parse-file and provide a concise summary.\n\n${manifest}`;
-                    }
-                    else {
-                        fullMessage = `${fullMessage}\n\n${manifest}`;
-                    }
-                    if (nonStructured.length > 0) {
-                        streamInput = [
-                            {
-                                role: 'user',
-                                content: [
-                                    { type: 'text', text: fullMessage },
-                                    ...nonStructured.map((a) => ({
-                                        type: 'file',
-                                        data: a.data,
-                                        mimeType: a.mimeType,
-                                    })),
-                                ],
-                            },
-                        ];
-                    }
-                    else {
-                        streamInput = fullMessage;
-                    }
+                const fullMessage = conversationSummary
+                    ? `${conversationSummary}\n\n${messageWithoutSummary}`
+                    : messageWithoutSummary;
+                if (nonStructuredAttachments.length > 0) {
+                    streamInput = [
+                        {
+                            role: 'user',
+                            content: [
+                                { type: 'text', text: fullMessage },
+                                ...nonStructuredAttachments.map((attachment) => ({
+                                    type: 'file',
+                                    data: attachment.data,
+                                    mimeType: attachment.mimeType,
+                                })),
+                            ],
+                        },
+                    ];
                 }
                 else {
                     streamInput = fullMessage;
@@ -1364,7 +1577,7 @@ let InstanceAiService = class InstanceAiService {
                         : {
                             fullMessage,
                             attachmentCount: attachments?.length ?? 0,
-                            nonStructuredAttachmentCount: attachments?.filter((a) => !(0, instance_ai_1.isStructuredAttachment)(a)).length ?? 0,
+                            nonStructuredAttachmentCount: nonStructuredAttachments.length,
                         };
                     await tracing.finishRun(promptBuildRun, {
                         outputs: traceOutput,
@@ -1434,6 +1647,7 @@ let InstanceAiService = class InstanceAiService {
                         messageGroupId,
                         createdAt: Date.now(),
                         tracing,
+                        checkpoint,
                     });
                 }
                 const intermediateText = await (result.text ?? Promise.resolve(''));
@@ -1533,9 +1747,125 @@ let InstanceAiService = class InstanceAiService {
             if (!this.runState.hasSuspendedRun(threadId) && mastraRunId) {
                 void this.cleanupMastraSnapshots(mastraRunId);
             }
+            if (!this.runState.hasSuspendedRun(threadId)) {
+                if (checkpoint?.isCheckpointFollowUp) {
+                    await this.finalizeCheckpointFollowUp(user, threadId, checkpoint.checkpointTaskId);
+                }
+                else {
+                    await this.schedulePlannedTasks(user, threadId);
+                }
+                await this.drainPendingCheckpointReentries(user, threadId);
+            }
+        }
+    }
+    queuePendingCheckpointReentry(threadId, checkpointTaskId) {
+        let set = this.pendingCheckpointReentries.get(threadId);
+        if (!set) {
+            set = new Set();
+            this.pendingCheckpointReentries.set(threadId, set);
         }
+        set.add(checkpointTaskId);
     }
-    async resolveConfirmation(requestingUserId, requestId, data) {
+    async drainPendingCheckpointReentries(user, threadId) {
+        const set = this.pendingCheckpointReentries.get(threadId);
+        if (!set || set.size === 0)
+            return;
+        const snapshot = [...set];
+        for (const checkpointTaskId of snapshot) {
+            if (this.runState.getActiveRunId(threadId) || this.runState.hasSuspendedRun(threadId)) {
+                return;
+            }
+            const siblings = this.backgroundTasks.getRunningTasksByParentCheckpoint(threadId, checkpointTaskId);
+            if (siblings.length > 0)
+                continue;
+            set.delete(checkpointTaskId);
+            await this.reenterCheckpointById(user, threadId, checkpointTaskId);
+        }
+        if (set.size === 0)
+            this.pendingCheckpointReentries.delete(threadId);
+    }
+    async reenterCheckpointById(user, threadId, checkpointTaskId, messageGroupId) {
+        try {
+            const { plannedTaskService } = await this.createPlannedTaskState();
+            const graph = await plannedTaskService.getGraph(threadId);
+            const checkpoint = graph?.tasks.find((t) => t.id === checkpointTaskId);
+            if (!graph || !checkpoint || checkpoint.kind !== 'checkpoint')
+                return false;
+            if (checkpoint.status !== 'running')
+                return false;
+            const startedRunId = await this.startInternalFollowUpRun(user, threadId, this.buildPlannedTaskFollowUpMessage('checkpoint', graph, { checkpoint }), this.runState.getThreadResearchMode(threadId), messageGroupId, false, { isCheckpointFollowUp: true, checkpointTaskId });
+            if (!startedRunId)
+                return false;
+            this.logger.debug('Re-entered checkpoint follow-up', {
+                threadId,
+                checkpointTaskId,
+                messageGroupId,
+            });
+            return true;
+        }
+        catch (error) {
+            this.logger.error('Failed to re-enter checkpoint follow-up', {
+                threadId,
+                checkpointTaskId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return false;
+        }
+    }
+    async maybeReenterParentCheckpoint(user, threadId, task) {
+        const parentCheckpointId = task.parentCheckpointId;
+        if (!parentCheckpointId)
+            return false;
+        const siblings = this.backgroundTasks
+            .getRunningTasksByParentCheckpoint(threadId, parentCheckpointId)
+            .filter((t) => t.taskId !== task.taskId);
+        if (siblings.length > 0)
+            return false;
+        if (this.runState.getActiveRunId(threadId) || this.runState.hasSuspendedRun(threadId)) {
+            return false;
+        }
+        return await this.reenterCheckpointById(user, threadId, parentCheckpointId, task.messageGroupId);
+    }
+    async finalizeCheckpointFollowUp(user, threadId, checkpointTaskId) {
+        try {
+            const { plannedTaskService } = await this.createPlannedTaskState();
+            const graph = await plannedTaskService.getGraph(threadId);
+            const task = graph?.tasks.find((t) => t.id === checkpointTaskId);
+            if (task && task.status === 'running') {
+                const inflightChildren = this.backgroundTasks.getRunningTasksByParentCheckpoint(threadId, checkpointTaskId);
+                if (inflightChildren.length > 0) {
+                    this.logger.debug('Checkpoint run ended with in-flight child tasks — deferring finalization', {
+                        threadId,
+                        checkpointTaskId,
+                        inflightTaskIds: inflightChildren.map((t) => t.taskId),
+                    });
+                }
+                else {
+                    this.logger.warn('Checkpoint run ended without reporting completion — marking failed', {
+                        threadId,
+                        checkpointTaskId,
+                    });
+                    await plannedTaskService.markCheckpointFailed(threadId, checkpointTaskId, {
+                        error: 'Checkpoint run ended without reporting completion',
+                    });
+                    const nextGraph = await plannedTaskService.getGraph(threadId);
+                    if (nextGraph) {
+                        await this.syncPlannedTasksToUi(threadId, nextGraph);
+                    }
+                }
+            }
+        }
+        catch (error) {
+            this.logger.error('Checkpoint finalization failed', {
+                threadId,
+                checkpointTaskId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+        await this.schedulePlannedTasks(user, threadId);
+    }
+    async resolveConfirmation(requestingUserId, requestId, request) {
+        const data = toConfirmationData(request);
         if (this.runState.resolvePendingConfirmation(requestingUserId, requestId, data)) {
             this.logger.debug('Resolved pending confirmation (sub-agent HITL)', {
                 requestId,
@@ -1558,16 +1888,14 @@ let InstanceAiService = class InstanceAiService {
             });
             return false;
         }
-        const { agent, runId, mastraRunId, threadId, user, toolCallId, abortController, tracing } = suspended;
+        const { agent, runId, mastraRunId, threadId, user, toolCallId, abortController, tracing, checkpoint, } = suspended;
         if (user.id !== requestingUserId)
             return false;
         this.runState.activateSuspendedRun(threadId);
         const credentialsPayload = data.nodeCredentials ?? data.credentials;
         const resumeData = {
             approved: data.approved,
-            ...(data.credentialId ? { credentialId: data.credentialId } : {}),
             ...(credentialsPayload ? { credentials: credentialsPayload } : {}),
-            ...(data.autoSetup ? { autoSetup: data.autoSetup } : {}),
             ...(data.userInput !== undefined ? { userInput: data.userInput } : {}),
             ...(data.domainAccessAction ? { domainAccessAction: data.domainAccessAction } : {}),
             ...(data.action ? { action: data.action } : {}),
@@ -1586,6 +1914,7 @@ let InstanceAiService = class InstanceAiService {
             abortController,
             snapshotStorage: this.dbSnapshotStorage,
             tracing,
+            checkpoint,
         });
         return true;
     }
@@ -1635,6 +1964,7 @@ let InstanceAiService = class InstanceAiService {
                         messageGroupId: this.traceContextsByRunId.get(opts.runId)?.messageGroupId,
                         createdAt: Date.now(),
                         tracing: opts.tracing,
+                        checkpoint: opts.checkpoint,
                     });
                 }
                 const intermediateText = await (result.text ?? Promise.resolve(''));
@@ -1725,10 +2055,19 @@ let InstanceAiService = class InstanceAiService {
             if (messageTraceFinalization) {
                 await this.maybeFinalizeRunTraceRoot(opts.runId, messageTraceFinalization);
             }
+            if (!this.runState.hasSuspendedRun(opts.threadId)) {
+                if (opts.checkpoint?.isCheckpointFollowUp) {
+                    await this.finalizeCheckpointFollowUp(opts.user, opts.threadId, opts.checkpoint.checkpointTaskId);
+                }
+                else {
+                    await this.schedulePlannedTasks(opts.user, opts.threadId);
+                }
+                await this.drainPendingCheckpointReentries(opts.user, opts.threadId);
+            }
         }
     }
     spawnBackgroundTask(runId, opts, snapshotStorage, messageGroupIdOverride) {
-        this.backgroundTasks.spawn({
+        const outcome = this.backgroundTasks.spawn({
             taskId: opts.taskId,
             threadId: opts.threadId,
             runId,
@@ -1738,6 +2077,8 @@ let InstanceAiService = class InstanceAiService {
             plannedTaskId: opts.plannedTaskId,
             workItemId: opts.workItemId,
             traceContext: opts.traceContext,
+            dedupeKey: opts.dedupeKey,
+            parentCheckpointId: opts.parentCheckpointId,
             run: opts.run,
             onLimitReached: async (errorMessage) => {
                 await this.finalizeDetachedTraceRun(opts.taskId, opts.traceContext, {
@@ -1792,25 +2133,88 @@ let InstanceAiService = class InstanceAiService {
             },
             onSettled: async (task) => {
                 await this.saveAgentTreeSnapshot(opts.threadId, runId, snapshotStorage, true, task.messageGroupId);
-                if (!task.plannedTaskId) {
-                    const remaining = this.backgroundTasks.getRunningTasks(opts.threadId);
-                    const hasActiveRun = !!this.runState.getActiveRunId(opts.threadId);
-                    const hasSuspendedRun = this.runState.hasSuspendedRun(opts.threadId);
-                    if (remaining.length === 0 && !hasActiveRun && !hasSuspendedRun) {
-                        const user = this.runState.getThreadUser(opts.threadId);
-                        if (user) {
-                            const payload = JSON.stringify({
-                                role: opts.role,
-                                status: task.result ? 'completed' : task.error ? 'failed' : 'finished',
-                                result: task.result ?? undefined,
-                                error: task.error ?? undefined,
-                            }, null, 2);
-                            await this.startInternalFollowUpRun(user, opts.threadId, `<background-task-completed>\n${payload}\n</background-task-completed>\n\n${internal_messages_1.AUTO_FOLLOW_UP_MESSAGE}`, this.runState.getThreadResearchMode(opts.threadId), task.messageGroupId);
-                        }
+                if (task.plannedTaskId)
+                    return;
+                const parentCheckpointId = task.parentCheckpointId;
+                if (parentCheckpointId) {
+                    const user = this.runState.getThreadUser(opts.threadId);
+                    if (!user) {
+                        this.queuePendingCheckpointReentry(opts.threadId, parentCheckpointId);
+                        return;
+                    }
+                    const reentered = await this.maybeReenterParentCheckpoint(user, opts.threadId, task);
+                    if (!reentered) {
+                        this.queuePendingCheckpointReentry(opts.threadId, parentCheckpointId);
+                    }
+                    return;
+                }
+                const remaining = this.backgroundTasks.getRunningTasks(opts.threadId);
+                const hasActiveRun = !!this.runState.getActiveRunId(opts.threadId);
+                const hasSuspendedRun = this.runState.hasSuspendedRun(opts.threadId);
+                if (remaining.length === 0 && !hasActiveRun && !hasSuspendedRun) {
+                    const user = this.runState.getThreadUser(opts.threadId);
+                    if (user) {
+                        const payload = JSON.stringify({
+                            role: opts.role,
+                            status: task.result ? 'completed' : task.error ? 'failed' : 'finished',
+                            result: task.result ?? undefined,
+                            outcome: task.outcome ?? undefined,
+                            error: task.error ?? undefined,
+                        }, null, 2);
+                        await this.startInternalFollowUpRun(user, opts.threadId, `<background-task-completed>\n${payload}\n</background-task-completed>\n\n${internal_messages_1.AUTO_FOLLOW_UP_MESSAGE}`, this.runState.getThreadResearchMode(opts.threadId), task.messageGroupId);
                     }
                 }
             },
         });
+        if (outcome.status === 'started') {
+            return { status: 'started', taskId: outcome.task.taskId, agentId: outcome.task.agentId };
+        }
+        if (outcome.status === 'duplicate') {
+            this.logger.warn('Background task dispatch deduped — task already in flight', {
+                threadId: opts.threadId,
+                requestedTaskId: opts.taskId,
+                existingTaskId: outcome.existing.taskId,
+                plannedTaskId: opts.dedupeKey?.plannedTaskId,
+                workflowId: opts.dedupeKey?.workflowId,
+                role: opts.role,
+            });
+            void this.finalizeDetachedTraceRun(opts.taskId, opts.traceContext, {
+                status: 'cancelled',
+                outputs: {
+                    taskId: opts.taskId,
+                    agentId: opts.agentId,
+                    role: opts.role,
+                    deduped_to: outcome.existing.taskId,
+                },
+                metadata: {
+                    deduped: true,
+                    existing_task_id: outcome.existing.taskId,
+                    ...(opts.plannedTaskId ? { planned_task_id: opts.plannedTaskId } : {}),
+                    ...(opts.workItemId ? { work_item_id: opts.workItemId } : {}),
+                },
+            });
+            this.eventBus.publish(opts.threadId, {
+                type: 'agent-completed',
+                runId,
+                agentId: opts.agentId,
+                payload: {
+                    role: opts.role,
+                    result: '',
+                    error: `Deduped: task already in flight as ${outcome.existing.taskId}`,
+                },
+            });
+            return {
+                status: 'duplicate',
+                existing: {
+                    taskId: outcome.existing.taskId,
+                    agentId: outcome.existing.agentId,
+                    role: outcome.existing.role,
+                    plannedTaskId: outcome.existing.plannedTaskId,
+                    workItemId: outcome.existing.workItemId,
+                },
+            };
+        }
+        return { status: 'limit-reached' };
     }
     async buildMessageWithRunningTasks(threadId, message) {
         return await (0, instance_ai_1.enrichMessageWithBackgroundTasks)(message, this.backgroundTasks.getRunningTasks(threadId), {
@@ -1853,6 +2257,14 @@ let InstanceAiService = class InstanceAiService {
         });
     }
     async reapAiTemporaryFromRun(threadId, user, createdWorkflowIds) {
+        const runningTaskCount = this.backgroundTasks.getRunningTasks(threadId).length;
+        if (runningTaskCount > 0) {
+            this.logger.debug('Deferring AI-builder temporary workflow cleanup until tasks settle', {
+                threadId,
+                runningTaskCount,
+            });
+            return [];
+        }
         let markedWorkflows = [];
         try {
             markedWorkflows = await this.aiBuilderTemporaryWorkflowRepository.findByThread(threadId);
@@ -2100,6 +2512,7 @@ exports.InstanceAiService = InstanceAiService = __decorate([
         source_control_preferences_service_ee_1.SourceControlPreferencesService,
         telemetry_1.Telemetry,
         db_1.UserRepository,
-        db_1.AiBuilderTemporaryWorkflowRepository])
+        db_1.AiBuilderTemporaryWorkflowRepository,
+        n8n_core_1.ErrorReporter])
 ], InstanceAiService);
 //# sourceMappingURL=instance-ai.service.js.map