n8n 2.30.4 → 2.31.0

package/dist/modules/instance-ai/instance-ai.adapter.service.d.ts

@@ -1,7 +1,8 @@
-import type { InstanceAiContext, ExecutionResult, ExecutionDebugInfo, NodeOutputResult, ServiceProxyConfig } from '@n8n/instance-ai';
+import type { InstanceAiContext, ExecutionResult, ExecutionDebugInfo, NodeOutputResult, ServiceProxyConfig, EvaluationConfigSummary, UpsertEvaluationConfigInput } from '@n8n/instance-ai';
 import { GlobalConfig } from '@n8n/config';
-import type { User } from '@n8n/db';
+import type { User, EvaluationConfig } from '@n8n/db';
 import { InstanceAiSettingsService } from './instance-ai-settings.service';
+import { WorkflowTemplatesService } from './workflow-templates.service';
 import { AiBuilderTemporaryWorkflowRepository, ExecutionRepository, ProjectRepository, SharedWorkflowRepository, WorkflowRepository } from '@n8n/db';
 import { Logger } from '@n8n/backend-common';
 import { OutboundHttp, SsrfProtectionService } from '@n8n/backend-network';
@@ -9,6 +10,7 @@ import { type ExecutionError } from 'n8n-workflow';
 import { ActiveExecutions } from '../../active-executions';
 import { CredentialsFinderService } from '../../credentials/credentials-finder.service';
 import { CredentialsService } from '../../credentials/credentials.service';
+import { EvaluationConfigService } from '../../evaluation.ee/evaluation-config.service';
 import { EventService } from '../../events/event.service';
 import { ExecutionPersistence } from '../../executions/execution-persistence';
 import { License } from '../../license';
