n8n 2.18.3 → 2.19.0

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

@@ -47,11 +47,14 @@ const api_types_1 = require("@n8n/api-types");
 const backend_common_1 = require("@n8n/backend-common");
 const config_1 = require("@n8n/config");
 const constants_1 = require("@n8n/constants");
+const db_1 = require("@n8n/db");
 const di_1 = require("@n8n/di");
 const url_service_1 = require("../../services/url.service");
 const instance_ai_1 = require("@n8n/instance-ai");
 const workflow_sdk_1 = require("@n8n/workflow-sdk");
 const nanoid_1 = require("nanoid");
+const uuid_1 = require("uuid");
+const constants_2 = require("../../constants");
 const source_control_preferences_service_ee_1 = require("../../modules/source-control.ee/source-control-preferences.service.ee");
 const ai_service_1 = require("../../services/ai.service");
 const push_1 = require("../../push");
@@ -75,6 +78,7 @@ function createInertAbortSignal() {
     return new AbortController().signal;
 }
 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 getProxyFetch() {
     const proxyUrl = process.env.HTTPS_PROXY || process.env.HTTP_PROXY;
@@ -88,7 +92,7 @@ function getProxyFetch() {
     }));
 }
 let InstanceAiService = class InstanceAiService {
-    constructor(logger, globalConfig, adapterService, eventBus, settingsService, compositeStore, compactionService, aiService, push, threadRepo, urlService, dbSnapshotStorage, dbIterationLogStorage, sourceControlPreferencesService, telemetry) {
+    constructor(logger, globalConfig, adapterService, eventBus, settingsService, compositeStore, compactionService, aiService, push, threadRepo, urlService, dbSnapshotStorage, dbIterationLogStorage, sourceControlPreferencesService, telemetry, userRepository, aiBuilderTemporaryWorkflowRepository) {
         this.adapterService = adapterService;
         this.eventBus = eventBus;
         this.settingsService = settingsService;
@@ -102,6 +106,8 @@ let InstanceAiService = class InstanceAiService {
         this.dbIterationLogStorage = dbIterationLogStorage;
         this.sourceControlPreferencesService = sourceControlPreferencesService;
         this.telemetry = telemetry;
+        this.userRepository = userRepository;
+        this.aiBuilderTemporaryWorkflowRepository = aiBuilderTemporaryWorkflowRepository;
         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);
@@ -218,9 +224,9 @@ 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));
+            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);
+        return new instance_ai_1.BuilderSandboxFactory(config, undefined, this.logger);
     }
     async getOrCreateWorkspace(threadId, user) {
         const existing = this.sandboxes.get(threadId);
@@ -262,6 +268,20 @@ let InstanceAiService = class InstanceAiService {
             headers: { Authorization: `${token.tokenType} ${token.accessToken}` },
         };
     }
+    async resolveAgentModelConfig(user) {
+        if (this.aiService.isProxyEnabled()) {
+            const client = await this.aiService.getClient();
+            const proxyBaseUrl = client.getApiProxyBaseUrl();
+            const tokenManager = new proxy_token_manager_1.ProxyTokenManager(async () => {
+                return await client.getBuilderApiProxyToken({ id: user.id }, { userMessageId: (0, nanoid_1.nanoid)() });
+            });
+            return await this.resolveProxyModel(user, proxyBaseUrl, tokenManager);
+        }
+        const httpProxyModel = await this.resolveHttpProxyModel(user);
+        if (httpProxyModel)
+            return httpProxyModel;
+        return await this.settingsService.resolveModelConfig(user);
+    }
     async resolveProxyModel(user, proxyBaseUrl, tokenManager) {
         const modelName = await this.settingsService.resolveModelName(user);
         const { createAnthropic } = await Promise.resolve().then(() => __importStar(require('@ai-sdk/anthropic')));
@@ -274,6 +294,9 @@ let InstanceAiService = class InstanceAiService {
                 for (const [k, v] of Object.entries(auth)) {
                     headers.set(k, v);
                 }
+                for (const [k, v] of Object.entries((0, api_types_1.buildProxyHeaders)({ feature: 'instance-ai', n8nVersion: constants_2.N8N_VERSION }))) {
+                    headers.set(k, v);
+                }
                 return await globalThis.fetch(input, { ...init, headers });
             },
         });
