n8n 2.16.0 → 2.17.0

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

@@ -1,13 +1,49 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
 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 __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InstanceAiAdapterService = void 0;
 exports.truncateResultData = truncateResultData;
@@ -16,6 +52,8 @@ exports.truncateNodeOutput = truncateNodeOutput;
 exports.extractNodeOutput = extractNodeOutput;
 exports.extractExecutionDebugInfo = extractExecutionDebugInfo;
 const node_crypto_1 = require("node:crypto");
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
 const instance_ai_1 = require("@n8n/instance-ai");
 const config_1 = require("@n8n/config");
 const constants_1 = require("@n8n/constants");
@@ -28,6 +66,7 @@ const di_1 = require("@n8n/di");
 const permissions_1 = require("@n8n/permissions");
 const typeorm_1 = require("@n8n/typeorm");
 const n8n_workflow_1 = require("n8n-workflow");
+const n8n_core_1 = require("n8n-core");
 const active_executions_1 = require("../../active-executions");
 const credentials_finder_service_1 = require("../../credentials/credentials-finder.service");
 const credentials_service_1 = require("../../credentials/credentials.service");
@@ -48,6 +87,7 @@ const workflow_finder_service_1 = require("../../workflows/workflow-finder.servi
 const workflow_history_service_1 = require("../../workflows/workflow-history/workflow-history.service");
 const workflow_service_1 = require("../../workflows/workflow.service");
 const workflow_service_ee_1 = require("../../workflows/workflow.service.ee");
+const telemetry_1 = require("../../telemetry");
 const workflow_runner_1 = require("../../workflow-runner");
 const workflow_execute_additional_data_1 = require("../../workflow-execute-additional-data");
 let InstanceAiAdapterService = class InstanceAiAdapterService {
@@ -55,14 +95,15 @@ let InstanceAiAdapterService = class InstanceAiAdapterService {
         if (this.nodesCache && Date.now() < this.nodesCache.expiresAt) {
             return await this.nodesCache.promise;
         }
-        const promise = this.loadNodesAndCredentials.collectTypes().then((result) => result.nodes);
+        const filePath = node_path_1.default.join(this.instanceSettings.staticCacheDir, 'types/nodes.json');
+        const promise = (0, promises_1.readFile)(filePath, 'utf-8').then((json) => (0, n8n_workflow_1.jsonParse)(json));
         this.nodesCache = { promise, expiresAt: Date.now() + this.NODES_CACHE_TTL_MS };
         promise.catch(() => {
             this.nodesCache = null;
         });
         return await promise;
     }
-    constructor(logger, globalConfig, workflowService, workflowFinderService, workflowRepository, sharedWorkflowRepository, projectRepository, executionRepository, credentialsService, credentialsFinderService, activeExecutions, workflowRunner, loadNodesAndCredentials, dataTableService, dataTableRepository, dynamicNodeParametersService, folderService, projectService, tagService, sourceControlPreferencesService, settingsService, workflowHistoryService, enterpriseWorkflowService, license, executionPersistence, eventService, roleService) {
+    constructor(logger, globalConfig, workflowService, workflowFinderService, workflowRepository, sharedWorkflowRepository, projectRepository, executionRepository, credentialsService, credentialsFinderService, activeExecutions, workflowRunner, loadNodesAndCredentials, instanceSettings, dataTableService, dataTableRepository, dynamicNodeParametersService, folderService, projectService, tagService, sourceControlPreferencesService, settingsService, workflowHistoryService, enterpriseWorkflowService, license, executionPersistence, eventService, roleService, telemetry) {
         this.workflowService = workflowService;
         this.workflowFinderService = workflowFinderService;
         this.workflowRepository = workflowRepository;
@@ -74,6 +115,7 @@ let InstanceAiAdapterService = class InstanceAiAdapterService {
         this.activeExecutions = activeExecutions;
         this.workflowRunner = workflowRunner;
         this.loadNodesAndCredentials = loadNodesAndCredentials;
+        this.instanceSettings = instanceSettings;
         this.dataTableService = dataTableService;
         this.dataTableRepository = dataTableRepository;
         this.dynamicNodeParametersService = dynamicNodeParametersService;
@@ -88,6 +130,7 @@ let InstanceAiAdapterService = class InstanceAiAdapterService {
         this.executionPersistence = executionPersistence;
         this.eventService = eventService;
         this.roleService = roleService;
+        this.telemetry = telemetry;
         this.nodesCache = null;
         this.NODES_CACHE_TTL_MS = 5 * 60 * 1000;
         this.webResearchCache = new web_research_1.LRUCache({
@@ -102,18 +145,17 @@ let InstanceAiAdapterService = class InstanceAiAdapterService {
         this.allowSendingParameterValues = globalConfig.ai.allowSendingParameterValues;
     }
     createContext(user, options) {
-        const { filesystemService, searchProxyConfig, pushRef } = options ?? {};
+        const { searchProxyConfig, pushRef, threadId } = options ?? {};
         return {
             userId: user.id,
-            workflowService: this.createWorkflowAdapter(user),
-            executionService: this.createExecutionAdapter(user, pushRef),
+            workflowService: this.createWorkflowAdapter(user, threadId),
+            executionService: this.createExecutionAdapter(user, pushRef, threadId),
             credentialService: this.createCredentialAdapter(user),
             nodeService: this.createNodeAdapter(user),
             dataTableService: this.createDataTableAdapter(user),
             webResearchService: this.createWebResearchAdapter(user, searchProxyConfig),
             workspaceService: this.createWorkspaceAdapter(user),
             licenseHints: this.buildLicenseHints(),
-            ...(filesystemService ? { filesystemService } : {}),
         };
     }
     buildLicenseHints() {
@@ -126,6 +168,11 @@ let InstanceAiAdapterService = class InstanceAiAdapterService {
         }
         return hints;
     }
+    assertInstanceNotReadOnly(resourceType) {
+        if (this.sourceControlPreferencesService.getPreferences().branchReadOnly) {
+            throw new Error(`Cannot modify ${resourceType} on a protected instance. This instance is in read-only mode.`);
+        }
+    }
     createProjectScopeHelpers(user) {
         const { projectRepository } = this;
         let personalProjectIdPromise = null;
@@ -148,8 +195,9 @@ let InstanceAiAdapterService = class InstanceAiAdapterService {
         };
         return { getPersonalProjectId, assertProjectScope, resolveProjectId };
     }
-    createWorkflowAdapter(user) {
-        const { workflowService, workflowFinderService, workflowRepository, sharedWorkflowRepository, workflowHistoryService, enterpriseWorkflowService, license, allowSendingParameterValues, } = this;
+    createWorkflowAdapter(user, threadId) {
+        const { workflowService, workflowFinderService, workflowRepository, sharedWorkflowRepository, workflowHistoryService, enterpriseWorkflowService, license, allowSendingParameterValues, telemetry, } = this;
+        const assertNotReadOnly = () => this.assertInstanceNotReadOnly('workflows');
         const { resolveProjectId } = this.createProjectScopeHelpers(user);
         const redactParameters = !allowSendingParameterValues;
         return {
@@ -182,9 +230,11 @@ let InstanceAiAdapterService = class InstanceAiAdapterService {
                 return toWorkflowDetail(workflow, { redactParameters });
             },
             async archive(workflowId) {
+                assertNotReadOnly();
                 await workflowService.archive(user, workflowId, { skipArchived: true });
             },
             async delete(workflowId) {
+                assertNotReadOnly();
                 await workflowService.delete(user, workflowId);
             },
             async publish(workflowId, options) {
@@ -196,6 +246,12 @@ let InstanceAiAdapterService = class InstanceAiAdapterService {
                 if (!wf.activeVersionId) {
                     throw new Error(`Workflow ${workflowId} was not activated — no active version set`);
                 }
+                if (threadId) {
+                    telemetry.track('Builder published workflow', {
+                        thread_id: threadId,
+                        executed_by: 'ai',
+                    });
+                }
                 return { activeVersionId: wf.activeVersionId };
             },
             async unpublish(workflowId) {
@@ -210,6 +266,7 @@ let InstanceAiAdapterService = class InstanceAiAdapterService {
                 return toWorkflowJSON(wf, { redactParameters });
             },
             async createFromWorkflowJSON(json, options) {
+                assertNotReadOnly();
                 const projectId = await resolveProjectId(['workflow:create'], options?.projectId);
                 const settings = (json.settings ?? {});
                 if (settings.redactionPolicy !== undefined) {
@@ -243,9 +300,16 @@ let InstanceAiAdapterService = class InstanceAiAdapterService {
                     updateData = await enterpriseWorkflowService.preventTampering(updateData, saved.id, user);
                 }
                 const updated = await workflowService.update(user, updateData, saved.id);
+                if (threadId) {
+                    telemetry.track('Builder created workflow', {
+                        thread_id: threadId,
+                        workflow_id: updated.id,
+                    });
+                }
                 return toWorkflowDetail(updated, { redactParameters });
             },
             async updateFromWorkflowJSON(workflowId, json, _options) {
+                assertNotReadOnly();
                 const settings = (json.settings ?? {});
                 if (settings.redactionPolicy !== undefined) {
                     const canUpdateRedaction = await (0, check_access_1.userHasScopes)(user, ['workflow:updateRedactionSetting'], false, { workflowId });
@@ -264,6 +328,12 @@ let InstanceAiAdapterService = class InstanceAiAdapterService {
                     updateData = await enterpriseWorkflowService.preventTampering(updateData, workflowId, user);
                 }
                 const updated = await workflowService.update(user, updateData, workflowId);
+                if (threadId) {
+                    telemetry.track('Builder modified workflow', {
+                        thread_id: threadId,
+                        workflow_id: workflowId,
+                    });
+                }
                 return toWorkflowDetail(updated, { redactParameters });
             },
             async listVersions(workflowId, options) {
@@ -328,8 +398,9 @@ let InstanceAiAdapterService = class InstanceAiAdapterService {
                 : {}),
         };
     }
-    createExecutionAdapter(user, pushRef) {
-        const { workflowFinderService, workflowRunner, activeExecutions, executionRepository, allowSendingParameterValues, license, roleService, } = this;
+    createExecutionAdapter(user, pushRef, threadId) {
+        const { workflowFinderService, workflowRunner, activeExecutions, executionRepository, allowSendingParameterValues, license, roleService, telemetry, } = this;
+        const assertNotReadOnly = () => this.assertInstanceNotReadOnly('executions');
         const DEFAULT_TIMEOUT_MS = 5 * constants_1.Time.minutes.toMilliseconds;
         const MAX_TIMEOUT_MS = 10 * constants_1.Time.minutes.toMilliseconds;
         const assertExecutionAccess = async (executionId, scopes = ['workflow:read']) => {
@@ -385,6 +456,7 @@ let InstanceAiAdapterService = class InstanceAiAdapterService {
                 }));
             },
             async run(workflowId, inputData, options) {
+                assertNotReadOnly();
                 const workflow = await workflowFinderService.findWorkflowForUser(workflowId, user, [
                     'workflow:execute',
                 ]);
@@ -473,6 +545,14 @@ let InstanceAiAdapterService = class InstanceAiAdapterService {
                         throw error;
                     }
                 }
+                if (threadId) {
+                    telemetry.track('Builder executed workflow', {
+                        thread_id: threadId,
+                        executed_by: 'ai',
+                        pinned_node_count: Object.keys(runData.pinData ?? {}).length,
+                        exec_type: runData.executionMode,
+                    });
+                }
                 return await extractExecutionResult(executionRepository, executionId, allowSendingParameterValues);
             },
             async getStatus(executionId) {
@@ -491,6 +571,7 @@ let InstanceAiAdapterService = class InstanceAiAdapterService {
                 return await extractExecutionResult(executionRepository, executionId, allowSendingParameterValues);
             },
             async stop(executionId) {
+                assertNotReadOnly();
                 await assertExecutionAccess(executionId, ['workflow:execute']);
                 if (!activeExecutions.has(executionId)) {
                     return {
@@ -541,8 +622,6 @@ let InstanceAiAdapterService = class InstanceAiAdapterService {
                     id: c.id,
                     name: c.name,
                     type: c.type,
-                    createdAt: c.createdAt.toISOString(),
-                    updatedAt: c.updatedAt.toISOString(),
                 }));
             },
             async get(credentialId) {
@@ -551,8 +630,6 @@ let InstanceAiAdapterService = class InstanceAiAdapterService {
                     id: credential.id,
                     name: credential.name,
                     type: credential.type,
-                    createdAt: credential.createdAt.toISOString(),
-                    updatedAt: credential.updatedAt.toISOString(),
                 };
             },
             async delete(credentialId) {
@@ -686,15 +763,54 @@ let InstanceAiAdapterService = class InstanceAiAdapterService {
                 }
                 return results;
             },
+            async getAccountContext(credentialId) {
+                const credential = await credentialsFinderService.findCredentialForUser(credentialId, user, ['credential:read']);
+                if (!credential) {
+                    return { accountIdentifier: undefined };
+                }
+                const mask = (id) => {
+                    const atIdx = id.indexOf('@');
+                    if (atIdx > 0) {
+                        const local = id.slice(0, atIdx);
+                        const domain = id.slice(atIdx);
+                        const keep = Math.min(2, local.length);
+                        return local.slice(0, keep) + '***' + domain;
+                    }
+                    if (id.length <= 3)
+                        return id;
+                    return id.slice(0, 2) + '***' + id.slice(-1);
+                };
+                try {
+                    const redacted = credentialsService.decrypt(credential, false);
+                    if (typeof redacted.accountIdentifier === 'string' && redacted.accountIdentifier) {
+                        return { accountIdentifier: mask(redacted.accountIdentifier) };
+                    }
+                    for (const key of ['email', 'user', 'username', 'account', 'serviceAccountEmail']) {
+                        const value = redacted[key];
+                        if (typeof value === 'string' && value) {
+                            return { accountIdentifier: mask(value) };
+                        }
+                    }
+                    const raw = credentialsService.decrypt(credential, true);
+                    const tokenData = raw.oauthTokenData;
+                    if (tokenData && typeof tokenData === 'object') {
+                        const { OauthService } = await Promise.resolve().then(() => __importStar(require('../../oauth/oauth.service')));
+                        const identifier = OauthService.extractAccountIdentifier(tokenData);
+                        if (identifier) {
+                            return { accountIdentifier: mask(identifier) };
+                        }
+                    }
+                    return { accountIdentifier: undefined };
+                }
+                catch {
+                    return { accountIdentifier: undefined };
+                }
+            },
         };
     }
     createDataTableAdapter(user) {
-        const { dataTableService, dataTableRepository, sourceControlPreferencesService } = this;
-        const assertInstanceNotReadOnly = () => {
-            if (sourceControlPreferencesService.getPreferences().branchReadOnly) {
-                throw new Error('Cannot modify data tables on a protected instance. This instance is in read-only mode.');
-            }
-        };
+        const { dataTableService, dataTableRepository } = this;
+        const assertNotReadOnly = () => this.assertInstanceNotReadOnly('data tables');
         const { resolveProjectId } = this.createProjectScopeHelpers(user);
         const resolveProjectIdForTable = async (scopes, dataTableId) => {
             const allowed = await (0, check_access_1.userHasScopes)(user, scopes, false, { dataTableId });
@@ -704,6 +820,14 @@ let InstanceAiAdapterService = class InstanceAiAdapterService {
             const table = await dataTableRepository.findOneByOrFail({ id: dataTableId });
             return table.projectId;
         };
+        const resolveTableMeta = async (scopes, dataTableId) => {
+            const allowed = await (0, check_access_1.userHasScopes)(user, scopes, false, { dataTableId });
+            if (!allowed) {
+                throw new Error(`Data table "${dataTableId}" not found`);
+            }
+            const table = await dataTableRepository.findOneByOrFail({ id: dataTableId });
+            return { projectId: table.projectId, tableName: table.name };
+        };
         return {
             async list(options) {
                 const projectId = await resolveProjectId(['dataTable:listProject'], options?.projectId);
@@ -720,7 +844,7 @@ let InstanceAiAdapterService = class InstanceAiAdapterService {
                 }));
             },
             async create(name, columns, options) {
-                assertInstanceNotReadOnly();
+                assertNotReadOnly();
                 const projectId = await resolveProjectId(['dataTable:create'], options?.projectId);
                 const result = await dataTableService.createDataTable(projectId, { name, columns });
                 return {
@@ -733,7 +857,7 @@ let InstanceAiAdapterService = class InstanceAiAdapterService {
                 };
             },
             async delete(dataTableId) {
-                assertInstanceNotReadOnly();
+                assertNotReadOnly();
                 const projectId = await resolveProjectIdForTable(['dataTable:delete'], dataTableId);
                 await dataTableService.deleteDataTable(dataTableId, projectId);
             },
@@ -748,7 +872,7 @@ let InstanceAiAdapterService = class InstanceAiAdapterService {
                 }));
             },
             async addColumn(dataTableId, column) {
-                assertInstanceNotReadOnly();
+                assertNotReadOnly();
                 const projectId = await resolveProjectIdForTable(['dataTable:update'], dataTableId);
                 const result = await dataTableService.addColumn(dataTableId, projectId, column);
                 return {
@@ -759,12 +883,12 @@ let InstanceAiAdapterService = class InstanceAiAdapterService {
                 };
             },
             async deleteColumn(dataTableId, columnId) {
-                assertInstanceNotReadOnly();
+                assertNotReadOnly();
                 const projectId = await resolveProjectIdForTable(['dataTable:update'], dataTableId);
                 await dataTableService.deleteColumn(dataTableId, projectId, columnId);
             },
             async renameColumn(dataTableId, columnId, newName) {
-                assertInstanceNotReadOnly();
+                assertNotReadOnly();
                 const projectId = await resolveProjectIdForTable(['dataTable:update'], dataTableId);
                 await dataTableService.renameColumn(dataTableId, projectId, columnId, {
                     name: newName,
@@ -779,22 +903,37 @@ let InstanceAiAdapterService = class InstanceAiAdapterService {
                 });
             },
             async insertRows(dataTableId, rows) {
-                assertInstanceNotReadOnly();
-                const projectId = await resolveProjectIdForTable(['dataTable:writeRow'], dataTableId);
+                assertNotReadOnly();
+                const { projectId, tableName } = await resolveTableMeta(['dataTable:writeRow'], dataTableId);
                 const result = await dataTableService.insertRows(dataTableId, projectId, rows, 'count');
-                return { insertedCount: typeof result === 'number' ? result : rows.length };
+                return {
+                    insertedCount: typeof result === 'number' ? result : rows.length,
+                    dataTableId,
+                    tableName,
+                    projectId,
+                };
             },
             async updateRows(dataTableId, filter, data) {
-                assertInstanceNotReadOnly();
-                const projectId = await resolveProjectIdForTable(['dataTable:writeRow'], dataTableId);
+                assertNotReadOnly();
+                const { projectId, tableName } = await resolveTableMeta(['dataTable:writeRow'], dataTableId);
                 const result = await dataTableService.updateRows(dataTableId, projectId, { filter: filter, data: data }, true);
-                return { updatedCount: Array.isArray(result) ? result.length : 0 };
+                return {
+                    updatedCount: Array.isArray(result) ? result.length : 0,
+                    dataTableId,
+                    tableName,
+                    projectId,
+                };
             },
             async deleteRows(dataTableId, filter) {
-                assertInstanceNotReadOnly();
-                const projectId = await resolveProjectIdForTable(['dataTable:writeRow'], dataTableId);
+                assertNotReadOnly();
+                const { projectId, tableName } = await resolveTableMeta(['dataTable:writeRow'], dataTableId);
                 const result = await dataTableService.deleteRows(dataTableId, projectId, { filter: filter }, true);
-                return { deletedCount: Array.isArray(result) ? result.length : 0 };
+                return {
+                    deletedCount: Array.isArray(result) ? result.length : 0,
+                    dataTableId,
+                    tableName,
+                    projectId,
+                };
             },
         };
     }
@@ -1123,6 +1262,13 @@ let InstanceAiAdapterService = class InstanceAiAdapterService {
                 for (const credType of Object.keys(credentialIssues)) {
                     credentialTypes.add(credType);
                 }
+                if (parameters.authentication === 'genericCredentialType' && parameters.genericAuthType) {
+                    credentialTypes.add(parameters.genericAuthType);
+                }
+                else if (parameters.authentication === 'predefinedCredentialType' &&
+                    parameters.nodeCredentialType) {
+                    credentialTypes.add(parameters.nodeCredentialType);
+                }
                 if (existingCredentials) {
                     for (const credType of Object.keys(existingCredentials)) {
                         credentialTypes.add(credType);
@@ -1204,6 +1350,7 @@ let InstanceAiAdapterService = class InstanceAiAdapterService {
     }
     createWorkspaceAdapter(user) {
         const { projectService, folderService, tagService, workflowFinderService, workflowService, executionRepository, executionPersistence, eventService, } = this;
+        const assertNotReadOnly = (resource) => this.assertInstanceNotReadOnly(resource);
         const { assertProjectScope } = this.createProjectScopeHelpers(user);
         const adapter = {
             async getProject(projectId) {
@@ -1232,6 +1379,7 @@ let InstanceAiAdapterService = class InstanceAiAdapterService {
                         }));
                     },
                     async createFolder(name, projectId, parentFolderId) {
+                        assertNotReadOnly('folders');
                         await assertProjectScope(['folder:create'], projectId);
                         const folder = await folderService.createFolder({ name, parentFolderId: parentFolderId ?? undefined }, projectId);
                         return {
@@ -1241,12 +1389,14 @@ let InstanceAiAdapterService = class InstanceAiAdapterService {
                         };
                     },
                     async deleteFolder(folderId, projectId, transferToFolderId) {
+                        assertNotReadOnly('folders');
                         await assertProjectScope(['folder:delete'], projectId);
                         await folderService.deleteFolder(user, folderId, projectId, {
                             transferToFolderId: transferToFolderId ?? undefined,
                         });
                     },
                     async moveWorkflowToFolder(workflowId, folderId) {
+                        assertNotReadOnly('workflows');
                         const workflow = await workflowFinderService.findWorkflowForUser(workflowId, user, [
                             'workflow:update',
                         ]);
@@ -1260,6 +1410,7 @@ let InstanceAiAdapterService = class InstanceAiAdapterService {
                 }
                 : {}),
             async tagWorkflow(workflowId, tagNames) {
+                assertNotReadOnly('workflows');
                 const workflow = await workflowFinderService.findWorkflowForUser(workflowId, user, [
                     'workflow:update',
                 ]);
@@ -1305,6 +1456,7 @@ let InstanceAiAdapterService = class InstanceAiAdapterService {
                 return { id: saved.id, name: saved.name };
             },
             async cleanupTestExecutions(workflowId, options) {
+                assertNotReadOnly('executions');
                 const workflow = await workflowFinderService.findWorkflowForUser(workflowId, user, [
                     'workflow:execute',
                 ]);
@@ -1363,6 +1515,7 @@ exports.InstanceAiAdapterService = InstanceAiAdapterService = __decorate([
         active_executions_1.ActiveExecutions,
         workflow_runner_1.WorkflowRunner,
         load_nodes_and_credentials_1.LoadNodesAndCredentials,
+        n8n_core_1.InstanceSettings,
         data_table_service_1.DataTableService,
         data_table_repository_1.DataTableRepository,
         dynamic_node_parameters_service_1.DynamicNodeParametersService,
@@ -1376,7 +1529,8 @@ exports.InstanceAiAdapterService = InstanceAiAdapterService = __decorate([
         license_1.License,
         execution_persistence_1.ExecutionPersistence,
         event_service_1.EventService,
-        role_service_1.RoleService])
+        role_service_1.RoleService,
+        telemetry_1.Telemetry])
 ], InstanceAiAdapterService);
 const MAX_RESULT_CHARS = 20_000;
 const MAX_NODE_OUTPUT_CHARS = 1_000;