@@ -65,28 +67,37 @@ export declare class InstanceAiAdapterService {
     private readonly ssrfProtectionService;
     private readonly outboundHttp;
     private readonly aiGatewayService;
+    private readonly workflowTemplatesService;
     private readonly nodeCatalogService?;
+    private readonly evaluationConfigService?;
     private readonly logger;
     private readonly allowSendingParameterValues;
     private nodesCache;
     private readonly NODES_CACHE_TTL_MS;
     private templatesService;
     private getNodesFromCache;
-    constructor(logger: Logger, globalConfig: GlobalConfig, workflowService: WorkflowService, workflowFinderService: WorkflowFinderService, workflowRepository: WorkflowRepository, sharedWorkflowRepository: SharedWorkflowRepository, projectRepository: ProjectRepository, executionRepository: ExecutionRepository, credentialsService: CredentialsService, credentialsFinderService: CredentialsFinderService, activeExecutions: ActiveExecutions, workflowRunner: WorkflowRunner, loadNodesAndCredentials: LoadNodesAndCredentials, nodeTypes: NodeTypes, instanceSettings: InstanceSettings, dataTableService: DataTableService, dataTableRepository: DataTableRepository, nodeResourceExplorerService: NodeResourceExplorerService, folderService: FolderService, projectService: ProjectService, tagService: TagService, sourceControlPreferencesService: SourceControlPreferencesService, settingsService: InstanceAiSettingsService, workflowHistoryService: WorkflowHistoryService, enterpriseWorkflowService: EnterpriseWorkflowService, license: License, executionPersistence: ExecutionPersistence, eventService: EventService, roleService: RoleService, telemetry: Telemetry, aiBuilderTemporaryWorkflowRepository: AiBuilderTemporaryWorkflowRepository, ssrfProtectionService: SsrfProtectionService, outboundHttp: OutboundHttp, aiGatewayService: AiGatewayService, nodeCatalogService?: NodeCatalogService | undefined);
+    constructor(logger: Logger, globalConfig: GlobalConfig, workflowService: WorkflowService, workflowFinderService: WorkflowFinderService, workflowRepository: WorkflowRepository, sharedWorkflowRepository: SharedWorkflowRepository, projectRepository: ProjectRepository, executionRepository: ExecutionRepository, credentialsService: CredentialsService, credentialsFinderService: CredentialsFinderService, activeExecutions: ActiveExecutions, workflowRunner: WorkflowRunner, loadNodesAndCredentials: LoadNodesAndCredentials, nodeTypes: NodeTypes, instanceSettings: InstanceSettings, dataTableService: DataTableService, dataTableRepository: DataTableRepository, nodeResourceExplorerService: NodeResourceExplorerService, folderService: FolderService, projectService: ProjectService, tagService: TagService, sourceControlPreferencesService: SourceControlPreferencesService, settingsService: InstanceAiSettingsService, workflowHistoryService: WorkflowHistoryService, enterpriseWorkflowService: EnterpriseWorkflowService, license: License, executionPersistence: ExecutionPersistence, eventService: EventService, roleService: RoleService, telemetry: Telemetry, aiBuilderTemporaryWorkflowRepository: AiBuilderTemporaryWorkflowRepository, ssrfProtectionService: SsrfProtectionService, outboundHttp: OutboundHttp, aiGatewayService: AiGatewayService, workflowTemplatesService: WorkflowTemplatesService, nodeCatalogService?: NodeCatalogService | undefined, evaluationConfigService?: EvaluationConfigService | undefined);
     createContext(user: User, options?: {
         searchProxyConfig?: ServiceProxyConfig;
         pushRef?: string;
         threadId?: string;
         projectId?: string;
         credentialIdAllowlist?: string[];
+        agentId?: string;
     }): InstanceAiContext;
+    private getBuilderDelegateAdapter;
+    private getGatewayConfigOrNull;
+    private buildAiGatewayNodeMeta;
     private getTemplatesService;
+    private createWorkflowTemplateAdapter;
     private buildLicenseHints;
+    private trackGatewayAvailability;
     private assertInstanceNotReadOnly;
     private createProjectScopeHelpers;
     private createWorkflowAdapter;
     private createExecutionAdapter;
     private createCredentialAdapter;
+    private createEvaluationConfigAdapter;
     private createDataTableAdapter;
     private readonly webResearchCache;
     private readonly searchCache;
@@ -124,6 +135,81 @@ export type ResolveDataTableResult = {
     kind: 'ambiguous';
     candidates: DataTableRecord[];
 };
+export declare function buildEvaluationConfigDto(input: UpsertEvaluationConfigInput): {
+    name: string;
+    startNodeName: string;
+    endNodeName: string;
+    metrics: ({
+        type: "expression";
+        id: string;
+        name: string;
+        config: {
+            expression: string;
+            outputType: "boolean" | "numeric";
+        };
+    } | {
+        type: "llm_judge";
+        id: string;
+        name: string;
+        config: {
+            provider: string;
+            credentialId: string;
+            model: string;
+            outputType: "boolean" | "numeric";
+            preset: "correctness" | "helpfulness";
+            inputs: {
+                actualAnswer: string;
+                userQuery?: string | undefined;
+                expectedAnswer?: string | undefined;
+            };
+            prompt?: string | undefined;
+        };
+    } | {
+        type: "string_similarity";
+        id: string;
+        name: string;
+        config: {
+            inputs: {
+                actualAnswer: string;
+                expectedAnswer: string;
+            };
+        };
+    } | {
+        type: "categorization";
+        id: string;
+        name: string;
+        config: {
+            inputs: {
+                actualAnswer: string;
+                expectedAnswer: string;
+            };
+        };
+    } | {
+        type: "tools_used";
+        id: string;
+        name: string;
+        config: {
+            inputs: {
+                expectedTools: string;
+                intermediateSteps: string;
+            };
+        };
+    })[];
+} & ({
+    datasetSource: "data_table";
+    datasetRef: {
+        dataTableId: string;
+    };
+} | {
+    datasetSource: "google_sheets";
+    datasetRef: {
+        credentialId: string;
+        spreadsheetId: string;
+        sheetName: string;
+        headerRow?: number | undefined;
+    };
+});
+export declare function evaluationConfigToSummary(config: EvaluationConfig): EvaluationConfigSummary;
 export declare function resolveDataTableByIdOrName(repository: DataTableIdOrNameRepository, logger: DataTableResolverLogger, idOrName: string, options?: {
     projectIdFilter?: string;
     accessFilter?: (id: string) => Promise<boolean>;

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

@@ -46,6 +46,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InstanceAiAdapterService = void 0;
+exports.buildEvaluationConfigDto = buildEvaluationConfigDto;
+exports.evaluationConfigToSummary = evaluationConfigToSummary;
 exports.resolveDataTableByIdOrName = resolveDataTableByIdOrName;
 exports.truncateResultData = truncateResultData;
 exports.extractExecutionResult = extractExecutionResult;
@@ -58,10 +60,13 @@ const promises_1 = require("node:fs/promises");
 const node_path_1 = __importDefault(require("node:path"));
 const ai_utilities_1 = require("@n8n/ai-utilities");
 const instance_ai_1 = require("@n8n/instance-ai");
+const api_types_1 = require("@n8n/api-types");
 const config_1 = require("@n8n/config");
 const constants_1 = require("@n8n/constants");
+const nanoid_1 = require("nanoid");
 const extract_resolved_node_parameters_1 = require("./extract-resolved-node-parameters");
 const instance_ai_settings_service_1 = require("./instance-ai-settings.service");
+const workflow_templates_service_1 = require("./workflow-templates.service");
 const instance_ai_run_pin_data_1 = require("./instance-ai-run-pin-data");
 const node_definition_resolver_1 = require("./node-definition-resolver");
 const web_research_1 = require("./web-research");
@@ -73,13 +78,17 @@ const permissions_1 = require("@n8n/permissions");
 const typeorm_1 = require("@n8n/typeorm");
 const n8n_workflow_1 = require("n8n-workflow");
 const active_executions_1 = require("../../active-executions");
+const conflict_error_1 = require("../../errors/response-errors/conflict.error");
 const credentials_finder_service_1 = require("../../credentials/credentials-finder.service");
 const credentials_service_1 = require("../../credentials/credentials.service");
+const evaluation_config_service_1 = require("../../evaluation.ee/evaluation-config.service");
 const event_service_1 = require("../../events/event.service");
 const execution_persistence_1 = require("../../executions/execution-persistence");
 const license_1 = require("../../license");
 const load_nodes_and_credentials_1 = require("../../load-nodes-and-credentials");
 const node_types_1 = require("../../node-types");
+const agents_credential_provider_1 = require("../../modules/agents/adapters/agents-credential-provider");
+const instance_ai_builder_delegate_adapter_1 = require("../../modules/agents/instance-ai-builder-delegate.adapter");
 const node_catalog_1 = require("../../node-catalog");
 const data_table_repository_1 = require("../../modules/data-table/data-table.repository");
 const data_table_service_1 = require("../../modules/data-table/data-table.service");
@@ -126,7 +135,7 @@ let InstanceAiAdapterService = class InstanceAiAdapterService {
         });
         return await promise;
     }
-    constructor(logger, globalConfig, workflowService, workflowFinderService, workflowRepository, sharedWorkflowRepository, projectRepository, executionRepository, credentialsService, credentialsFinderService, activeExecutions, workflowRunner, loadNodesAndCredentials, nodeTypes, instanceSettings, dataTableService, dataTableRepository, nodeResourceExplorerService, folderService, projectService, tagService, sourceControlPreferencesService, settingsService, workflowHistoryService, enterpriseWorkflowService, license, executionPersistence, eventService, roleService, telemetry, aiBuilderTemporaryWorkflowRepository, ssrfProtectionService, outboundHttp, aiGatewayService, nodeCatalogService) {
+    constructor(logger, globalConfig, workflowService, workflowFinderService, workflowRepository, sharedWorkflowRepository, projectRepository, executionRepository, credentialsService, credentialsFinderService, activeExecutions, workflowRunner, loadNodesAndCredentials, nodeTypes, instanceSettings, dataTableService, dataTableRepository, nodeResourceExplorerService, folderService, projectService, tagService, sourceControlPreferencesService, settingsService, workflowHistoryService, enterpriseWorkflowService, license, executionPersistence, eventService, roleService, telemetry, aiBuilderTemporaryWorkflowRepository, ssrfProtectionService, outboundHttp, aiGatewayService, workflowTemplatesService, nodeCatalogService, evaluationConfigService) {
         this.globalConfig = globalConfig;
         this.workflowService = workflowService;
         this.workflowFinderService = workflowFinderService;
@@ -160,7 +169,9 @@ let InstanceAiAdapterService = class InstanceAiAdapterService {
         this.ssrfProtectionService = ssrfProtectionService;
         this.outboundHttp = outboundHttp;
         this.aiGatewayService = aiGatewayService;
+        this.workflowTemplatesService = workflowTemplatesService;
         this.nodeCatalogService = nodeCatalogService;
+        this.evaluationConfigService = evaluationConfigService;
         this.nodesCache = null;
         this.NODES_CACHE_TTL_MS = 5 * 60 * 1000;
         this.webResearchCache = new web_research_1.LRUCache({
@@ -178,7 +189,9 @@ let InstanceAiAdapterService = class InstanceAiAdapterService {
         });
     }
     createContext(user, options) {
-        const { searchProxyConfig, pushRef, threadId, projectId, credentialIdAllowlist } = options ?? {};
+        const { searchProxyConfig, pushRef, threadId, projectId, credentialIdAllowlist, agentId } = options ?? {};
+        void this.trackGatewayAvailability();
+        const builderDelegateAdapter = this.getBuilderDelegateAdapter();
         return {
             userId: user.id,
             projectId,
@@ -187,15 +200,66 @@ let InstanceAiAdapterService = class InstanceAiAdapterService {
             credentialService: this.createCredentialAdapter(user, projectId, credentialIdAllowlist),
             nodeService: this.createNodeAdapter(user),
             dataTableService: this.createDataTableAdapter(user, projectId),
+            ...(this.evaluationConfigService
+                ? {
+                    evaluationConfigService: this.createEvaluationConfigAdapter(this.evaluationConfigService, user),
+                }
+                : {}),
             webResearchService: this.createWebResearchAdapter(user, searchProxyConfig),
             workspaceService: this.createWorkspaceAdapter(user),
             templatesService: this.getTemplatesService(),
+            workflowTemplateService: this.createWorkflowTemplateAdapter(),
             licenseHints: this.buildLicenseHints(),
             logger: this.logger,
             nodeTypesProvider: this.nodeTypes,
             allowSendingParameterValues: this.allowSendingParameterValues,
+            ...(builderDelegateAdapter && agentId && projectId
+                ? { agentBuilderTarget: { agentId, projectId } }
+                : {}),
+            ...(builderDelegateAdapter && projectId
+                ? {
+                    builderDelegate: builderDelegateAdapter.createDelegate(user, projectId, new agents_credential_provider_1.AgentsCredentialProvider(this.credentialsService, projectId, user)),
+                }
+                : {}),
         };
     }
+    getBuilderDelegateAdapter() {
+        if (!di_1.Container.get(backend_common_1.ModuleRegistry).isActive('agents'))
+            return null;
+        try {
+            return di_1.Container.get(instance_ai_builder_delegate_adapter_1.InstanceAiBuilderDelegateAdapterService);
+        }
+        catch {
+            return null;
+        }
+    }
+    async getGatewayConfigOrNull() {
+        if (!this.license.isLicensed(constants_1.LICENSE_FEATURES.AI_GATEWAY))
+            return null;
+        try {
+            return await this.aiGatewayService.getGatewayConfig();
+        }
+        catch {
+            return null;
+        }
+    }
+    buildAiGatewayNodeMeta(config, nodeName) {
+        if (!config)
+            return undefined;
+        if (!config.nodes.includes(nodeName))
+            return undefined;
+        const meta = { supported: true };
+        const operations = config.supportedActions?.[nodeName];
+        if (operations && Object.keys(operations).length > 0)
+            meta.operations = operations;
+        const minVersion = config.minNodeTypeVersion?.[nodeName];
+        if (minVersion !== undefined)
+            meta.minVersion = minVersion;
+        const hiddenProperties = config.hiddenNodeProperties?.[nodeName];
+        if (hiddenProperties && hiddenProperties.length > 0)
+            meta.hiddenProperties = hiddenProperties;
+        return meta;
+    }
     getTemplatesService() {
         if (!this.templatesService) {
             this.templatesService = new instance_ai_1.BuilderTemplatesService({
@@ -206,6 +270,14 @@ let InstanceAiAdapterService = class InstanceAiAdapterService {
         }
         return this.templatesService;
     }
+    createWorkflowTemplateAdapter() {
+        const workflowTemplatesService = this.workflowTemplatesService;
+        return {
+            async getTemplate(templateId) {
+                return await workflowTemplatesService.getTemplate(templateId);
+            },
+        };
+    }
     buildLicenseHints() {
         const hints = [];
         if (!this.license.isLicensed('feat:namedVersions')) {
@@ -216,6 +288,15 @@ let InstanceAiAdapterService = class InstanceAiAdapterService {
         }
         return hints;
     }
+    async trackGatewayAvailability() {
+        const config = await this.getGatewayConfigOrNull();
+        if (!config)
+            return;
+        this.telemetry.track('instance_ai_gateway_available', {
+            nodeCount: config.nodes.length,
+            credentialTypeCount: config.credentialTypes.length,
+        });
+    }
     assertInstanceNotReadOnly(resourceType) {
         if (this.sourceControlPreferencesService.getPreferences().branchReadOnly) {
             throw new Error(`Cannot modify ${resourceType} on a protected instance. This instance is in read-only mode.`);
@@ -286,7 +367,7 @@ let InstanceAiAdapterService = class InstanceAiAdapterService {
                 if (!workflow) {
                     throw new Error(`Workflow ${workflowId} not found or not accessible`);
                 }
-                return toWorkflowDetail(workflow, { redactParameters });
+                return await toWorkflowDetailWithChecksum(workflow, { redactParameters });
             },
             async archive(workflowId) {
                 assertNotReadOnly();
@@ -480,9 +561,9 @@ let InstanceAiAdapterService = class InstanceAiAdapterService {
                         workflow_id: updated.id,
                     });
                 }
-                return toWorkflowDetail(updated, { redactParameters });
+                return await toWorkflowDetailWithChecksum(updated, { redactParameters });
             },
-            async updateFromWorkflowJSON(workflowId, json, _options) {
+            async updateFromWorkflowJSON(workflowId, json, options) {
                 assertNotReadOnly();
                 const settings = (json.settings ?? {});
                 if (settings.redactionPolicy !== undefined) {
@@ -516,9 +597,13 @@ let InstanceAiAdapterService = class InstanceAiAdapterService {
                     }
                     updated = await workflowService.update(user, updateData, workflowId, {
                         source: 'n8n-ai',
+                        ...(options?.expectedChecksum ? { expectedChecksum: options.expectedChecksum } : {}),
                     });
                 }
                 catch (error) {
+                    if (error instanceof conflict_error_1.ConflictError) {
+                        throw new instance_ai_1.WorkflowSaveConflictError(workflowId);
+                    }
                     logger.warn('AI-builder workflow save failed', {
                         threadId,
                         workflowId,
@@ -532,7 +617,7 @@ let InstanceAiAdapterService = class InstanceAiAdapterService {
                         workflow_id: workflowId,
                     });
                 }
-                return toWorkflowDetail(updated, { redactParameters });
+                return await toWorkflowDetailWithChecksum(updated, { redactParameters });
             },
             async listVersions(workflowId, options) {
                 const take = options?.limit ?? 20;
@@ -863,7 +948,8 @@ let InstanceAiAdapterService = class InstanceAiAdapterService {
         };
     }
     createCredentialAdapter(user, boundProjectId, credentialIdAllowlist) {
-        const { credentialsService, credentialsFinderService, loadNodesAndCredentials, aiGatewayService, } = this;
+        const { credentialsService, credentialsFinderService, loadNodesAndCredentials } = this;
+        const getGatewayConfig = async () => await this.getGatewayConfigOrNull();
         const adapter = {
             async list(options) {
                 if (boundProjectId) {
@@ -1108,13 +1194,12 @@ let InstanceAiAdapterService = class InstanceAiAdapterService {
                 }
             },
             async isAiGatewayCredentialType(credType) {
-                try {
-                    const config = await aiGatewayService.getGatewayConfig();
-                    return config.credentialTypes.includes(credType);
-                }
-                catch {
-                    return false;
-                }
+                const config = await getGatewayConfig();
+                return config?.credentialTypes.includes(credType) ?? false;
+            },
+            async listAiGatewayCredentialTypes() {
+                const config = await getGatewayConfig();
+                return config?.credentialTypes ?? [];
             },
         };
         if (!credentialIdAllowlist)
@@ -1125,6 +1210,46 @@ let InstanceAiAdapterService = class InstanceAiAdapterService {
             list: async (options) => allowed.size === 0 ? [] : (await adapter.list(options)).filter((c) => allowed.has(c.id)),
         };
     }
+    createEvaluationConfigAdapter(evaluationConfigService, user) {
+        const { workflowFinderService } = this;
+        const assertNotReadOnly = () => this.assertInstanceNotReadOnly('evaluations');
+        const findWorkflow = async (workflowId, scope) => {
+            const workflow = await workflowFinderService.findWorkflowForUser(workflowId, user, [scope]);
+            if (!workflow) {
+                throw new Error(`Workflow ${workflowId} not found or not accessible`);
+            }
+            return workflow;
+        };
+        return {
+            async list(workflowId) {
+                await findWorkflow(workflowId, 'workflow:read');
+                const configs = await evaluationConfigService.list(workflowId);
+                return configs.map(evaluationConfigToSummary);
+            },
+            async get(workflowId, configId) {
+                await findWorkflow(workflowId, 'workflow:read');
+                const config = await evaluationConfigService.get(workflowId, configId);
+                return config ? evaluationConfigToSummary(config) : null;
+            },
+            async create(workflowId, input) {
+                assertNotReadOnly();
+                const workflow = await findWorkflow(workflowId, 'workflow:update');
+                const config = await evaluationConfigService.create(workflowId, workflow, user, buildEvaluationConfigDto(input));
+                return evaluationConfigToSummary(config);
+            },
+            async update(workflowId, configId, input) {
+                assertNotReadOnly();
+                const workflow = await findWorkflow(workflowId, 'workflow:update');
+                const config = await evaluationConfigService.update(workflowId, configId, workflow, user, buildEvaluationConfigDto(input));
+                return evaluationConfigToSummary(config);
+            },
+            async delete(workflowId, configId) {
+                assertNotReadOnly();
+                await findWorkflow(workflowId, 'workflow:update');
+                await evaluationConfigService.delete(workflowId, configId);
+            },
+        };
+    }
     createDataTableAdapter(user, boundProjectId) {
         const { dataTableService, dataTableRepository } = this;
         const assertNotReadOnly = () => this.assertInstanceNotReadOnly('data tables');
@@ -1386,6 +1511,8 @@ let InstanceAiAdapterService = class InstanceAiAdapterService {
     }
     createNodeAdapter(user) {
         const getNodes = async () => await this.getNodesFromCache();
+        const getGatewayConfig = async () => await this.getGatewayConfigOrNull();
+        const buildMeta = (config, nodeName) => this.buildAiGatewayNodeMeta(config, nodeName);
         const findNodeByVersion = (nodes, nodeType, version) => {
             if (version !== undefined) {
                 const exact = nodes.find((n) => {
@@ -1402,24 +1529,34 @@ let InstanceAiAdapterService = class InstanceAiAdapterService {
         };
         return {
             async listAvailable(options) {
-                const nodes = await getNodes();
+                const [nodes, gatewayConfig] = await Promise.all([
+                    getNodes(),
+                    options?.n8nConnectOnly ? getGatewayConfig() : Promise.resolve(null),
+                ]);
                 let filtered = nodes;
                 if (options?.query) {
                     const q = options.query.toLowerCase();
-                    filtered = nodes.filter((n) => n.displayName.toLowerCase().includes(q) ||
+                    filtered = filtered.filter((n) => n.displayName.toLowerCase().includes(q) ||
                         n.name.toLowerCase().includes(q) ||
                         n.description?.toLowerCase().includes(q));
                 }
-                return filtered.map((n) => ({
-                    name: n.name,
-                    displayName: n.displayName,
-                    description: n.description ?? '',
-                    group: n.group ?? [],
-                    version: Array.isArray(n.version) ? n.version[n.version.length - 1] : n.version,
-                }));
+                const summaries = filtered.map((n) => {
+                    const summary = {
+                        name: n.name,
+                        displayName: n.displayName,
+                        description: n.description ?? '',
+                        group: n.group ?? [],
+                        version: Array.isArray(n.version) ? n.version[n.version.length - 1] : n.version,
+                    };
+                    const meta = buildMeta(gatewayConfig, n.name);
+                    if (meta)
+                        summary.aiGateway = meta;
+                    return summary;
+                });
+                return options?.n8nConnectOnly ? summaries.filter((s) => s.aiGateway) : summaries;
             },
             async listSearchable() {
-                const nodes = await getNodes();
+                const [nodes, gatewayConfig] = await Promise.all([getNodes(), getGatewayConfig()]);
                 const toStringArray = (value) => {
                     if (typeof value === 'string')
                         return value;
@@ -1434,6 +1571,9 @@ let InstanceAiAdapterService = class InstanceAiAdapterService {
                         inputs: toStringArray(n.inputs),
                         outputs: toStringArray(n.outputs),
                     };
+                    const meta = buildMeta(gatewayConfig, n.name);
+                    if (meta)
+                        result.aiGateway = meta;
                     if (n.codex?.alias) {
                         result.codex = { alias: n.codex.alias };
                     }
@@ -1471,7 +1611,7 @@ let InstanceAiAdapterService = class InstanceAiAdapterService {
                 });
             },
             async getDescription(nodeType, version) {
-                const nodes = await getNodes();
+                const [nodes, gatewayConfig] = await Promise.all([getNodes(), getGatewayConfig()]);
                 let desc = version !== undefined
                     ? nodes.find((n) => {
                         if (n.name !== nodeType)
@@ -1487,6 +1627,7 @@ let InstanceAiAdapterService = class InstanceAiAdapterService {
                 if (!desc) {
                     throw new Error(`Node type ${nodeType} not found`);
                 }
+                const meta = buildMeta(gatewayConfig, desc.name);
                 return {
                     name: desc.name,
                     displayName: desc.displayName,
@@ -1521,6 +1662,7 @@ let InstanceAiAdapterService = class InstanceAiAdapterService {
                     ...(desc.webhooks ? { webhooks: desc.webhooks } : {}),
                     ...(desc.polling ? { polling: desc.polling } : {}),
                     ...(desc.triggerPanel !== undefined ? { triggerPanel: desc.triggerPanel } : {}),
+                    ...(meta ? { aiGateway: meta } : {}),
                 };
             },
             getNodeTypeDefinition: async (nodeType, options) => {
@@ -1845,10 +1987,60 @@ exports.InstanceAiAdapterService = InstanceAiAdapterService = __decorate([
         backend_network_1.SsrfProtectionService,
         backend_network_1.OutboundHttp,
         ai_gateway_service_1.AiGatewayService,
-        node_catalog_1.NodeCatalogService])
+        workflow_templates_service_1.WorkflowTemplatesService,
+        node_catalog_1.NodeCatalogService,
+        evaluation_config_service_1.EvaluationConfigService])
 ], InstanceAiAdapterService);
 const MAX_RESULT_CHARS = 20_000;
 const MAX_NODE_OUTPUT_CHARS = 1_000;
+function buildEvaluationConfigDto(input) {
+    return api_types_1.upsertEvaluationConfigSchema.parse({
+        name: input.name,
+        startNodeName: input.startNodeName,
+        endNodeName: input.endNodeName,
+        datasetSource: 'data_table',
+        datasetRef: { dataTableId: input.dataTableId },
+        metrics: input.metrics.map((metric) => ({
+            id: (0, nanoid_1.nanoid)(),
+            name: metric.name,
+            type: 'llm_judge',
+            config: {
+                preset: metric.preset,
+                ...(metric.prompt ? { prompt: metric.prompt } : {}),
+                provider: metric.provider,
+                credentialId: metric.credentialId,
+                model: metric.model,
+                outputType: metric.outputType,
+                inputs: {
+                    actualAnswer: metric.actualAnswer,
+                    ...(metric.userQuery ? { userQuery: metric.userQuery } : {}),
+                    ...(metric.expectedAnswer ? { expectedAnswer: metric.expectedAnswer } : {}),
+                },
+            },
+        })),
+    });
+}
+function evaluationConfigToSummary(config) {
+    const dataTableId = config.datasetSource === 'data_table' && 'dataTableId' in config.datasetRef
+        ? config.datasetRef.dataTableId
+        : undefined;
+    return {
+        id: config.id,
+        workflowId: config.workflowId,
+        name: config.name,
+        status: config.status,
+        invalidReason: config.invalidReason,
+        startNodeName: config.startNodeName,
+        endNodeName: config.endNodeName,
+        metrics: config.metrics.map((metric) => ({
+            id: metric.id,
+            name: metric.name,
+            type: metric.type,
+        })),
+        datasetSource: config.datasetSource,
+        ...(dataTableId !== undefined ? { dataTableId } : {}),
+    };
+}
 async function resolveDataTableByIdOrName(repository, logger, idOrName, options) {
     const byId = await repository.findOneBy({ id: idOrName });
     if (byId) {
@@ -1910,6 +2102,42 @@ function wrapResultDataEntries(data) {
     }
     return wrapped;
 }
+const MAX_NODE_ERRORS = 10;
+function isFailedNodeRun(nodeRun) {
+    return (nodeRun.executionStatus === 'error' ||
+        nodeRun.error !== undefined ||
+        nodeRun.redactedError !== undefined);
+}
+function nodeContinuesOnError(node) {
+    return (node?.continueOnFail === true ||
+        node?.onError === 'continueRegularOutput' ||
+        node?.onError === 'continueErrorOutput');
+}
+function extractNodeErrors(runData, includeUpstreamDetails, workflowNodes = []) {
+    if (!runData)
+        return [];
+    const nodesByName = new Map(workflowNodes.map((node) => [node.name, node]));
+    const nodeErrors = [];
+    for (const [nodeName, nodeRuns] of Object.entries(runData)) {
+        if (nodeErrors.length >= MAX_NODE_ERRORS)
+            break;
+        if (nodeContinuesOnError(nodesByName.get(nodeName)))
+            continue;
+        const failedRun = nodeRuns.find(isFailedNodeRun);
+        if (!failedRun)
+            continue;
+        const message = failedRun.error
+            ? formatExecutionError(failedRun.error, includeUpstreamDetails)
+            : failedRun.redactedError
+                ? `${failedRun.redactedError.type} error${failedRun.redactedError.httpCode ? ` (${failedRun.redactedError.httpCode})` : ''}`
+                : undefined;
+        nodeErrors.push({
+            nodeName,
+            ...(message ? { message } : {}),
+        });
+    }
+    return nodeErrors;
+}
 async function extractExecutionResult(executionId, includeOutputData = true) {
     const execution = await di_1.Container.get(execution_persistence_1.ExecutionPersistence).findSingleExecution(executionId, {
         includeData: true,
@@ -1926,9 +2154,9 @@ async function extractExecutionResult(executionId, includeOutputData = true) {
                 ? 'waiting'
                 : 'success';
     const resultData = {};
-    const executedNodeNames = Object.keys(execution.data?.resultData?.runData ?? {});
+    const runData = execution.data?.resultData?.runData;
+    const executedNodeNames = Object.keys(runData ?? {});
     if (includeOutputData) {
-        const runData = execution.data?.resultData?.runData;
         if (runData) {
             for (const [nodeName, nodeRuns] of Object.entries(runData)) {
                 const lastRun = nodeRuns[nodeRuns.length - 1];
@@ -1946,6 +2174,7 @@ async function extractExecutionResult(executionId, includeOutputData = true) {
     }
     const error = execution.data?.resultData?.error;
     const errorMessage = error ? formatExecutionError(error, includeOutputData) : undefined;
+    const nodeErrors = extractNodeErrors(runData, includeOutputData, execution.workflowData?.nodes);
     return {
         executionId,
         status,
@@ -1953,6 +2182,7 @@ async function extractExecutionResult(executionId, includeOutputData = true) {
             ? wrapResultDataEntries(truncateResultData(resultData))
             : undefined,
         executedNodeNames: executedNodeNames.length > 0 ? executedNodeNames : undefined,
+        nodeErrors: nodeErrors.length > 0 ? nodeErrors : undefined,
         lastNodeExecuted: execution.data?.resultData?.lastNodeExecuted,
         error: errorMessage,
         startedAt: execution.startedAt?.toISOString(),
@@ -2105,7 +2335,7 @@ async function extractExecutionDebugInfo(executionId, includeOutputData = true,
             nodeTrace.push({
                 name: nodeName,
                 type: nodeType,
-                status: lastRun.error !== undefined ? 'error' : 'success',
+                status: isFailedNodeRun(lastRun) ? 'error' : 'success',
                 startedAt: lastRun.startTime !== undefined ? new Date(lastRun.startTime).toISOString() : undefined,
                 finishedAt: lastRun.startTime !== undefined && lastRun.executionTime !== undefined
                     ? new Date(lastRun.startTime + lastRun.executionTime).toISOString()
@@ -2239,4 +2469,9 @@ function toWorkflowDetail(workflow, options) {
         settings: workflow.settings,
     };
 }
+async function toWorkflowDetailWithChecksum(workflow, options) {
+    const detail = toWorkflowDetail(workflow, options);
+    detail.checksum = await (0, n8n_workflow_1.calculateWorkflowChecksum)(workflow);
+    return detail;
+}
 //# sourceMappingURL=instance-ai.adapter.service.js.map