@@ -305,7 +328,18 @@ let InstanceAiService = class InstanceAiService {
             return;
         if (this.creditedThreads.has(threadId))
             return;
-        const thread = await this.threadRepo.findOneBy({ id: threadId });
+        let thread;
+        try {
+            thread = await this.threadRepo.findOneBy({ id: threadId });
+        }
+        catch (error) {
+            this.logger.warn('Failed to check Instance AI credit status', {
+                threadId,
+                runId,
+                error: getErrorMessage(error),
+            });
+            return;
+        }
         if (!thread)
             return;
         if (thread.metadata?.creditCounted) {
@@ -502,6 +536,63 @@ let InstanceAiService = class InstanceAiService {
             },
         });
     }
+    async submitLangsmithFeedback(user, threadId, responseId, payload) {
+        const anchor = await this.dbSnapshotStorage.findLangsmithAnchor(threadId, responseId);
+        if (!anchor) {
+            this.logger.debug('No LangSmith anchor for feedback; skipping annotation', {
+                threadId,
+                responseId,
+            });
+            return;
+        }
+        let tracingProxyConfig;
+        if (this.aiService.isProxyEnabled()) {
+            try {
+                const client = await this.aiService.getClient();
+                const baseUrl = client.getApiProxyBaseUrl();
+                const manager = new proxy_token_manager_1.ProxyTokenManager(async () => await client.getBuilderApiProxyToken({ id: user.id }, { userMessageId: (0, nanoid_1.nanoid)() }));
+                tracingProxyConfig = {
+                    apiUrl: baseUrl + '/langsmith',
+                    getAuthHeaders: async () => await manager.getAuthHeaders(),
+                };
+            }
+            catch (error) {
+                this.logger.warn('Failed to build LangSmith proxy config for feedback', {
+                    threadId,
+                    responseId,
+                    error: getErrorMessage(error),
+                });
+                return;
+            }
+        }
+        const key = 'user_score';
+        const feedbackId = (0, uuid_1.v5)(`${key}:${responseId}`, INSTANCE_AI_FEEDBACK_NAMESPACE);
+        try {
+            await (0, instance_ai_1.submitLangsmithUserFeedback)({
+                langsmithRunId: anchor.langsmithRunId,
+                langsmithTraceId: anchor.langsmithTraceId,
+                key,
+                score: payload.rating === 'up' ? 1 : 0,
+                value: payload.rating,
+                comment: payload.comment,
+                feedbackId,
+                sourceInfo: {
+                    thread_id: threadId,
+                    response_id: responseId,
+                    user_id: user.id,
+                    rating: payload.rating,
+                },
+                proxyConfig: tracingProxyConfig,
+            });
+        }
+        catch (error) {
+            this.logger.warn('Failed to submit LangSmith feedback', {
+                threadId,
+                responseId,
+                error: getErrorMessage(error),
+            });
+        }
+    }
     startRun(user, threadId, message, researchMode, attachments, timeZone, pushRef) {
         const { runId, abortController, messageGroupId } = this.runState.startRun({
             threadId,
@@ -549,25 +640,7 @@ let InstanceAiService = class InstanceAiService {
         }
         if (suspended) {
             suspended.abortController.abort();
-            void this.finalizeRunTracing(suspended.runId, suspended.tracing, {
-                status: 'cancelled',
-                reason: 'user_cancelled',
-            });
-            this.eventBus.publish(threadId, {
-                type: 'run-finish',
-                runId: suspended.runId,
-                agentId: ORCHESTRATOR_AGENT_ID,
-                payload: { status: 'cancelled', reason: 'user_cancelled' },
-            });
-            void this.saveAgentTreeSnapshot(threadId, suspended.runId, this.dbSnapshotStorage, true);
-            if (suspended.mastraRunId) {
-                void this.cleanupMastraSnapshots(suspended.mastraRunId);
-            }
-            void this.maybeFinalizeRunTraceRoot(suspended.runId, {
-                status: 'cancelled',
-                reason: 'user_cancelled',
-                metadata: { completion_source: 'orchestrator' },
-            });
+            void this.finalizeCancelledSuspendedRun(suspended);
         }
     }
     sendCorrectionToTask(threadId, taskId, correction) {
@@ -632,6 +705,10 @@ let InstanceAiService = class InstanceAiService {
     }
     initGateway(userId, data) {
         this.gatewayRegistry.initGateway(userId, data);
+        this.telemetry.track('User connected to Computer Use', {
+            user_id: userId,
+            tool_groups: data.toolCategories.filter((c) => c.enabled).map((c) => c.name),
+        });
     }
     resolveGatewayRequest(userId, requestId, result, error) {
         return this.gatewayRegistry.resolveGatewayRequest(userId, requestId, result, error);
@@ -687,6 +764,7 @@ let InstanceAiService = class InstanceAiService {
         this.threadPushRef.delete(threadId);
         this.deleteTraceContextsForThread(threadId);
         await this.destroySandbox(threadId);
+        await this.reapAiTemporaryForThreadCleanup(threadId);
         this.eventBus.clearThread(threadId);
     }
     async shutdown() {
@@ -823,13 +901,23 @@ let InstanceAiService = class InstanceAiService {
                 return await client.getBuilderApiProxyToken({ id: user.id }, { userMessageId: (0, nanoid_1.nanoid)() });
             });
             tokenManager = manager;
+            const featureHeaders = (0, api_types_1.buildProxyHeaders)({
+                feature: 'instance-ai',
+                n8nVersion: constants_2.N8N_VERSION,
+            });
             searchProxyConfig = {
                 apiUrl: proxyBaseUrl + '/brave-search',
-                getAuthHeaders: async () => await manager.getAuthHeaders(),
+                getAuthHeaders: async () => ({
+                    ...(await manager.getAuthHeaders()),
+                    ...featureHeaders,
+                }),
             };
             tracingProxyConfig = {
                 apiUrl: proxyBaseUrl + '/langsmith',
-                getAuthHeaders: async () => await manager.getAuthHeaders(),
+                getAuthHeaders: async () => ({
+                    ...(await manager.getAuthHeaders()),
+                    ...featureHeaders,
+                }),
             };
         }
         const context = this.adapterService.createContext(user, {
@@ -866,8 +954,7 @@ let InstanceAiService = class InstanceAiService {
         }
         const modelId = proxyBaseUrl && tokenManager
             ? await this.resolveProxyModel(user, proxyBaseUrl, tokenManager)
-            : ((await this.resolveHttpProxyModel(user)) ??
-                (await this.settingsService.resolveModelConfig(user)));
+            : await this.resolveAgentModelConfig(user);
         const memory = (0, instance_ai_1.createMemory)(this.createMemoryConfig());
         await this.ensureThreadExists(memory, threadId, user.id);
         const taskStorage = new instance_ai_1.MastraTaskStorage(memory);
@@ -1031,7 +1118,7 @@ let InstanceAiService = class InstanceAiService {
         }
         await this.schedulePlannedTasks(user, task.threadId);
     }
-    async startInternalFollowUpRun(user, threadId, message, researchMode, messageGroupId) {
+    async startInternalFollowUpRun(user, threadId, message, researchMode, messageGroupId, isReplanFollowUp = false) {
         if (this.runState.hasLiveRun(threadId)) {
             this.logger.warn('Skipping internal follow-up: active run exists', { threadId });
             return '';
@@ -1042,7 +1129,7 @@ let InstanceAiService = class InstanceAiService {
             researchMode,
             messageGroupId,
         });
-        void this.executeRun(user, threadId, runId, message, abortController, researchMode, undefined, messageGroupId);
+        void this.executeRun(user, threadId, runId, message, abortController, researchMode, undefined, messageGroupId, undefined, isReplanFollowUp);
         return runId;
     }
     async schedulePlannedTasks(user, threadId) {
@@ -1064,7 +1151,7 @@ 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);
+            await this.startInternalFollowUpRun(user, threadId, this.buildPlannedTaskFollowUpMessage('replan', action.graph, action.failedTask), this.runState.getThreadResearchMode(threadId), action.graph.messageGroupId, true);
             return;
         }
         if (action.type === 'synthesize') {
@@ -1079,11 +1166,12 @@ let InstanceAiService = class InstanceAiService {
         }
         await this.doSchedulePlannedTasks(user, threadId);
     }
-    async executeRun(user, threadId, runId, message, abortController, researchMode, attachments, messageGroupId, timeZone) {
+    async executeRun(user, threadId, runId, message, abortController, researchMode, attachments, messageGroupId, timeZone, isReplanFollowUp = false) {
         const signal = abortController.signal;
         let mastraRunId = '';
         let tracing;
         let messageTraceFinalization;
+        let aiCreatedWorkflowIds;
         try {
             const messageId = (0, nanoid_1.nanoid)();
             this.eventBus.publish(threadId, {
@@ -1105,7 +1193,9 @@ let InstanceAiService = class InstanceAiService {
             const mcpServers = this.parseMcpServers(this.instanceAiConfig.mcpServers);
             const executionPushRef = this.threadPushRef.get(threadId);
             const { context, memory, taskStorage, snapshotStorage, modelId, orchestrationContext } = await this.createExecutionEnvironment(user, threadId, runId, signal, researchMode, messageGroupId, executionPushRef);
+            aiCreatedWorkflowIds = context.aiCreatedWorkflowIds ??= new Set();
             orchestrationContext.currentUserMessage = message;
+            orchestrationContext.isReplanFollowUp = isReplanFollowUp;
             orchestrationContext.timeZone = timeZone ?? this.defaultTimeZone;
             if (attachments && attachments.length > 0) {
                 context.currentUserAttachments = attachments;
@@ -1374,9 +1464,11 @@ let InstanceAiService = class InstanceAiService {
                 modelId,
                 metadata: { completion_source: 'orchestrator' },
             };
+            const archivedWorkflowIds = await this.reapAiTemporaryFromRun(threadId, user, aiCreatedWorkflowIds);
             await this.finalizeRun(threadId, runId, result.status, snapshotStorage, {
                 userId: user.id,
                 modelId,
+                archivedWorkflowIds,
             });
             if (result.status === 'completed') {
                 await this.countCreditsIfFirst(user, threadId, runId);
@@ -1400,7 +1492,8 @@ let InstanceAiService = class InstanceAiService {
                     reason: 'user_cancelled',
                     metadata: { completion_source: 'orchestrator' },
                 };
-                this.publishRunFinish(threadId, runId, 'cancelled', 'user_cancelled');
+                const archivedWorkflowIds = await this.reapAiTemporaryFromRun(threadId, user, aiCreatedWorkflowIds);
+                this.publishRunFinish(threadId, runId, 'cancelled', 'user_cancelled', archivedWorkflowIds);
                 return;
             }
             const errorMessage = getErrorMessage(error);
@@ -1418,6 +1511,7 @@ let InstanceAiService = class InstanceAiService {
                 reason: errorMessage,
                 metadata: { completion_source: 'orchestrator' },
             };
+            const archivedWorkflowIds = await this.reapAiTemporaryFromRun(threadId, user, aiCreatedWorkflowIds);
             this.eventBus.publish(threadId, {
                 type: 'run-finish',
                 runId,
@@ -1425,6 +1519,7 @@ let InstanceAiService = class InstanceAiService {
                 payload: {
                     status: 'error',
                     reason: errorMessage,
+                    ...(archivedWorkflowIds.length > 0 ? { archivedWorkflowIds } : {}),
                 },
             });
         }
@@ -1568,7 +1663,10 @@ let InstanceAiService = class InstanceAiService {
                 outputText,
                 metadata: { completion_source: 'orchestrator' },
             };
-            await this.finalizeRun(opts.threadId, opts.runId, result.status, opts.snapshotStorage);
+            const archivedWorkflowIds = await this.reapAiTemporaryFromRun(opts.threadId, opts.user, undefined);
+            await this.finalizeRun(opts.threadId, opts.runId, result.status, opts.snapshotStorage, {
+                archivedWorkflowIds,
+            });
             if (result.status === 'completed') {
                 this.telemetry.track('Builder sent message', {
                     thread_id: opts.threadId,
@@ -1590,7 +1688,8 @@ let InstanceAiService = class InstanceAiService {
                     reason: 'user_cancelled',
                     metadata: { completion_source: 'orchestrator' },
                 };
-                this.publishRunFinish(opts.threadId, opts.runId, 'cancelled', 'user_cancelled');
+                const archivedWorkflowIds = await this.reapAiTemporaryFromRun(opts.threadId, opts.user, undefined);
+                this.publishRunFinish(opts.threadId, opts.runId, 'cancelled', 'user_cancelled', archivedWorkflowIds);
                 return;
             }
             const errorMessage = getErrorMessage(error);
@@ -1608,6 +1707,7 @@ let InstanceAiService = class InstanceAiService {
                 reason: errorMessage,
                 metadata: { completion_source: 'orchestrator' },
             };
+            const archivedWorkflowIds = await this.reapAiTemporaryFromRun(opts.threadId, opts.user, undefined);
             this.eventBus.publish(opts.threadId, {
                 type: 'run-finish',
                 runId: opts.runId,
@@ -1615,6 +1715,7 @@ let InstanceAiService = class InstanceAiService {
                 payload: {
                     status: 'error',
                     reason: errorMessage,
+                    ...(archivedWorkflowIds.length > 0 ? { archivedWorkflowIds } : {}),
                 },
             });
         }
@@ -1751,19 +1852,133 @@ let InstanceAiService = class InstanceAiService {
             num_steps: numSteps,
         });
     }
-    publishRunFinish(threadId, runId, status, reason) {
+    async reapAiTemporaryFromRun(threadId, user, createdWorkflowIds) {
+        let markedWorkflows = [];
+        try {
+            markedWorkflows = await this.aiBuilderTemporaryWorkflowRepository.findByThread(threadId);
+        }
+        catch (error) {
+            this.logger.warn('Failed to inspect AI-builder temporary workflows during run finish', {
+                threadId,
+                error: getErrorMessage(error),
+            });
+        }
+        const workflowIds = new Set([
+            ...markedWorkflows.map(({ workflowId }) => workflowId),
+            ...(createdWorkflowIds ?? []),
+        ]);
+        if (workflowIds.size === 0)
+            return [];
+        return await this.archiveAiTemporaryWorkflows(threadId, user, workflowIds);
+    }
+    async archiveAiTemporaryWorkflows(threadId, user, workflowIds) {
+        const adapter = this.adapterService.createContext(user, { threadId });
+        const archived = [];
+        for (const workflowId of workflowIds) {
+            try {
+                const didArchive = await adapter.workflowService.archiveIfAiTemporary(workflowId);
+                if (didArchive)
+                    archived.push(workflowId);
+            }
+            catch (error) {
+                this.logger.warn('Failed to reap AI-builder temporary workflow', {
+                    threadId,
+                    workflowId,
+                    error: getErrorMessage(error),
+                });
+            }
+        }
+        return archived;
+    }
+    async finalizeCancelledSuspendedRun(suspended) {
+        await this.finalizeRunTracing(suspended.runId, suspended.tracing, {
+            status: 'cancelled',
+            reason: 'user_cancelled',
+        });
+        const archivedWorkflowIds = await this.reapAiTemporaryFromRun(suspended.threadId, suspended.user, undefined);
+        this.publishRunFinish(suspended.threadId, suspended.runId, 'cancelled', 'user_cancelled', archivedWorkflowIds);
+        await this.saveAgentTreeSnapshot(suspended.threadId, suspended.runId, this.dbSnapshotStorage, true);
+        if (suspended.mastraRunId) {
+            void this.cleanupMastraSnapshots(suspended.mastraRunId);
+        }
+        await this.maybeFinalizeRunTraceRoot(suspended.runId, {
+            status: 'cancelled',
+            reason: 'user_cancelled',
+            metadata: { completion_source: 'orchestrator' },
+        });
+    }
+    async reapAiTemporaryForThreadCleanup(threadId) {
+        let markedWorkflows;
+        try {
+            markedWorkflows = await this.aiBuilderTemporaryWorkflowRepository.findByThread(threadId);
+        }
+        catch (error) {
+            this.logger.warn('Failed to inspect AI-builder temporary workflows during thread cleanup', {
+                threadId,
+                error: getErrorMessage(error),
+            });
+            return;
+        }
+        if (markedWorkflows.length === 0)
+            return;
+        let thread;
+        try {
+            thread = await this.threadRepo.findOneBy({ id: threadId });
+        }
+        catch (error) {
+            this.logger.warn('Failed to load thread owner for AI-builder temporary workflow cleanup', {
+                threadId,
+                markedWorkflowCount: markedWorkflows.length,
+                error: getErrorMessage(error),
+            });
+            return;
+        }
+        if (!thread?.resourceId) {
+            this.logger.warn('Skipping AI-builder temporary workflow cleanup for thread without owner', {
+                threadId,
+                markedWorkflowCount: markedWorkflows.length,
+            });
+            return;
+        }
+        let user;
+        try {
+            user = await this.userRepository.findOneBy({ id: thread.resourceId });
+        }
+        catch (error) {
+            this.logger.warn('Failed to load user for AI-builder temporary workflow cleanup', {
+                threadId,
+                userId: thread.resourceId,
+                markedWorkflowCount: markedWorkflows.length,
+                error: getErrorMessage(error),
+            });
+            return;
+        }
+        if (!user) {
+            this.logger.warn('Skipping AI-builder temporary workflow cleanup for missing thread owner', {
+                threadId,
+                userId: thread.resourceId,
+                markedWorkflowCount: markedWorkflows.length,
+            });
+            return;
+        }
+        await this.archiveAiTemporaryWorkflows(threadId, user, new Set(markedWorkflows.map(({ workflowId }) => workflowId)));
+    }
+    publishRunFinish(threadId, runId, status, reason, archivedWorkflowIds) {
         const effectiveStatus = status === 'errored' ? 'error' : status;
+        const hasArchived = archivedWorkflowIds && archivedWorkflowIds.length > 0;
         this.eventBus.publish(threadId, {
             type: 'run-finish',
             runId,
             agentId: ORCHESTRATOR_AGENT_ID,
-            payload: status === 'cancelled'
-                ? { status: effectiveStatus, reason: reason ?? 'user_cancelled' }
-                : { status: effectiveStatus },
+            payload: {
+                status: effectiveStatus,
+                ...(status === 'cancelled' ? { reason: reason ?? 'user_cancelled' } : {}),
+                ...(hasArchived ? { archivedWorkflowIds } : {}),
+            },
         });
     }
     async finalizeRun(threadId, runId, status, snapshotStorage, options) {
-        this.publishRunFinish(threadId, runId, status);
+        this.publishRunFinish(threadId, runId, status, undefined, options?.archivedWorkflowIds);
         if (status === 'completed') {
             await this.saveAgentTreeSnapshot(threadId, runId, snapshotStorage);
             if (options?.userId && options?.modelId) {
@@ -1835,11 +2050,18 @@ let InstanceAiService = class InstanceAiService {
                 events = this.eventBus.getEventsForRun(threadId, runId);
             }
             const agentTree = (0, instance_ai_1.buildAgentTreeFromEvents)(events);
+            const tracing = this.traceContextsByRunId.get(runId)?.tracing;
+            const saveOptions = {
+                messageGroupId,
+                runIds: groupRunIds,
+                langsmithRunId: tracing?.rootRun.id,
+                langsmithTraceId: tracing?.rootRun.traceId,
+            };
             if (isUpdate) {
-                await snapshotStorage.updateLast(threadId, agentTree, runId, messageGroupId, groupRunIds);
+                await snapshotStorage.updateLast(threadId, agentTree, runId, saveOptions);
             }
             else {
-                await snapshotStorage.save(threadId, agentTree, runId, messageGroupId, groupRunIds);
+                await snapshotStorage.save(threadId, agentTree, runId, saveOptions);
             }
         }
         catch (error) {
@@ -1876,6 +2098,8 @@ exports.InstanceAiService = InstanceAiService = __decorate([
         db_snapshot_storage_1.DbSnapshotStorage,
         db_iteration_log_storage_1.DbIterationLogStorage,
         source_control_preferences_service_ee_1.SourceControlPreferencesService,
-        telemetry_1.Telemetry])
+        telemetry_1.Telemetry,
+        db_1.UserRepository,
+        db_1.AiBuilderTemporaryWorkflowRepository])
 ], InstanceAiService);
 //# sourceMappingURL=instance-ai.service.js.map