n8n 2.45.6 → 2.46.1

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

@@ -0,0 +1,786 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SystemAgentExecutionService = void 0;
+const backend_common_1 = require("@n8n/backend-common");
+const db_1 = require("@n8n/db");
+const di_1 = require("@n8n/di");
+const errors_1 = require("@n8n/errors");
+const sleep_1 = require("@n8n/utils/sleep");
+const n8n_core_1 = require("n8n-core");
+const n8n_workflow_1 = require("n8n-workflow");
+const node_crypto_1 = require("node:crypto");
+const consumers_1 = require("node:stream/consumers");
+const agent_chat_attachment_service_1 = require("../agent-chat-attachment.service");
+const agent_chat_execution_service_1 = require("../agent-chat-execution.service");
+const agent_conversation_state_service_1 = require("../agent-conversation-state.service");
+const agent_execution_service_1 = require("../agent-execution.service");
+const agent_formatted_turn_error_1 = require("../agent-formatted-turn.error");
+const agent_message_queue_service_1 = require("../agent-message-queue.service");
+const agent_sse_stream_1 = require("../agent-sse-stream");
+const agent_turn_execution_service_1 = require("../agent-turn-execution.service");
+const n8n_checkpoint_storage_1 = require("../integrations/n8n-checkpoint-storage");
+const n8n_memory_1 = require("../integrations/n8n-memory");
+const agent_execution_repository_1 = require("../repositories/agent-execution.repository");
+const agent_execution_thread_repository_1 = require("../repositories/agent-execution-thread.repository");
+const agent_thread_grant_repository_1 = require("../repositories/agent-thread-grant.repository");
+const agent_memory_scope_1 = require("../utils/agent-memory-scope");
+const inbound_attachments_1 = require("../utils/inbound-attachments");
+const agent_thread_access_1 = require("../utils/agent-thread-access");
+const system_agent_access_1 = require("./system-agent-access");
+const system_agent_host_events_1 = require("./system-agent-host-events");
+const system_agent_registry_1 = require("./system-agent-registry");
+function runOptionsOf(handle) {
+    const { abortSignal: _abortSignal, ...runOptions } = handle.runOptions ?? {};
+    return {
+        ...runOptions,
+        ...(handle.onSideCallUsage ? { onSideCallUsage: handle.onSideCallUsage } : {}),
+    };
+}
+const USER_DELETION_DELETE_ATTEMPTS = 5;
+const USER_DELETION_RETRY_DELAY_MS = 1_000;
+let SystemAgentExecutionService = class SystemAgentExecutionService {
+    constructor(logger, registry, threadRepository, executionRepository, executionService, turnExecutionService, messageQueue, chatExecutionService, checkpointStorage, txRunner, attachmentService, conversationState, n8nMemory, threadGrants) {
+        this.logger = logger;
+        this.registry = registry;
+        this.threadRepository = threadRepository;
+        this.executionRepository = executionRepository;
+        this.executionService = executionService;
+        this.turnExecutionService = turnExecutionService;
+        this.messageQueue = messageQueue;
+        this.chatExecutionService = chatExecutionService;
+        this.checkpointStorage = checkpointStorage;
+        this.txRunner = txRunner;
+        this.attachmentService = attachmentService;
+        this.conversationState = conversationState;
+        this.n8nMemory = n8nMemory;
+        this.threadGrants = threadGrants;
+    }
+    resourceIdFor(user) {
+        return (0, agent_memory_scope_1.systemChatMemoryResourceId)(user.id);
+    }
+    getProvider(agentId) {
+        const provider = this.registry.get(agentId);
+        if (!provider)
+            throw new errors_1.NotFoundError(`Agent "${agentId}" not found`);
+        return provider;
+    }
+    assertRegistered(agentId) {
+        this.getProvider(agentId);
+    }
+    async assertCanUse(agentId, user, projectId) {
+        const provider = this.getProvider(agentId);
+        if (!(await (0, system_agent_access_1.canUseSystemAgent)(provider, user, projectId))) {
+            throw new errors_1.NotFoundError(`Agent "${agentId}" not found`);
+        }
+        return provider;
+    }
+    async getUsableThread(agentId, user, threadId) {
+        const thread = await this.getThread(agentId, user, threadId);
+        await this.assertCanUse(agentId, user, thread.projectId);
+        return thread;
+    }
+    async createThread(params) {
+        return (await this.resolveSession(params)).thread;
+    }
+    async resolveSession(params) {
+        this.assertRegistered(params.agentId);
+        const owned = params.threadId
+            ? await this.threadRepository.findOwnedById(params.agentId, params.user.id, params.threadId)
+            : null;
+        if (owned && params.projectId && owned.projectId !== params.projectId) {
+            throw new errors_1.NotFoundError('Session not found');
+        }
+        const projectId = owned?.projectId ?? params.projectId;
+        if (!projectId)
+            throw new n8n_workflow_1.UserError('A new session needs a working project');
+        const provider = await this.assertCanUse(params.agentId, params.user, projectId);
+        if (owned)
+            return { provider, thread: owned };
+        const thread = await this.txRunner.run({}, async (ctx) => {
+            let created;
+            try {
+                ({ thread: created } = await this.threadRepository.findOrCreate(params.threadId ?? (0, node_crypto_1.randomUUID)(), provider.agentId, provider.name, projectId, { accessScope: 'user', ownerId: params.user.id }, ctx));
+            }
+            catch (error) {
+                if (error instanceof n8n_workflow_1.UserError)
+                    throw new errors_1.NotFoundError('Session not found');
+                throw error;
+            }
+            if (created.parentThreadId !== null)
+                throw new errors_1.NotFoundError('Session not found');
+            if (params.title) {
+                await this.threadRepository.renameOwned(provider.agentId, params.user.id, created.id, params.title, ctx);
+                created.title = params.title;
+            }
+            return created;
+        });
+        return { provider, thread };
+    }
+    async listThreads(agentId, user, limit) {
+        this.assertRegistered(agentId);
+        return await this.threadRepository.findOwnedByAgent(agentId, user.id, { limit });
+    }
+    async getThread(agentId, user, threadId) {
+        this.assertRegistered(agentId);
+        const thread = await this.threadRepository.findOwnedById(agentId, user.id, threadId);
+        if (!thread)
+            throw new errors_1.NotFoundError('Session not found');
+        return thread;
+    }
+    async updateThread(agentId, user, threadId, changes) {
+        const thread = await this.getThread(agentId, user, threadId);
+        const { title, projectId } = changes;
+        const moving = projectId !== undefined && projectId !== thread.projectId;
+        if (moving)
+            await this.assertCanUse(agentId, user, projectId);
+        await this.txRunner.run({}, async (ctx) => {
+            if (moving) {
+                const locked = await this.threadRepository.lockById(threadId, ctx);
+                if (!locked)
+                    throw new errors_1.NotFoundError('Session not found');
+                if ((await this.resolveStatus(locked, ctx)).status !== 'idle') {
+                    throw new n8n_workflow_1.UserError('Wait for the current turn to finish before you change the project');
+                }
+            }
+            const renamed = title === undefined ||
+                (await this.threadRepository.renameOwned(agentId, user.id, threadId, title, ctx));
+            const moved = projectId === undefined ||
+                (await this.threadRepository.moveOwned(agentId, user.id, threadId, projectId, ctx));
+            if (!renamed || !moved)
+                throw new errors_1.NotFoundError('Session not found');
+        });
+        if (changes.title !== undefined)
+            thread.title = changes.title;
+        if (changes.projectId !== undefined)
+            thread.projectId = changes.projectId;
+        return thread;
+    }
+    async deleteThread(agentId, user, threadId) {
+        const thread = await this.getThread(agentId, user, threadId);
+        await this.deleteOwnedThread(thread, user.id);
+    }
+    async deleteThreadsOfUser(userId) {
+        let sessions;
+        try {
+            sessions = await this.threadRepository.findOwnedSystemAgentSessions(userId);
+        }
+        catch (error) {
+            this.logger.warn('Failed to find the system agent sessions of a deleted user', {
+                userId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return;
+        }
+        for (const session of sessions) {
+            let descendants;
+            try {
+                descendants = await this.findDescendantSessions(session);
+                await this.stopRunningTurn(session, [session, ...descendants], userId);
+            }
+            catch (error) {
+                this.logUserSessionDeletionFailure(userId, session, error);
+                continue;
+            }
+            for (const thread of [...descendants.reverse(), session]) {
+                try {
+                    await this.deleteWithRetry(thread, userId);
+                }
+                catch (error) {
+                    this.logUserSessionDeletionFailure(userId, thread, error);
+                }
+            }
+        }
+    }
+    logUserSessionDeletionFailure(userId, thread, error) {
+        this.logger.warn('Failed to delete a system agent session of a deleted user', {
+            userId,
+            agentId: thread.agentId,
+            threadId: thread.id,
+            error: error instanceof Error ? error.message : String(error),
+        });
+    }
+    async findDescendantSessions(root) {
+        const descendants = [];
+        const visited = new Set([root.id]);
+        let level = [root];
+        while (level.length > 0) {
+            const next = [];
+            for (const parent of level) {
+                for (const child of await this.threadRepository.findByParentThreadId(parent.id, parent.projectId)) {
+                    if (visited.has(child.id))
+                        continue;
+                    visited.add(child.id);
+                    next.push({ id: child.id, agentId: child.agentId, projectId: child.projectId });
+                }
+            }
+            descendants.push(...next);
+            level = next;
+        }
+        return descendants;
+    }
+    async stopRunningTurn(session, tree, userId) {
+        let running = false;
+        for (const thread of tree) {
+            if (await this.executionRepository.existsRunningByThread(thread.id)) {
+                running = true;
+                break;
+            }
+        }
+        if (!running)
+            return;
+        const latest = await this.executionRepository.findLatestByThreadId(session.id);
+        if (!latest)
+            return;
+        await this.chatExecutionService.requestCancel({
+            projectId: session.projectId,
+            agentId: session.agentId,
+            threadId: session.id,
+            executionId: latest.id,
+            userId,
+            surface: 'system',
+        });
+    }
+    async deleteWithRetry(session, userId) {
+        for (let attempt = 1;; attempt++) {
+            try {
+                await this.deleteOwnedThread(session, userId);
+                return;
+            }
+            catch (error) {
+                if (!(error instanceof errors_1.ConflictError) || attempt >= USER_DELETION_DELETE_ATTEMPTS) {
+                    throw error;
+                }
+                await (0, sleep_1.sleep)(USER_DELETION_RETRY_DELAY_MS);
+            }
+        }
+    }
+    async deleteOwnedThread(thread, userId) {
+        const deleted = await this.executionService.deleteThread(thread.projectId, thread.agentId, thread.id, userId);
+        if (!deleted)
+            throw new errors_1.NotFoundError('Session not found');
+        await this.destroyThreadWorkspace(thread.agentId, thread.id, userId);
+    }
+    async destroyThreadWorkspace(agentId, threadId, userId) {
+        const source = this.registry.get(agentId)?.workspace;
+        if (!source?.destroy)
+            return;
+        try {
+            await source.destroy({ agentId, threadId, ...(userId ? { userId } : {}) });
+        }
+        catch (error) {
+            this.logger.warn('System agent workspace destroy failed', { agentId, threadId, error });
+        }
+    }
+    async getStatus(thread) {
+        const { status, checkpoint } = await this.resolveStatus(thread);
+        const latest = await this.executionRepository.findLatestByThreadId(thread.id);
+        return { status, latestExecutionId: latest?.id ?? null, checkpoint };
+    }
+    async resolveStatus(thread, ctx = {}) {
+        const { running, suspendedCheckpoint } = await this.conversationState.inspect(thread.agentId, thread.id, ctx);
+        if (running)
+            return { status: 'running', checkpoint: null };
+        if (suspendedCheckpoint)
+            return { status: 'suspended', checkpoint: suspendedCheckpoint };
+        const queued = await this.messageQueue.hasQueuedMessages(thread.id, ctx);
+        return { status: queued ? 'running' : 'idle', checkpoint: null };
+    }
+    async getUsage(thread) {
+        const turns = await this.executionRepository.findUsageByThreadId(thread.id);
+        const children = await this.executionRepository.findChildUsageByParentIds(turns.map((turn) => turn.id));
+        const childrenByParent = new Map();
+        for (const row of children) {
+            if (row.parentExecutionId === null)
+                continue;
+            const entries = childrenByParent.get(row.parentExecutionId) ?? [];
+            entries.push(toUsageEntry(row));
+            childrenByParent.set(row.parentExecutionId, entries);
+        }
+        const executions = turns.map((turn) => {
+            const own = toUsageEntry(turn);
+            const children = childrenByParent.get(turn.id) ?? [];
+            return { ...own, descendants: children, total: sumUsage([own, ...children]) };
+        });
+        return { executions, total: sumUsage(executions.map((turn) => turn.total)) };
+    }
+    async sendMessage(params) {
+        const thread = await this.getUsableThread(params.agentId, params.user, params.threadId);
+        return await this.messageQueue.enqueue(this.queueInput(thread, params.user, params));
+    }
+    async steerIntoRunningTurn(thread, user, queueId) {
+        const execution = await this.executionRepository.findSteerable(thread.id);
+        if (!execution)
+            return false;
+        try {
+            await this.messageQueue.steer({
+                projectId: thread.projectId,
+                agentId: thread.agentId,
+                threadId: thread.id,
+                userId: user.id,
+                queueId,
+                executionId: execution.id,
+                kind: 'system',
+            });
+            return true;
+        }
+        catch (error) {
+            this.logger.debug('Could not steer system agent message', { threadId: thread.id, error });
+            return false;
+        }
+    }
+    async consume(claim, user, signal, send) {
+        const { thread, admission, payload } = claim;
+        if (payload.kind !== 'system')
+            return;
+        const provider = this.getProvider(thread.agentId);
+        signal.throwIfAborted();
+        const { resourceId } = payload;
+        const attachments = payload.attachments ?? [];
+        const hostEvents = this.createHostEventChannel(thread, send);
+        const workspace = await this.acquireWorkspace(provider, thread, user);
+        const controller = new AbortController();
+        const stopSetup = () => controller.abort(signal.reason);
+        signal.addEventListener('abort', stopSetup, { once: true });
+        if (signal.aborted)
+            stopSetup();
+        let handle;
+        try {
+            handle = await this.prepareOrRelease(workspace, hostEvents, controller.signal, thread, async () => {
+                return await provider.prepareTurn({
+                    type: 'start',
+                    user,
+                    thread,
+                    resourceId,
+                    abortSignal: controller.signal,
+                    ...(workspace ? { workspace: workspace.lease } : {}),
+                    ...this.turnStateOf(thread),
+                    emitHostEvent: hostEvents.emit,
+                    executionId: admission.executionId,
+                    message: payload.message,
+                    attachments,
+                    readAttachment: async (ref) => await this.readTurnAttachment(thread, resourceId, attachments, ref),
+                    options: payload.options ?? {},
+                });
+            });
+        }
+        finally {
+            signal.removeEventListener('abort', stopSetup);
+        }
+        const text = handle.input ?? payload.message;
+        const input = attachments.length > 0 && typeof text === 'string'
+            ? (0, inbound_attachments_1.buildInboundUserMessage)(text, attachments)
+            : text;
+        await this.runTurn({
+            thread,
+            handle,
+            workspace,
+            hostEvents,
+            send,
+            controller,
+            admission,
+            prepare: async () => ({
+                type: 'start',
+                input,
+                options: {
+                    ...runOptionsOf(handle),
+                    persistence: { threadId: thread.id, resourceId, hostMetadata: handle.hostMetadata },
+                    abortSignal: signal,
+                },
+                recording: claim.recording,
+            }),
+        });
+    }
+    async resume(params) {
+        const resumed = await this.startResume(params);
+        const done = resumed.done.catch((error) => {
+            this.logger.warn('System agent resume failed', { threadId: params.threadId, error });
+        });
+        return { ...resumed, done };
+    }
+    async startResume(params) {
+        const thread = await this.getUsableThread(params.agentId, params.user, params.threadId);
+        const provider = this.getProvider(params.agentId);
+        const checkpoint = await this.checkpointStorage.findSuspendedForThread(thread.agentId, thread.id);
+        const pending = Object.values(checkpoint?.pendingToolCalls ?? {}).find((toolCall) => toolCall.suspended &&
+            (params.toolCallId === undefined || toolCall.toolCallId === params.toolCallId));
+        if (!checkpoint || !pending || (params.runId !== undefined && params.runId !== pending.runId)) {
+            throw new n8n_workflow_1.UserError('This action is no longer waiting for input');
+        }
+        const { runId } = pending;
+        const resourceId = this.resourceIdFor(params.user);
+        if (checkpoint.persistence?.resourceId !== resourceId) {
+            throw new errors_1.NotFoundError('Session not found');
+        }
+        const checkpointHostMetadata = checkpoint.persistence.hostMetadata ?? {};
+        const controller = new AbortController();
+        const send = params.send ?? (() => { });
+        const hostEvents = this.createHostEventChannel(thread, send);
+        const workspace = await this.acquireWorkspace(provider, thread, params.user);
+        const handle = await this.prepareOrRelease(workspace, hostEvents, controller.signal, thread, async () => await provider.prepareTurn({
+            type: 'resume',
+            user: params.user,
+            thread,
+            resourceId,
+            abortSignal: controller.signal,
+            ...(workspace ? { workspace: workspace.lease } : {}),
+            ...this.turnStateOf(thread),
+            emitHostEvent: hostEvents.emit,
+            runId,
+            toolCallId: pending.toolCallId,
+            checkpointHostMetadata,
+            resumeData: params.resumeData,
+        }));
+        const recording = {
+            threadId: thread.id,
+            agentId: thread.agentId,
+            agentName: thread.agentName,
+            projectId: thread.projectId,
+            resourceId,
+            access: { accessScope: 'user', ownerId: params.user.id },
+            userMessage: null,
+            sessionMode: 'existing',
+            source: agent_thread_access_1.SYSTEM_CHAT_SOURCE,
+        };
+        const done = this.runTurn({
+            thread,
+            handle,
+            workspace,
+            hostEvents,
+            send,
+            controller,
+            onExecutionStarted: params.onExecutionStarted,
+            prepare: async () => ({
+                type: 'resume',
+                resumeData: params.resumeData,
+                options: {
+                    ...runOptionsOf(handle),
+                    runId,
+                    toolCallId: pending.toolCallId,
+                    hostMetadata: handle.hostMetadata,
+                },
+                recording,
+            }),
+        });
+        return { runId, toolCallId: pending.toolCallId, done };
+    }
+    async prepareChatMessage(params) {
+        const { provider, thread } = await this.resolveSession({
+            agentId: params.agentId,
+            user: params.user,
+            projectId: params.projectId,
+            threadId: params.sessionId,
+        });
+        const options = (await provider.chatTurnOptions?.(params.user, thread, params.clientContext)) ?? {};
+        const attachments = await params.storeAttachments?.(thread.id, thread.projectId);
+        return this.queueInput(thread, params.user, {
+            message: params.message,
+            messageId: params.messageId,
+            attachments,
+            options,
+        });
+    }
+    queueInput(thread, user, input) {
+        return {
+            agentId: thread.agentId,
+            projectId: thread.projectId,
+            threadId: thread.id,
+            sessionMode: 'existing',
+            source: agent_thread_access_1.SYSTEM_CHAT_SOURCE,
+            payload: {
+                kind: 'system',
+                userId: user.id,
+                message: input.message,
+                resourceId: this.resourceIdFor(user),
+                ...(input.attachments?.length ? { attachments: input.attachments } : {}),
+                ...(input.messageId ? { messageId: input.messageId } : {}),
+                ...(input.options ? { options: input.options } : {}),
+                ...(input.hidden ? { hidden: true } : {}),
+            },
+        };
+    }
+    async resumeRun(params) {
+        const provider = this.getProvider(params.agentId);
+        const state = await this.checkpointStorage.load(params.runId, params.agentId);
+        const threadId = state?.persistence?.threadId;
+        if (!threadId)
+            throw new n8n_workflow_1.UserError('This action is no longer waiting for input');
+        const { done } = await this.startResume({
+            agentId: params.agentId,
+            user: params.user,
+            threadId,
+            runId: params.runId,
+            toolCallId: params.toolCallId,
+            resumeData: provider.normalizeResumeData
+                ? provider.normalizeResumeData(params.resumeData)
+                : params.resumeData,
+            send: params.send,
+            onExecutionStarted: params.onExecutionStarted,
+        });
+        await done;
+    }
+    async cancel(agentId, user, threadId) {
+        const thread = await this.getThread(agentId, user, threadId);
+        const latest = await this.executionRepository.findLatestByThreadId(thread.id);
+        if (!latest)
+            return false;
+        return await this.chatExecutionService.requestCancel({
+            projectId: thread.projectId,
+            agentId,
+            threadId: thread.id,
+            executionId: latest.id,
+            userId: user.id,
+            surface: 'system',
+        });
+    }
+    turnStateOf(thread) {
+        return {
+            memory: this.n8nMemory.getImplementation(thread.agentId),
+            checkpointStore: this.checkpointStorage.getStorage(thread.agentId),
+            sessionGrants: {
+                load: async () => await this.threadGrants.findKeys(thread.id),
+                grant: async (key) => await this.threadGrants.grant(thread.id, key),
+                revoke: async (key) => await this.threadGrants.revoke(thread.id, key),
+            },
+        };
+    }
+    async readTurnAttachment(thread, resourceId, attachments, ref) {
+        if (!attachments.some((attachment) => attachment.id === ref.id))
+            return undefined;
+        const attachment = await this.attachmentService.getForSystemAgent(ref.id, {
+            agentId: thread.agentId,
+            resourceId,
+            source: agent_thread_access_1.SYSTEM_CHAT_SOURCE,
+        });
+        if (attachment?.threadId !== thread.id)
+            return undefined;
+        try {
+            return await (0, consumers_1.buffer)(await this.attachmentService.getStream(attachment));
+        }
+        catch (error) {
+            if (error instanceof n8n_core_1.FileNotFoundError)
+                return undefined;
+            throw error;
+        }
+    }
+    attachFileStore(handle, thread) {
+        handle.agent.fileStore(this.attachmentService.getFileStore({ agentId: thread.agentId, projectId: thread.projectId }, handle.agent.snapshot.model.provider ?? ''));
+    }
+    async acquireWorkspace(provider, thread, user) {
+        const source = provider.workspace;
+        if (!source)
+            return undefined;
+        const scope = {
+            agentId: thread.agentId,
+            threadId: thread.id,
+            projectId: thread.projectId,
+            user,
+        };
+        const lease = await source.acquire(scope);
+        if (lease === undefined)
+            return undefined;
+        return {
+            lease,
+            release: async (outcome) => {
+                if (!source.release)
+                    return;
+                try {
+                    await source.release(scope, lease, outcome);
+                }
+                catch (error) {
+                    this.logger.warn('System agent workspace release failed', {
+                        threadId: thread.id,
+                        error,
+                    });
+                }
+            },
+        };
+    }
+    async prepareOrRelease(workspace, hostEvents, signal, thread, prepare) {
+        try {
+            const handle = await prepare();
+            this.attachFileStore(handle, thread);
+            return handle;
+        }
+        catch (error) {
+            hostEvents.close();
+            await workspace?.release({ status: signal.aborted ? 'cancelled' : 'errored', error });
+            throw error;
+        }
+    }
+    createHostEventChannel(thread, send) {
+        return new system_agent_host_events_1.SystemAgentHostEventChannel(send, (name) => {
+            this.logger.debug('System agent host event after the turn settled was dropped', {
+                threadId: thread.id,
+                name,
+            });
+        });
+    }
+    async runTurn({ thread, handle, workspace, hostEvents, send, controller, admission, onExecutionStarted, prepare, }) {
+        let executionId = admission?.executionId;
+        let failure;
+        const formatError = this.turnErrorFormatter(handle, thread);
+        const settled = {};
+        const settle = async (outcome) => {
+            settled.outcome = outcome;
+            try {
+                await handle.onSettled?.(outcome);
+            }
+            catch (settleError) {
+                this.logger.warn('System agent turn settle hook failed', {
+                    threadId: thread.id,
+                    error: settleError,
+                });
+            }
+        };
+        const providerSignal = handle.runOptions?.abortSignal;
+        const stopTurn = () => controller.abort(providerSignal?.reason);
+        if (providerSignal?.aborted)
+            stopTurn();
+        else
+            providerSignal?.addEventListener('abort', stopTurn, { once: true });
+        try {
+            const stream = this.turnExecutionService.execute({
+                admittedExecution: admission,
+                agentInstance: handle.agent,
+                toolRegistry: handle.toolRegistry ?? new Map(),
+                mcpServerAttributions: new Map(),
+                context: { projectId: thread.projectId, agentId: thread.agentId, threadId: thread.id },
+                chatSurface: 'system',
+                chatController: controller,
+                onExecutionStarted: (id, threadId, inputMessageIds) => {
+                    executionId = id;
+                    onExecutionStarted?.(id, threadId, inputMessageIds);
+                },
+                onRecorderCreated: (recorder) => hostEvents.attach(recorder),
+                onBeforeFinalize: async (outcome) => {
+                    await settle(outcome);
+                    hostEvents.close();
+                },
+                prepare,
+                formatError,
+            });
+            for await (const chunk of stream) {
+                const formatted = chunk.type === 'error' ? await formatError(chunk.error) : undefined;
+                if (formatted) {
+                    send({
+                        type: 'error',
+                        message: formatted.message,
+                        ...(formatted.code ? { errorCode: formatted.code } : {}),
+                    });
+                }
+                else {
+                    (0, agent_sse_stream_1.emitChunkEvents)(chunk, send);
+                }
+                handle.onChunk?.(chunk);
+            }
+        }
+        catch (caught) {
+            failure = caught;
+            const formatted = await formatError(caught);
+            if (formatted)
+                throw new agent_formatted_turn_error_1.AgentFormattedTurnError(formatted, caught);
+            throw caught;
+        }
+        finally {
+            providerSignal?.removeEventListener('abort', stopTurn);
+            hostEvents.close();
+            if (!settled.outcome) {
+                await settle({
+                    status: controller.signal.aborted ? 'cancelled' : 'errored',
+                    executionId,
+                    ...(failure !== undefined ? { error: failure } : {}),
+                });
+            }
+            if (settled.outcome)
+                await workspace?.release(settled.outcome);
+            if (settled.outcome?.status === 'completed') {
+                send({ type: 'done', sessionId: thread.id, executionId: executionId ?? '' });
+            }
+        }
+    }
+    turnErrorFormatter(handle, thread) {
+        const results = new Map();
+        return async (error) => {
+            let result = results.get(error);
+            if (!result) {
+                result = this.formatTurnError(handle, thread, error);
+                results.set(error, result);
+            }
+            return await result;
+        };
+    }
+    async formatTurnError(handle, thread, error) {
+        if (!handle.formatError || (0, agent_sse_stream_1.chatErrorCode)(error) !== undefined)
+            return undefined;
+        try {
+            const formatted = await handle.formatError(error);
+            return formatted?.message ? formatted : undefined;
+        }
+        catch (formatError) {
+            this.logger.warn('System agent error formatter failed', {
+                threadId: thread.id,
+                error: formatError,
+            });
+            return undefined;
+        }
+    }
+};
+exports.SystemAgentExecutionService = SystemAgentExecutionService;
+exports.SystemAgentExecutionService = SystemAgentExecutionService = __decorate([
+    (0, di_1.Service)(),
+    __metadata("design:paramtypes", [backend_common_1.Logger, system_agent_registry_1.SystemAgentRegistry, agent_execution_thread_repository_1.AgentExecutionThreadRepository, agent_execution_repository_1.AgentExecutionRepository, agent_execution_service_1.AgentExecutionService, agent_turn_execution_service_1.AgentTurnExecutionService, agent_message_queue_service_1.AgentMessageQueueService, agent_chat_execution_service_1.AgentChatExecutionService, n8n_checkpoint_storage_1.N8NCheckpointStorage, db_1.TransactionRunner, agent_chat_attachment_service_1.AgentChatAttachmentService, agent_conversation_state_service_1.AgentConversationStateService, n8n_memory_1.N8nMemory, agent_thread_grant_repository_1.AgentThreadGrantRepository])
+], SystemAgentExecutionService);
+function toUsageEntry(row) {
+    return {
+        executionId: row.id,
+        threadId: row.threadId,
+        parentExecutionId: row.parentExecutionId,
+        status: row.status,
+        model: row.model,
+        startedAt: row.startedAt?.toISOString() ?? null,
+        stoppedAt: row.stoppedAt?.toISOString() ?? null,
+        duration: row.duration,
+        promptTokens: row.promptTokens,
+        completionTokens: row.completionTokens,
+        totalTokens: row.totalTokens,
+        cacheReadTokens: row.cacheReadTokens,
+        cacheWriteTokens: row.cacheWriteTokens,
+        cost: row.cost,
+    };
+}
+const USAGE_FIELDS = [
+    'promptTokens',
+    'completionTokens',
+    'totalTokens',
+    'cacheReadTokens',
+    'cacheWriteTokens',
+    'cost',
+];
+function sumUsage(entries) {
+    const total = {
+        promptTokens: null,
+        completionTokens: null,
+        totalTokens: null,
+        cacheReadTokens: null,
+        cacheWriteTokens: null,
+        cost: null,
+    };
+    for (const entry of entries) {
+        for (const field of USAGE_FIELDS) {
+            const value = entry[field];
+            if (value !== null)
+                total[field] = (total[field] ?? 0) + value;
+        }
+    }
+    return total;
+}
+//# sourceMappingURL=system-agent-execution.service.js.map