n8n 2.41.2 → 2.42.0

package/dist/modules/agents/builder/agents-builder-tools.service.js

@@ -14,11 +14,15 @@ const agents_1 = require("@n8n/agents");
 const tool_1 = require("@n8n/agents/tool");
 const agent_config_1 = require("@n8n/ai-utilities/agent-config");
 const api_types_1 = require("@n8n/api-types");
+const backend_common_1 = require("@n8n/backend-common");
 const backend_network_1 = require("@n8n/backend-network");
 const di_1 = require("@n8n/di");
+const instance_ai_1 = require("@n8n/instance-ai");
 const zod_1 = require("zod");
 const credential_types_1 = require("../../../credential-types");
+const collaboration_service_1 = require("../../../collaboration/collaboration.service");
 const conflict_error_1 = require("../../../errors/response-errors/conflict.error");
+const locked_error_1 = require("../../../errors/response-errors/locked.error");
 const mcp_registry_service_1 = require("../../../modules/mcp-registry/registry/mcp-registry.service");
 const node_types_1 = require("../../../node-types");
 const oauth_service_1 = require("../../../oauth/oauth.service");
@@ -32,21 +36,19 @@ const ai_proxy_fetch_1 = require("../../../utils/ai-proxy-fetch");
 const agent_config_service_1 = require("../agent-config.service");
 const agent_custom_tools_service_1 = require("../agent-custom-tools.service");
 const agent_integration_persistence_service_1 = require("../agent-integration-persistence.service");
+const instance_ai_agent_context_adapter_1 = require("../instance-ai-agent-context.adapter");
 const agent_publish_service_1 = require("../agent-publish.service");
 const agent_skills_service_1 = require("../agent-skills.service");
 const agent_task_service_1 = require("../agent-task.service");
 const agent_test_run_service_1 = require("../agent-test-run.service");
 const agents_tools_service_1 = require("../agents-tools.service");
 const agents_service_1 = require("../agents.service");
-const attachable_workflows_service_1 = require("../attachable-workflows.service");
 const agent_builder_preview_path_1 = require("./agent-builder-preview-path");
 const call_agent_failure_1 = require("./call-agent-failure");
 const builder_model_live_lookup_service_1 = require("./builder-model-live-lookup.service");
 const builder_tool_names_1 = require("./builder-tool-names");
 const get_resource_locator_options_tool_1 = require("./get-resource-locator-options.tool");
 const interactive_1 = require("./interactive");
-const resolve_integration_tool_1 = require("./resolve-integration.tool");
-const search_mcp_servers_tool_1 = require("./search-mcp-servers.tool");
 const skill_body_template_1 = require("./skill-body-template");
 const task_objective_template_1 = require("./task-objective-template");
 const verify_mcp_server_tool_1 = require("./verify-mcp-server.tool");
@@ -56,9 +58,14 @@ const agent_secure_runtime_1 = require("../runtime/agent-secure-runtime");
 const agent_config_hash_1 = require("../utils/agent-config-hash");
 const STALE_CONFIG_ERROR = {
     path: '(root)',
-    message: 'Agent config changed since you last read it. Call read_config, then retry using the config and configHash it returns.',
+    message: 'Agent config changed. Call agent-context with type "config", then retry with its config and configHash.',
 };
-const STALE_SKILL_ERROR_MESSAGE = 'Skill changed since you last read it. Call read_skill, then retry using the skill and skillHash it returns.';
+const AGENT_LOCKED_BY_EDITOR_ERROR = {
+    path: '(root)',
+    message: 'The agent is being edited by a user in the n8n builder right now, so it cannot be modified. ' +
+        'Stop editing and tell the user to finish or close their editing session, then retry.',
+};
+const STALE_SKILL_ERROR_MESSAGE = 'Skill changed. Call agent-context with type "skill", then retry with its skill and skillHash.';
 const CLI_AGENT_CONFIG_MESSAGES = {
     emptyInstructionsFollowUp: 'saving the config again.',
     dynamicSelectorFollowUp: 'Load skill agent-builder-resource-locators, resolve a credential if missing, then call ' +
@@ -77,16 +84,6 @@ const createSkillInputSchema = zod_1.z
         .describe('Markdown-only supporting files under references/... paths. References are not automatically loaded; instructions must say exactly when to load each reference by path.'),
 })
     .strict();
-const readSkillInputSchema = zod_1.z
-    .object({
-    skillId: zod_1.z.string().min(1).describe('Persisted target-agent skill id to read.'),
-    referencePaths: zod_1.z
-        .array(zod_1.z.string().min(1))
-        .max(api_types_1.AGENT_SKILL_REFERENCE_MAX_COUNT)
-        .optional()
-        .describe('Optional reference paths whose content is needed. Omit to receive paths and character counts only.'),
-})
-    .strict();
 const updateSkillFieldsSchema = zod_1.z
     .object({
     name: api_types_1.agentSkillSchema.shape.name.optional(),
@@ -109,7 +106,7 @@ const updateSkillInputSchema = zod_1.z
     baseSkillHash: zod_1.z
         .string()
         .min(1)
-        .describe('skillHash from the immediately preceding read_skill result for this skill.'),
+        .describe('skillHash from the immediately preceding agent-context with type "skill" result for this skill.'),
     updates: updateSkillFieldsSchema.describe('Only the fields to change. Pass null for allowedTools or references to remove that field; empty arrays are invalid.'),
 })
     .strict();
@@ -176,14 +173,14 @@ function applyPromptCachingBuilderDefaults(config) {
     };
 }
 let AgentsBuilderToolsService = class AgentsBuilderToolsService {
-    constructor(agentsService, agentConfigService, agentCustomToolsService, agentIntegrationPersistenceService, agentSkillsService, secureRuntime, attachableWorkflowsService, agentsToolsService, builderModelLiveLookupService, mcpRegistryService, oauthService, credentialTypes, agentTaskService, agentPublishService, agentTestRunService, aiService, aiGatewayService, outboundHttp, dynamicNodeParametersService, nodeTypes, freeAiCreditsService, telemetry) {
+    constructor(logger, agentsService, agentConfigService, agentCustomToolsService, agentIntegrationPersistenceService, agentSkillsService, secureRuntime, agentsToolsService, builderModelLiveLookupService, mcpRegistryService, oauthService, credentialTypes, agentTaskService, agentPublishService, agentTestRunService, aiService, aiGatewayService, outboundHttp, dynamicNodeParametersService, nodeTypes, freeAiCreditsService, telemetry, agentContextAdapter, collaborationService) {
+        this.logger = logger;
         this.agentsService = agentsService;
         this.agentConfigService = agentConfigService;
         this.agentCustomToolsService = agentCustomToolsService;
         this.agentIntegrationPersistenceService = agentIntegrationPersistenceService;
         this.agentSkillsService = agentSkillsService;
         this.secureRuntime = secureRuntime;
-        this.attachableWorkflowsService = attachableWorkflowsService;
         this.agentsToolsService = agentsToolsService;
         this.builderModelLiveLookupService = builderModelLiveLookupService;
         this.mcpRegistryService = mcpRegistryService;
@@ -199,6 +196,8 @@ let AgentsBuilderToolsService = class AgentsBuilderToolsService {
         this.nodeTypes = nodeTypes;
         this.freeAiCreditsService = freeAiCreditsService;
         this.telemetry = telemetry;
+        this.agentContextAdapter = agentContextAdapter;
+        this.collaborationService = collaborationService;
     }
     withConfigMutationMarker(tool, agentId) {
         const handler = tool.handler;
@@ -212,13 +211,26 @@ let AgentsBuilderToolsService = class AgentsBuilderToolsService {
                     result !== null &&
                     (('ok' in result && result.ok === true) ||
                         ('configured' in result && result.configured === true) ||
-                        ('completed' in result && result.completed === true))) {
+                        ('completed' in result && result.completed === true)) &&
+                    (!('changed' in result) || result.changed !== false)) {
                     return { ...result, configMutated: true, agentId };
                 }
                 return result;
             },
         };
     }
+    async getEditorLockFailure(agentId) {
+        try {
+            await this.collaborationService.ensureAgentEditable(agentId);
+            return null;
+        }
+        catch (error) {
+            if (error instanceof locked_error_1.LockedError) {
+                return { ok: false, errors: [AGENT_LOCKED_BY_EDITOR_ERROR] };
+            }
+            throw error;
+        }
+    }
     getTools(agentId, projectId, credentialProvider, credentialService, user, options) {
         return {
             json: this.getJsonTools(agentId, projectId, credentialProvider, credentialService, user, options),
@@ -233,206 +245,226 @@ let AgentsBuilderToolsService = class AgentsBuilderToolsService {
             ...(options?.runId ? { run_id: options.runId } : {}),
             ...properties,
         });
-        const readConfigTool = new tool_1.Tool(builder_tool_names_1.BUILDER_TOOLS.READ_CONFIG)
-            .description('Read the latest persisted agent configuration and its freshness token. ' +
-            'Returns { ok: true, config, configHash }. This is the only tool that returns the full config — ' +
-            'write_config, patch_config, and stale responses never echo it back. ' +
-            'Call this before every write_config or patch_config and use configHash as baseConfigHash.')
-            .input(zod_1.z.object({}))
-            .handler(async () => {
-            try {
-                const snapshot = await this.getConfigSnapshot(agentId, projectId);
-                return { ok: true, ...snapshot };
-            }
-            catch (e) {
-                return {
-                    ok: false,
-                    errors: [{ path: '(root)', message: e instanceof Error ? e.message : String(e) }],
-                };
-            }
-        })
-            .build();
-        const writeConfigTool = new tool_1.Tool(builder_tool_names_1.BUILDER_TOOLS.WRITE_CONFIG)
-            .description('Create or replace the agent configuration by writing a complete JSON string. ' +
-            'Requires baseConfigHash from the immediately preceding read_config result — never from a prior ' +
-            'write_config/patch_config success or from a stale response. ' +
-            'Returns { ok: true, configMutated: true, agentId } on success — no config, hash, or timestamps are returned; call ' +
-            'read_config again before any later inspection or mutation — or ' +
-            '{ ok: false, stage, errors } with path, message, expected, received fields on failure. ' +
-            'On stage: "stale", call read_config and retry once using its fresh config and configHash.')
+        const writeConfigTool = this.buildWriteConfigTool(agentId, projectId, user);
+        const patchConfigTool = this.buildPatchConfigTool(agentId, projectId, user);
+        const publishAgentTool = this.buildPublishAgentTool(user, projectId, agentId);
+        const unpublishAgentTool = this.buildUnpublishAgentTool(user, projectId, agentId);
+        const callAgentTool = this.buildCallAgentTool(user, projectId, agentId, credentialProvider);
+        const modelLookup = this.createModelLookup(user, projectId, options);
+        const tools = [
+            this.withConfigMutationMarker(writeConfigTool, agentId),
+            this.withConfigMutationMarker(patchConfigTool, agentId),
+            this.withConfigMutationMarker(publishAgentTool, agentId),
+            this.withConfigMutationMarker(unpublishAgentTool, agentId),
+            callAgentTool,
+            this.createLlmTool(credentialProvider, modelLookup, user, projectId),
+            this.createCredentialTool(credentialService, projectId, agentId, track),
+            this.createEmbeddingCredentialTool(credentialService, projectId, track),
+            (0, interactive_1.buildAskQuestionsTool)({ track }),
+            this.withConfigMutationMarker(this.createConfigureChannelTool(agentId, projectId, track), agentId),
+            this.withConfigMutationMarker(this.createFinishSetupTool(credentialService, agentId, projectId, track), agentId),
+            this.createVerifyMcpServerTool(agentId, credentialProvider, projectId, user),
+        ];
+        return tools;
+    }
+    createVerifyMcpServerTool(agentId, credentialProvider, projectId, user) {
+        return (0, verify_mcp_server_tool_1.buildVerifyMcpServerTool)({
+            agentId,
+            credentialProvider,
+            oauthService: this.oauthService,
+            projectId,
+            proxyFetch: (0, ai_proxy_fetch_1.createAiMcpFetch)(this.outboundHttp),
+            resolveRegistryConnection: async (nodeTypeName) => await this.mcpRegistryService.getConnection(nodeTypeName),
+            applyCredentialToMcpServer: async (serverName, credentialId) => await this.applyCredentialToMcpServer(agentId, projectId, serverName, credentialId, user),
+        });
+    }
+    createFinishSetupTool(credentialService, agentId, projectId, track) {
+        return (0, interactive_1.buildFinishSetupTool)({
+            credentialService,
+            agentId,
+            projectId,
+            track,
+            isCredentialTypeKnown: (credentialType) => this.credentialTypes.recognizes(credentialType),
+            listIntegrationCredentialIds: async () => {
+                const agent = await this.agentsService.findById(agentId, projectId);
+                return (agent?.integrations ?? [])
+                    .filter((integration) => (0, api_types_1.isCredentialAgentIntegration)(integration) && !(0, api_types_1.isDraftIntegration)(integration))
+                    .map((integration) => integration.credentialId);
+            },
+            listChatIntegrationTypes: () => this.agentIntegrationPersistenceService
+                .listChatIntegrations()
+                .map((integration) => integration.type),
+            listAiGatewayManagedCredentialTypes: async () => {
+                const agent = await this.agentsService.findById(agentId, projectId);
+                return (0, reconcile_node_tool_gateway_credentials_1.listAiGatewayManagedCredentialTypes)(agent?.schema?.tools, this.nodeTypes);
+            },
+        });
+    }
+    createConfigureChannelTool(agentId, projectId, track) {
+        return (0, interactive_1.buildConfigureChannelTool)({
+            agentId,
+            projectId,
+            listChatIntegrationTypes: () => this.agentIntegrationPersistenceService
+                .listChatIntegrations()
+                .map((integration) => integration.type),
+            track,
+        });
+    }
+    createEmbeddingCredentialTool(credentialService, projectId, track) {
+        return (0, interactive_1.buildAskEmbeddingCredentialTool)({
+            credentialService,
+            projectId,
+            isCredentialTypeKnown: (credentialType) => this.credentialTypes.recognizes(credentialType),
+            isAssistantProxyEnabled: () => this.aiService.isProxyEnabled(),
+            track,
+        });
+    }
+    createCredentialTool(credentialService, projectId, agentId, track) {
+        return (0, interactive_1.buildAskCredentialTool)({
+            credentialService,
+            projectId,
+            isCredentialTypeKnown: (credentialType) => this.credentialTypes.recognizes(credentialType),
+            listIntegrationCredentialIds: async () => {
+                const agent = await this.agentsService.findById(agentId, projectId);
+                return (agent?.integrations ?? [])
+                    .filter((integration) => (0, api_types_1.isCredentialAgentIntegration)(integration) && !(0, api_types_1.isDraftIntegration)(integration))
+                    .map((integration) => integration.credentialId);
+            },
+            track,
+        });
+    }
+    createLlmTool(credentialProvider, modelLookup, user, projectId) {
+        return (0, interactive_1.buildResolveLlmTool)({
+            credentialProvider,
+            modelLookup,
+            isProviderServedByGateway: async (provider) => {
+                try {
+                    return (await this.aiGatewayService.getCredentialTypeForProvider(provider)) !== undefined;
+                }
+                catch {
+                    return false;
+                }
+            },
+            freeCredits: {
+                isEligible: () => this.freeAiCreditsService.isEligible(user),
+                claim: async () => {
+                    const credential = await this.freeAiCreditsService.claim(user, projectId);
+                    this.telemetry.track('User claimed OpenAI credits', {
+                        user_id: user.id,
+                        source: 'agentBuilderResolveLlm',
+                    });
+                    return { credentialId: credential.id, credentialName: credential.name };
+                },
+            },
+        });
+    }
+    buildCallAgentTool(user, projectId, agentId, credentialProvider) {
+        return new tool_1.Tool(builder_tool_names_1.BUILDER_TOOLS.CALL_AGENT)
+            .description('Tests the draft agent through built-in Preview chat. It does not test configured channel integrations, including their triggers, platform context, message delivery, or replies. ' +
+            'Pass the returned sessionId on later calls to continue the same conversation; omit it to start a new one. ' +
+            'The draft uses its real configured tools and credentials, so external side effects are possible. ' +
+            'Standard tool approvals pause this test until the user approves or rejects them in chat. ' +
+            'Unsupported interactive requests return approval_required with a Preview path.')
             .input(zod_1.z.object({
-            json: zod_1.z.string().describe('Complete agent configuration as a JSON string'),
-            baseConfigHash: zod_1.z
+            message: zod_1.z.string().trim().min(1).describe('Message to send to the target agent'),
+            sessionId: zod_1.z
                 .string()
-                .nullable()
-                .describe('configHash from the immediately preceding read_config result; null only if no config exists'),
+                .trim()
+                .min(1)
+                .optional()
+                .describe('Session ID from a previous call_agent result'),
         }))
-            .handler(async ({ json, baseConfigHash }) => {
-            const parsed = (0, api_types_1.tryParseConfigJson)(json);
-            if (!parsed.ok) {
-                return { ok: false, errors: parsed.errors };
-            }
-            let snapshot;
-            try {
-                snapshot = await this.getConfigSnapshot(agentId, projectId);
-            }
-            catch (e) {
+            .suspend(tool_1.APPROVAL_SUSPEND_SCHEMA)
+            .resume(tool_1.APPROVAL_RESUME_SCHEMA)
+            .handler(async ({ message, sessionId }, ctx) => {
+            if (!(await (0, check_access_1.userHasScopes)(user, ['agent:execute'], false, { projectId }))) {
                 return {
-                    ok: false,
-                    stage: 'stale',
-                    errors: [{ path: '(root)', message: e instanceof Error ? e.message : String(e) }],
+                    status: 'error',
+                    code: 'forbidden',
+                    message: 'You do not have permission to run agents in this project.',
                 };
             }
-            if (baseConfigHash !== snapshot.configHash) {
-                return { ok: false, stage: 'stale', errors: [STALE_CONFIG_ERROR] };
-            }
-            const zodResult = parseBuilderWriteConfig(parsed.data, snapshot.config);
-            if (!zodResult.success) {
-                return { ok: false, errors: (0, api_types_1.formatZodErrors)(zodResult.error) };
-            }
-            const emptyInstructions = (0, agent_config_1.rejectIfEmptyInstructions)(zodResult.data, CLI_AGENT_CONFIG_MESSAGES);
-            if (emptyInstructions) {
-                return { ok: false, errors: emptyInstructions };
-            }
-            const unsupportedNativeWebSearch = (0, agent_config_1.rejectIfUnsupportedNativeWebSearch)(zodResult.data);
-            if (unsupportedNativeWebSearch) {
-                return { ok: false, errors: unsupportedNativeWebSearch };
-            }
-            const dynamicSelectorFromAi = (0, agent_config_1.rejectIfDynamicSelectorUsesFromAi)(zodResult.data, snapshot.config, this.nodeTypes, CLI_AGENT_CONFIG_MESSAGES);
-            if (dynamicSelectorFromAi) {
-                return { ok: false, errors: dynamicSelectorFromAi };
-            }
-            const configWithDefaults = applyPromptCachingBuilderDefaults((0, agent_config_1.applyNativeWebSearchDefaultOn)(zodResult.data));
+            const previewPath = (0, agent_builder_preview_path_1.buildAgentPreviewPath)(projectId, agentId);
             try {
-                await this.agentConfigService.updateConfig(agentId, projectId, configWithDefaults, user, { baseConfigHash: snapshot.configHash, modifiedBy: 'builder' });
-                return { ok: true };
+                const result = await this.runDraftTest(ctx, agentId, projectId, message, sessionId, credentialProvider, user);
+                return await this.formatDraftTestResult(result, ctx, agentId, user, previewPath);
             }
-            catch (e) {
-                return {
-                    ok: false,
-                    stage: e instanceof conflict_error_1.ConflictError ? 'stale' : 'schema',
-                    errors: [{ path: '(root)', message: e instanceof Error ? e.message : String(e) }],
-                };
+            catch (error) {
+                if (ctx.abortSignal ? ctx.abortSignal.aborted : (0, agents_1.isAbortError)(error))
+                    throw error;
+                if (error instanceof agent_test_run_service_1.InvalidAgentTestRunCheckpointError) {
+                    return {
+                        status: 'error',
+                        code: error.code,
+                        message: error.message,
+                    };
+                }
+                const { code, message } = (0, call_agent_failure_1.describeCallAgentFailure)(error instanceof Error ? error.message : 'Agent test run failed.');
+                return { status: 'error', code, message };
             }
         })
             .build();
-        const patchConfigTool = new tool_1.Tool(builder_tool_names_1.BUILDER_TOOLS.PATCH_CONFIG)
-            .description('Apply RFC 6902 JSON Patch operations to the current agent configuration. ' +
-            'Pass an array of patch operations as a JSON string. ' +
-            'Requires baseConfigHash from the immediately preceding read_config result — never from a prior ' +
-            'write_config/patch_config success or from a stale response. ' +
-            'Supported ops: add, remove, replace, move, copy, test. ' +
-            'Returns { ok: true, configMutated: true, agentId } on success — no config, hash, or timestamps are returned; call ' +
-            'read_config again before any later inspection or mutation — or ' +
-            '{ ok: false, stage, errors } on failure. ' +
-            'stage is "parse", "stale", "patch", or "schema". On stage: "stale", call read_config and retry ' +
-            'once using its fresh config and configHash.')
-            .input(zod_1.z.object({
-            operations: zod_1.z.string().describe('RFC 6902 JSON Patch operations array as a JSON string'),
-            baseConfigHash: zod_1.z
-                .string()
-                .nullable()
-                .describe('configHash from the immediately preceding read_config result; null only if no config exists'),
-        }))
-            .handler(async ({ operations, baseConfigHash, }) => {
-            const parsedOps = (0, api_types_1.tryParseConfigJson)(operations);
-            if (!parsedOps.ok) {
-                return { ok: false, stage: 'parse', errors: parsedOps.errors };
-            }
-            let snapshot;
-            try {
-                snapshot = await this.getConfigSnapshot(agentId, projectId);
-            }
-            catch (e) {
-                return {
-                    ok: false,
-                    stage: 'stale',
-                    errors: [{ path: '(root)', message: e instanceof Error ? e.message : String(e) }],
-                };
-            }
-            if (baseConfigHash !== snapshot.configHash) {
-                return { ok: false, stage: 'stale', errors: [STALE_CONFIG_ERROR] };
-            }
-            if (!snapshot.config) {
-                return {
-                    ok: false,
-                    stage: 'patch',
-                    errors: [{ path: '(root)', message: 'Agent has no JSON config yet.' }],
-                };
-            }
-            const jsonpatch = (await import('fast-json-patch')).default;
-            const ops = parsedOps.data;
-            const patchError = jsonpatch.validate(ops, snapshot.config);
-            if (patchError) {
-                const opPath = patchError.operation?.path ?? '(root)';
+    }
+    async runDraftTest(ctx, agentId, projectId, message, sessionId, credentialProvider, user) {
+        let result;
+        if (ctx.resumeData === undefined) {
+            result = await this.agentTestRunService.executeDraftRun({
+                agentId,
+                projectId,
+                message,
+                sessionId,
+                credentialProvider,
+                user,
+                source: 'instance-ai',
+                ...(ctx.abortSignal ? { abortSignal: ctx.abortSignal } : {}),
+            });
+        }
+        else {
+            result = await this.agentTestRunService.resumeDraftApproval({
+                agentId,
+                projectId,
+                continuation: ctx.continuation,
+                approved: ctx.resumeData.approved,
+                user,
+                source: 'instance-ai',
+                ...(ctx.abortSignal ? { abortSignal: ctx.abortSignal } : {}),
+            });
+        }
+        return result;
+    }
+    buildUnpublishAgentTool(user, projectId, agentId) {
+        return new tool_1.Tool(builder_tool_names_1.BUILDER_TOOLS.UNPUBLISH_AGENT)
+            .description('Unpublish this target agent: clears the live version while preserving the draft, disconnects chat ' +
+            'integrations, and stops scheduled tasks. Call when the user asks to unpublish or take the agent offline. ' +
+            'Returns { ok: true, configMutated: true, agentId, activeVersionId: null } or { ok: false, errors }.')
+            .input(zod_1.z.object({}))
+            .handler(async () => {
+            if (!(await (0, check_access_1.userHasScopes)(user, ['agent:unpublish'], false, { projectId }))) {
                 return {
                     ok: false,
-                    stage: 'patch',
-                    errors: [{ path: opPath, message: patchError.message ?? 'Invalid patch operation' }],
+                    errors: [
+                        { message: 'You do not have permission to unpublish agents in this project.' },
+                    ],
                 };
             }
-            const patched = jsonpatch.applyPatch(jsonpatch.deepClone(snapshot.config), ops)
-                .newDocument;
-            const zodResult = parseBuilderWriteConfig(patched, snapshot.config);
-            if (!zodResult.success) {
-                return { ok: false, stage: 'schema', errors: (0, api_types_1.formatZodErrors)(zodResult.error) };
-            }
-            const emptyInstructions = (0, agent_config_1.rejectIfEmptyInstructions)(zodResult.data, CLI_AGENT_CONFIG_MESSAGES);
-            if (emptyInstructions) {
-                return { ok: false, stage: 'schema', errors: emptyInstructions };
-            }
-            const unsupportedNativeWebSearch = (0, agent_config_1.rejectIfUnsupportedNativeWebSearch)(zodResult.data);
-            if (unsupportedNativeWebSearch) {
-                return { ok: false, stage: 'schema', errors: unsupportedNativeWebSearch };
-            }
-            const dynamicSelectorFromAi = (0, agent_config_1.rejectIfDynamicSelectorUsesFromAi)(zodResult.data, snapshot.config, this.nodeTypes, CLI_AGENT_CONFIG_MESSAGES);
-            if (dynamicSelectorFromAi) {
-                return { ok: false, stage: 'schema', errors: dynamicSelectorFromAi };
-            }
-            const configWithDefaults = applyPromptCachingBuilderDefaults((0, agent_config_1.applyNativeWebSearchDefaultOn)(zodResult.data));
+            const editorLock = await this.getEditorLockFailure(agentId);
+            if (editorLock)
+                return editorLock;
             try {
-                await this.agentConfigService.updateConfig(agentId, projectId, configWithDefaults, user, { baseConfigHash: snapshot.configHash, modifiedBy: 'builder' });
-                return { ok: true };
+                await this.agentPublishService.unpublishAgent(agentId, projectId, user, 'builder');
+                return { ok: true, agentId, activeVersionId: null };
             }
             catch (e) {
                 return {
                     ok: false,
-                    stage: e instanceof conflict_error_1.ConflictError ? 'stale' : 'schema',
-                    errors: [{ path: '(root)', message: e instanceof Error ? e.message : String(e) }],
+                    errors: [{ message: e instanceof Error ? e.message : String(e) }],
                 };
             }
         })
             .build();
-        const listIntegrationTypesTool = new tool_1.Tool(builder_tool_names_1.BUILDER_TOOLS.LIST_INTEGRATION_TYPES)
-            .description("List integration types that can be added to the agent's `integrations` array. " +
-            'Returns every available chat platform with the list of ' +
-            'credential types it supports (`credentialTypes: string[]`) and builder guidance ' +
-            '(`capabilities`, `useIntegrationWhen`, `useNodeToolWhen`). ' +
-            'Use that guidance to decide whether the user needs a chat integration or a node tool. ' +
-            'For a chat integration, pass the selected integration `type` to `configure_channel`; ' +
-            'never use `ask_credential` for chat-channel credentials.')
-            .input(zod_1.z.object({}))
-            .handler(async () => this.agentIntegrationPersistenceService.listChatIntegrations())
-            .build();
-        const listSubAgentsTool = new tool_1.Tool(builder_tool_names_1.BUILDER_TOOLS.LIST_SUB_AGENTS)
-            .description('List agents in the same project that can be added to the target agent as subagents. ' +
-            'Excludes the target agent itself. Use before asking the user which subagents to add. ' +
-            'Returned `agentId` values are the only valid values to write into `subAgents.agents[].agentId`; ' +
-            'write parent-owned routing guidance into `subAgents.agents[].useWhen`; ask a follow-up first when it is unclear when that parent should use the subagent.')
-            .input(zod_1.z.object({}))
-            .handler(async () => {
-            const agents = await this.agentsService.findByProjectId(projectId);
-            return {
-                agents: agents
-                    .filter((agent) => agent.id !== agentId)
-                    .map((agent) => ({
-                    agentId: agent.id,
-                    name: agent.name,
-                })),
-            };
-        })
-            .build();
-        const publishAgentTool = new tool_1.Tool(builder_tool_names_1.BUILDER_TOOLS.PUBLISH_AGENT)
+    }
+    buildPublishAgentTool(user, projectId, agentId) {
+        return new tool_1.Tool(builder_tool_names_1.BUILDER_TOOLS.PUBLISH_AGENT)
             .description('Publish this target agent so it becomes live: integrations sync and scheduled tasks start running. ' +
             'Idempotent when the draft is already the active published version. Pass optional `versionId` to ' +
             'activate an existing history row instead of publishing the current draft. Call only when the user ' +
@@ -452,13 +484,23 @@ let AgentsBuilderToolsService = class AgentsBuilderToolsService {
                     errors: [{ message: 'You do not have permission to publish agents in this project.' }],
                 };
             }
+            const editorLock = await this.getEditorLockFailure(agentId);
+            if (editorLock)
+                return editorLock;
             try {
+                const before = await this.agentsService.findById(agentId, projectId);
+                const beforeActiveVersionId = before?.activeVersionId;
+                const beforeVersionId = before?.versionId;
                 const { agent } = await this.agentPublishService.publishAgent(agentId, projectId, user, { by: 'builder', trigger: 'explicit' }, versionId);
                 return {
                     ok: true,
                     agentId,
                     activeVersionId: agent.activeVersionId,
                     versionId: agent.versionId,
+                    ...(beforeActiveVersionId === agent.activeVersionId &&
+                        beforeVersionId === agent.versionId
+                        ? { changed: false }
+                        : {}),
                 };
             }
             catch (e) {
@@ -469,366 +511,148 @@ let AgentsBuilderToolsService = class AgentsBuilderToolsService {
             }
         })
             .build();
-        const unpublishAgentTool = new tool_1.Tool(builder_tool_names_1.BUILDER_TOOLS.UNPUBLISH_AGENT)
-            .description('Unpublish this target agent: clears the live version while preserving the draft, disconnects chat ' +
-            'integrations, and stops scheduled tasks. Call when the user asks to unpublish or take the agent offline. ' +
-            'Returns { ok: true, configMutated: true, agentId, activeVersionId: null } or { ok: false, errors }.')
-            .input(zod_1.z.object({}))
-            .handler(async () => {
-            if (!(await (0, check_access_1.userHasScopes)(user, ['agent:unpublish'], false, { projectId }))) {
-                return {
-                    ok: false,
-                    errors: [
-                        { message: 'You do not have permission to unpublish agents in this project.' },
-                    ],
-                };
-            }
-            try {
-                await this.agentPublishService.unpublishAgent(agentId, projectId, user, 'builder');
-                return { ok: true, agentId, activeVersionId: null };
-            }
-            catch (e) {
-                return {
-                    ok: false,
-                    errors: [{ message: e instanceof Error ? e.message : String(e) }],
-                };
-            }
-        })
+    }
+    buildPatchConfigTool(agentId, projectId, user) {
+        return new tool_1.Tool(builder_tool_names_1.BUILDER_TOOLS.PATCH_CONFIG)
+            .description('Apply RFC 6902 JSON Patch operations to the current agent configuration. ' +
+            'Pass an array of patch operations as a JSON string. ' +
+            'Requires baseConfigHash from the immediately preceding agent-context with type "config" result — never from a prior ' +
+            'write_config/patch_config success or from a stale response. ' +
+            'Supported ops: add, remove, replace, move, copy, test. ' +
+            'Returns { ok: true, configMutated: true, agentId } on success — no config, hash, or timestamps are returned; call ' +
+            'agent-context with type "config" again before any later inspection or mutation — or ' +
+            '{ ok: false, stage, errors } on failure. ' +
+            'stage is "locked", "parse", "stale", "patch", or "schema". On stage: "stale", call agent-context with type "config" and retry ' +
+            'once using its fresh config and configHash. On stage: "locked", stop and tell the user to close ' +
+            'their editing session in the n8n builder.')
+            .input(zod_1.z.object({
+            operations: zod_1.z.string().describe('RFC 6902 JSON Patch operations array as a JSON string'),
+            baseConfigHash: zod_1.z
+                .string()
+                .nullable()
+                .describe('configHash from the immediately preceding agent-context with type "config" result; null only if no config exists'),
+        }))
+            .handler(async ({ operations, baseConfigHash, }) => await this.patchBuilderConfig(agentId, projectId, user, operations, baseConfigHash))
             .build();
-        const callAgentTool = new tool_1.Tool(builder_tool_names_1.BUILDER_TOOLS.CALL_AGENT)
-            .description('Tests the draft agent through built-in Preview chat. It does not test configured channel integrations, including their triggers, platform context, message delivery, or replies. ' +
-            'Pass the returned sessionId on later calls to continue the same conversation; omit it to start a new one. ' +
-            'The draft uses its real configured tools and credentials, so external side effects are possible. ' +
-            'Standard tool approvals pause this test until the user approves or rejects them in chat. ' +
-            'Unsupported interactive requests return approval_required with a Preview path.')
+    }
+    buildWriteConfigTool(agentId, projectId, user) {
+        return new tool_1.Tool(builder_tool_names_1.BUILDER_TOOLS.WRITE_CONFIG)
+            .description('Create or replace the agent configuration by writing a complete JSON string. ' +
+            'Requires baseConfigHash from the immediately preceding agent-context with type "config" result — never from a prior ' +
+            'write_config/patch_config success or from a stale response. ' +
+            'Returns { ok: true, configMutated: true, agentId } on success — no config, hash, or timestamps are returned; call ' +
+            'agent-context with type "config" again before any later inspection or mutation — or ' +
+            '{ ok: false, stage, errors } with path, message, expected, received fields on failure. ' +
+            'On stage: "stale", call agent-context with type "config" and retry once using its fresh config and configHash.')
             .input(zod_1.z.object({
-            message: zod_1.z.string().trim().min(1).describe('Message to send to the target agent'),
-            sessionId: zod_1.z
+            json: zod_1.z.string().describe('Complete agent configuration as a JSON string'),
+            baseConfigHash: zod_1.z
                 .string()
-                .trim()
-                .min(1)
-                .optional()
-                .describe('Session ID from a previous call_agent result'),
+                .nullable()
+                .describe('configHash from the immediately preceding agent-context with type "config" result; null only if no config exists'),
         }))
-            .suspend(tool_1.APPROVAL_SUSPEND_SCHEMA)
-            .resume(tool_1.APPROVAL_RESUME_SCHEMA)
-            .handler(async ({ message, sessionId }, ctx) => {
-            if (!(await (0, check_access_1.userHasScopes)(user, ['agent:execute'], false, { projectId }))) {
-                return {
-                    status: 'error',
-                    code: 'forbidden',
-                    message: 'You do not have permission to run agents in this project.',
-                };
-            }
-            const previewPath = (0, agent_builder_preview_path_1.buildAgentPreviewPath)(projectId, agentId);
-            try {
-                let result;
-                if (ctx.resumeData === undefined) {
-                    result = await this.agentTestRunService.executeDraftRun({
-                        agentId,
-                        projectId,
-                        message,
-                        sessionId,
-                        credentialProvider,
-                        user,
-                        source: 'instance-ai',
-                        ...(ctx.abortSignal ? { abortSignal: ctx.abortSignal } : {}),
-                    });
-                }
-                else {
-                    result = await this.agentTestRunService.resumeDraftApproval({
-                        agentId,
-                        projectId,
-                        continuation: ctx.continuation,
-                        approved: ctx.resumeData.approved,
-                        user,
-                        source: 'instance-ai',
-                        ...(ctx.abortSignal ? { abortSignal: ctx.abortSignal } : {}),
-                    });
-                }
-                if (result.status === 'session_not_found') {
-                    return {
-                        status: 'error',
-                        code: 'session_not_found',
-                        message: 'Session not found.',
-                    };
-                }
-                if (result.status === 'agent_misconfigured') {
-                    return {
-                        status: 'error',
-                        code: 'agent_misconfigured',
-                        message: "This agent isn't ready to run yet. Finish configuring it and try again.",
-                        missing: result.missing,
-                    };
-                }
-                if (result.status === 'completed')
-                    return result;
-                const approvals = (0, agent_test_run_service_1.collectStandardApprovals)(result);
-                const firstApproval = approvals?.[0];
-                if (firstApproval) {
-                    const { continuation, ...approval } = firstApproval;
-                    return await ctx.suspend(approval, { continuation });
-                }
-                const cancelled = await this.agentTestRunService.cancelSuspendedRuns({
-                    agentId,
-                    suspensions: result.suspensions,
-                    userId: user.id,
-                });
-                if (!cancelled) {
-                    return {
-                        status: 'error',
-                        code: 'cancellation_failed',
-                        message: 'This test needs approval, but its suspended run could not be cancelled. Open Preview before continuing this session.',
-                        sessionId: result.sessionId,
-                        previewPath,
-                    };
-                }
-                return {
-                    status: 'approval_required',
-                    response: result.response,
-                    sessionId: result.sessionId,
-                    ...(result.executionId ? { executionId: result.executionId } : {}),
-                    suspensions: result.suspensions.map(({ runId, toolCallId, toolName }) => ({
-                        runId,
-                        toolCallId,
-                        toolName,
-                    })),
-                    previewPath,
-                };
-            }
-            catch (error) {
-                if (ctx.abortSignal ? ctx.abortSignal.aborted : (0, agents_1.isAbortError)(error))
-                    throw error;
-                if (error instanceof agent_test_run_service_1.InvalidAgentTestRunCheckpointError) {
-                    return {
-                        status: 'error',
-                        code: error.code,
-                        message: error.message,
-                    };
-                }
-                const { code, message } = (0, call_agent_failure_1.describeCallAgentFailure)(error instanceof Error ? error.message : 'Agent test run failed.');
-                return { status: 'error', code, message };
-            }
-        })
+            .handler(async ({ json, baseConfigHash }) => await this.writeBuilderConfig(agentId, projectId, user, json, baseConfigHash))
             .build();
-        const modelLookup = {
-            list: async (credentialId, credentialType, provider) => await this.builderModelLiveLookupService.list(user, projectId, credentialId, credentialType, provider, { useEvalModelCatalog: options?.useEvalModelCatalog === true }),
-        };
-        const tools = [
-            readConfigTool,
-            this.withConfigMutationMarker(writeConfigTool, agentId),
-            this.withConfigMutationMarker(patchConfigTool, agentId),
-            listIntegrationTypesTool,
-            listSubAgentsTool,
-            this.withConfigMutationMarker(publishAgentTool, agentId),
-            this.withConfigMutationMarker(unpublishAgentTool, agentId),
-            callAgentTool,
-            (0, interactive_1.buildResolveLlmTool)({
-                credentialProvider,
-                modelLookup,
-                isProviderServedByGateway: async (provider) => {
-                    try {
-                        return ((await this.aiGatewayService.getCredentialTypeForProvider(provider)) !== undefined);
-                    }
-                    catch {
-                        return false;
-                    }
-                },
-                freeCredits: {
-                    isEligible: () => this.freeAiCreditsService.isEligible(user),
-                    claim: async () => {
-                        const credential = await this.freeAiCreditsService.claim(user, projectId);
-                        this.telemetry.track('User claimed OpenAI credits', {
-                            user_id: user.id,
-                            source: 'agentBuilderResolveLlm',
-                        });
-                        return { credentialId: credential.id, credentialName: credential.name };
-                    },
-                },
-            }),
-            (0, interactive_1.buildAskCredentialTool)({
-                credentialService,
-                projectId,
-                isCredentialTypeKnown: (credentialType) => this.credentialTypes.recognizes(credentialType),
-                listIntegrationCredentialIds: async () => {
-                    const agent = await this.agentsService.findById(agentId, projectId);
-                    return (agent?.integrations ?? [])
-                        .filter((integration) => !(0, api_types_1.isDraftIntegration)(integration))
-                        .map((integration) => integration.credentialId);
-                },
-                track,
-            }),
-            (0, interactive_1.buildAskEmbeddingCredentialTool)({
-                credentialService,
-                projectId,
-                isCredentialTypeKnown: (credentialType) => this.credentialTypes.recognizes(credentialType),
-                isAssistantProxyEnabled: () => this.aiService.isProxyEnabled(),
-                track,
+    }
+    getSharedTools(agentId, projectId, credentialProvider, user) {
+        const buildCustomToolTool = this.buildCustomToolTool(agentId, projectId, user);
+        const createSkillsTool = this.buildCreateSkillsTool(agentId, projectId, user);
+        const updateSkillTool = this.buildUpdateSkillTool(agentId, projectId, user);
+        const updateTaskTool = this.buildUpdateTaskTool(agentId, projectId, user);
+        const createTasksTool = this.buildCreateTasksTool(agentId, projectId, user);
+        return [
+            (0, instance_ai_1.createAgentContextTool)({
+                reader: this.agentContextAdapter.createReader(user, projectId),
+                resolveDefaultAgentId: async () => agentId,
+                logger: this.logger,
             }),
-            (0, interactive_1.buildAskQuestionsTool)({ track }),
-            this.withConfigMutationMarker((0, interactive_1.buildConfigureChannelTool)({
-                agentId,
-                projectId,
-                listChatIntegrationTypes: () => this.agentIntegrationPersistenceService
-                    .listChatIntegrations()
-                    .map((integration) => integration.type),
-                track,
-            }), agentId),
-            this.withConfigMutationMarker((0, interactive_1.buildFinishSetupTool)({
-                credentialService,
-                agentId,
-                projectId,
-                track,
-                isCredentialTypeKnown: (credentialType) => this.credentialTypes.recognizes(credentialType),
-                listIntegrationCredentialIds: async () => {
-                    const agent = await this.agentsService.findById(agentId, projectId);
-                    return (agent?.integrations ?? [])
-                        .filter((integration) => !(0, api_types_1.isDraftIntegration)(integration))
-                        .map((integration) => integration.credentialId);
-                },
-                listChatIntegrationTypes: () => this.agentIntegrationPersistenceService
-                    .listChatIntegrations()
-                    .map((integration) => integration.type),
-                listAiGatewayManagedCredentialTypes: async () => {
-                    const agent = await this.agentsService.findById(agentId, projectId);
-                    return (0, reconcile_node_tool_gateway_credentials_1.listAiGatewayManagedCredentialTypes)(agent?.schema?.tools, this.nodeTypes);
-                },
-            }), agentId),
-            (0, verify_mcp_server_tool_1.buildVerifyMcpServerTool)({
-                agentId,
-                credentialProvider,
-                oauthService: this.oauthService,
+            this.withConfigMutationMarker(buildCustomToolTool, agentId),
+            this.withConfigMutationMarker(createSkillsTool, agentId),
+            this.withConfigMutationMarker(updateSkillTool, agentId),
+            this.withConfigMutationMarker(createTasksTool, agentId),
+            this.withConfigMutationMarker(updateTaskTool, agentId),
+            (0, get_resource_locator_options_tool_1.buildGetResourceLocatorOptionsTool)({
+                dynamicNodeParametersService: this.dynamicNodeParametersService,
+                nodeTypes: this.nodeTypes,
+                user,
                 projectId,
-                proxyFetch: (0, ai_proxy_fetch_1.createAiMcpFetch)(this.outboundHttp),
-                resolveRegistryConnection: async (nodeTypeName) => await this.mcpRegistryService.getConnection(nodeTypeName),
-                applyCredentialToMcpServer: async (serverName, credentialId) => await this.applyCredentialToMcpServer(agentId, projectId, serverName, credentialId, user),
-            }),
-            (0, search_mcp_servers_tool_1.buildSearchMcpServersTool)({ mcpRegistryService: this.mcpRegistryService }),
-            (0, resolve_integration_tool_1.buildResolveIntegrationTool)({
-                mcpRegistryService: this.mcpRegistryService,
-                agentsToolsService: this.agentsToolsService,
             }),
+            ...this.agentsToolsService.getSharedTools(credentialProvider, 'Read-only inspection of available credentials. Use ask_credential to let the user ' +
+                'pick the credential to wire into a node tool — never copy ids from this list directly ' +
+                'into the config.'),
         ];
-        return tools;
     }
-    getSharedTools(agentId, projectId, credentialProvider, user) {
-        const buildCustomToolTool = new tool_1.Tool(builder_tool_names_1.BUILDER_TOOLS.BUILD_CUSTOM_TOOL)
-            .description('Compile and store a custom tool. Pass the complete TypeScript source ' +
-            'using `export default new Tool(...)` builder chain. The code is validated in a ' +
-            'sandbox and saved against the agent. The returned `id` equals the tool name ' +
-            'declared in the code (e.g. `new Tool("my_tool")` → id `"my_tool"`). ' +
-            'This does NOT register the tool in the agent config — follow up with ' +
-            'patch_config (or write_config) to add `{ type: "custom", id: "<tool name>" }` ' +
-            'to `tools`.' +
-            'Returns { ok: true, id, name } or { ok: false, errors }.')
+    buildCreateTasksTool(agentId, projectId, user) {
+        return new tool_1.Tool(builder_tool_names_1.BUILDER_TOOLS.CREATE_TASKS)
+            .description('Create one or more recurring scheduled tasks for the target agent (name + objective + cron ' +
+            'schedule per task) in a single call. Pass every task you currently know how to write in one ' +
+            "`tasks` array — do not spread multiple fully-specified tasks across separate calls; each task's " +
+            'objective field carries its own structured template. The whole batch is all-or-nothing: an ' +
+            'invalid cron or objective rejects every task in the call. This adds a `{ type: "task", id, ' +
+            'enabled }` ref per task to the agent config (config.tasks) and each task starts running once ' +
+            'the agent is (re)published via `publish_agent`. Returns { ok: true, configMutated: true, agentId, tasks: [{ id, name, enabled }, ...] } (same ' +
+            'order as input, objectives and crons are not echoed back) or { ok: false, errors }.')
+            .systemInstruction('Never create a task with a vague, broad, or placeholder objective, an objective missing any ' +
+            'required section, or an unclear schedule. Each objective must follow the required structured ' +
+            'Markdown template (Objective, Context, Steps, Output, Constraints, Success criteria) with every ' +
+            'section filled in with concrete, run-specific content. Agent Instructions still apply and ' +
+            'configured Skills remain available during scheduled runs, so never repeat universal rules or ' +
+            "copy reusable procedures into an objective. If anything is ambiguous, derive it from the user's goal as " +
+            'stated assumptions listed in your summary; ask the user clarifying questions with ask_questions ' +
+            'only when even a reasonable assumption is impossible, before calling ' +
+            'create_tasks. A task can only use tools the agent already has: if any step in an objective ' +
+            'requires a tool, integration, or web search the agent is missing, you MUST add it to the agent ' +
+            'config (patch_config/write_config) BEFORE calling create_tasks — otherwise the task will fail at ' +
+            'runtime. Batch every task you currently know how to write into one call.')
             .input(zod_1.z.object({
-            code: zod_1.z
-                .string()
-                .describe('Complete TypeScript source using export default new Tool(...)'),
+            tasks: zod_1.z
+                .array(zod_1.z.object({
+                name: api_types_1.agentTaskSchema.shape.name.describe('Short, human-readable task name.'),
+                objective: api_types_1.agentTaskSchema.shape.objective.describe(task_objective_template_1.TASK_OBJECTIVE_GUIDANCE),
+                cronExpression: api_types_1.agentTaskSchema.shape.cronExpression.describe('A 5-field cron expression for when the task runs, e.g. "0 9 * * 1-5" = weekdays at 09:00.'),
+                timezone: api_types_1.agentTaskSchema.shape.timezone.describe('IANA timezone the cron runs in, e.g. "Europe/London". Set it when the user names a timezone or a location; omit it to use the instance timezone.'),
+            }))
+                .min(1)
+                .max(20)
+                .describe('Every task to create, in the order they should be created.'),
         }))
-            .handler(async ({ code }, ctx) => {
+            .handler(async ({ tasks, }) => {
+            const editorLock = await this.getEditorLockFailure(agentId);
+            if (editorLock)
+                return editorLock;
+            let created;
             try {
-                const descriptor = await this.secureRuntime.describeToolSecurely(code);
-                const built = await this.agentCustomToolsService.buildCustomTool(agentId, projectId, code, descriptor, { user, modifiedBy: 'builder' });
-                return { ok: true, id: built.id, name: descriptor.name };
+                created = await this.agentTaskService.createTasks(agentId, projectId, tasks.map((task) => ({ ...task, enabled: true })), { user, modifiedBy: 'builder' });
             }
             catch (e) {
-                if (ctx.abortSignal ? ctx.abortSignal.aborted : (0, agents_1.isAbortError)(e))
-                    throw e;
                 return {
                     ok: false,
                     errors: [{ message: e instanceof Error ? e.message : String(e) }],
                 };
             }
+            return {
+                ok: true,
+                tasks: created.map(({ id, name }) => ({ id, name, enabled: true })),
+            };
         })
             .build();
-        const createSkillsTool = new tool_1.Tool(builder_tool_names_1.BUILDER_TOOLS.CREATE_SKILLS)
-            .description('Create and store one or more agent skills (reusable, load-on-demand capabilities) in a ' +
-            'single call. Pass every skill you currently know how to write in one `skills` array — do ' +
-            "not spread multiple fully-specified skills across separate calls; each skill's instructions " +
-            'field carries its own structured template. The whole batch is all-or-nothing: an invalid or ' +
-            'duplicate-named skill rejects every skill in the call. This does NOT attach the skills to the ' +
-            'agent config; follow up with read_config and patch_config (or write_config) to add a ' +
-            '`{ type: "skill", id }` entry per skill to `skills`. Returns { ok: true, skills: [{ id, name }, ' +
-            '...] } (same order as input, bodies are not echoed back) or { ok: false, errors }.')
-            .systemInstruction('Never create a vague or placeholder skill. The description field is the routing contract the ' +
-            'runtime uses to decide when to load the skill; the instructions must follow the required ' +
-            'structured Markdown template (Overview, Inputs, Steps, Rules, Example, Gotchas) with each ' +
-            'applicable section filled in with concrete, specific content. If you do not have enough domain ' +
-            "detail to write a genuinely useful skill, derive it from the user's goal as stated assumptions " +
-            'listed in your summary; ask the user clarifying questions only when even a reasonable ' +
-            'assumption is impossible. Use allowedTools only with exact target-agent tool names. Use references ' +
-            'only for markdown supporting files under the references/ directory — references are not ' +
-            'automatically loaded, so instructions must say exactly when to load each one by path; scripts and ' +
-            'non-markdown linked files are not supported. Do not invent tool names or reference paths. Batch ' +
-            'every skill you currently know how to write into one call.')
-            .input(zod_1.z.object({
-            skills: zod_1.z
-                .array(createSkillInputSchema)
-                .min(1)
-                .max(20)
-                .describe('Every skill to create, in the order they should be created.'),
-        }))
-            .handler(async ({ skills }) => {
+    }
+    buildUpdateTaskTool(agentId, projectId, user) {
+        return new tool_1.Tool(builder_tool_names_1.BUILDER_TOOLS.UPDATE_TASK)
+            .description('Update selected body fields of an existing target-agent scheduled task in place, preserving ' +
+            'its id and config reference. Returns { ok: true, id, name, configMutated: true, agentId } ' +
+            'or { ok: false, errors }.')
+            .input(updateTaskInputSchema)
+            .handler(async ({ taskId, updates }) => {
+            const editorLock = await this.getEditorLockFailure(agentId);
+            if (editorLock)
+                return editorLock;
             try {
-                const created = await this.agentSkillsService.createSkills(agentId, projectId, skills, {
+                const { task, changed } = await this.agentTaskService.updateWithChange(agentId, projectId, taskId, updates, {
                     user,
                     modifiedBy: 'builder',
                 });
-                return {
-                    ok: true,
-                    skills: created.map(({ id, skill }) => ({ id, name: skill.name })),
-                };
-            }
-            catch (e) {
-                return {
-                    ok: false,
-                    errors: [{ message: e instanceof Error ? e.message : String(e) }],
-                };
-            }
-        })
-            .build();
-        const readSkillTool = new tool_1.Tool(builder_tool_names_1.BUILDER_TOOLS.READ_SKILL)
-            .description('Read an existing target-agent skill by id. The response includes its instructions, but ' +
-            'references are returned as { path, characterCount } metadata by default to keep context small. ' +
-            'Pass only the referencePaths whose content you need. Returns { ok: true, id, skill, skillHash } or ' +
-            '{ ok: false, errors }. Call this before every update_skill and use skillHash as baseSkillHash.')
-            .input(readSkillInputSchema)
-            .handler(async ({ skillId, referencePaths = [] }) => {
-            try {
-                const skill = await this.agentSkillsService.getSkill(agentId, projectId, skillId);
-                const skillHash = (0, agent_config_hash_1.getAgentSkillHash)(skill);
-                const { references, ...body } = skill;
-                const requestedPaths = new Set(referencePaths);
-                const knownPaths = new Set(references?.map((reference) => reference.path) ?? []);
-                const missingPaths = referencePaths.filter((path) => !knownPaths.has(path));
-                if (missingPaths.length > 0) {
-                    return {
-                        ok: false,
-                        errors: [
-                            {
-                                message: `Reference path${missingPaths.length === 1 ? '' : 's'} not found: ${missingPaths.join(', ')}`,
-                            },
-                        ],
-                    };
-                }
-                return {
-                    ok: true,
-                    id: skillId,
-                    skillHash,
-                    skill: {
-                        ...body,
-                        ...(references
-                            ? {
-                                references: references.map((reference) => ({
-                                    path: reference.path,
-                                    characterCount: reference.content.length,
-                                    ...(requestedPaths.has(reference.path) ? { content: reference.content } : {}),
-                                })),
-                            }
-                            : {}),
-                    },
-                };
+                return { ok: true, id: task.id, name: task.name, ...(changed ? {} : { changed }) };
             }
             catch (e) {
                 return {
@@ -838,40 +662,20 @@ let AgentsBuilderToolsService = class AgentsBuilderToolsService {
             }
         })
             .build();
-        const listSkillsTool = new tool_1.Tool(builder_tool_names_1.BUILDER_TOOLS.LIST_SKILLS)
-            .description('List lightweight metadata for persisted target-agent skills. Use this to identify which ' +
-            'existing skill owns a capability before reading or creating a skill. Returns ' +
-            '{ ok: true, skills: [{ id, name, description }] } or { ok: false, errors }.')
-            .input(zod_1.z.object({}).strict())
-            .handler(async () => {
-            try {
-                const skills = await this.agentSkillsService.listSkills(agentId, projectId);
-                return {
-                    ok: true,
-                    skills: Object.entries(skills).map(([id, skill]) => ({
-                        id,
-                        name: skill.name,
-                        description: skill.description,
-                    })),
-                };
-            }
-            catch (e) {
-                return {
-                    ok: false,
-                    errors: [{ message: e instanceof Error ? e.message : String(e) }],
-                };
-            }
-        })
-            .build();
-        const updateSkillTool = new tool_1.Tool(builder_tool_names_1.BUILDER_TOOLS.UPDATE_SKILL)
+    }
+    buildUpdateSkillTool(agentId, projectId, user) {
+        return new tool_1.Tool(builder_tool_names_1.BUILDER_TOOLS.UPDATE_SKILL)
             .description('Update selected fields of an existing target-agent skill in place, preserving its id and ' +
-            'agent config reference. Requires baseSkillHash from the immediately preceding read_skill ' +
+            'agent config reference. Requires baseSkillHash from the immediately preceding agent-context with type "skill" ' +
             'result. Pass null for allowedTools to remove the tool restriction, or null ' +
             'for references to remove all references; empty arrays are invalid. Returns ' +
             '{ ok: true, id, name, configMutated: true, agentId } or { ok: false, errors }. On a stale ' +
-            'skill error, call read_skill and retry once with its fresh skillHash.')
+            'skill error, call agent-context with type "skill" and retry once with its fresh skillHash.')
             .input(updateSkillInputSchema)
             .handler(async ({ skillId, baseSkillHash, updates }) => {
+            const editorLock = await this.getEditorLockFailure(agentId);
+            if (editorLock)
+                return editorLock;
             const { allowedTools, references, ...requiredUpdates } = updates;
             const normalizedUpdates = {
                 ...requiredUpdates,
@@ -880,62 +684,64 @@ let AgentsBuilderToolsService = class AgentsBuilderToolsService {
             };
             try {
                 const updated = await this.agentSkillsService.updateSkill(agentId, projectId, skillId, normalizedUpdates, { user, modifiedBy: 'builder' }, baseSkillHash);
-                return { ok: true, id: updated.id, name: updated.skill.name };
-            }
-            catch (e) {
-                const message = e instanceof Error ? e.message : String(e);
-                return {
-                    ok: false,
-                    errors: [{ message: e instanceof conflict_error_1.ConflictError ? STALE_SKILL_ERROR_MESSAGE : message }],
-                };
-            }
-        })
-            .build();
-        const listTasksTool = new tool_1.Tool(builder_tool_names_1.BUILDER_TOOLS.LIST_TASKS)
-            .description('List the target agent scheduled tasks, including each persisted body and whether its ' +
-            'current config reference is enabled. Use this to identify a task before updating it. Returns ' +
-            '{ ok: true, tasks: [{ id, name, objective, cronExpression, timezone, enabled }] } or ' +
-            '{ ok: false, errors }.')
-            .input(zod_1.z.object({}).strict())
-            .handler(async () => {
-            try {
-                const agent = await this.agentsService.findById(agentId, projectId);
-                if (!agent)
-                    throw new Error('Agent not found');
-                const tasks = await this.agentTaskService.list(agentId);
-                const enabledByTaskId = new Map(((0, agent_config_composition_1.composeJsonConfig)(agent)?.tasks ?? []).map((task) => [task.id, task.enabled]));
                 return {
                     ok: true,
-                    tasks: tasks.map(({ id, name, objective, cronExpression, timezone }) => ({
-                        id,
-                        name,
-                        objective,
-                        cronExpression,
-                        timezone,
-                        enabled: enabledByTaskId.get(id) ?? false,
-                    })),
+                    id: updated.id,
+                    name: updated.skill.name,
+                    ...(updated.skillHash === baseSkillHash ? { changed: false } : {}),
                 };
             }
             catch (e) {
+                const message = e instanceof Error ? e.message : String(e);
                 return {
                     ok: false,
-                    errors: [{ message: e instanceof Error ? e.message : String(e) }],
+                    errors: [{ message: e instanceof conflict_error_1.ConflictError ? STALE_SKILL_ERROR_MESSAGE : message }],
                 };
             }
         })
             .build();
-        const updateTaskTool = new tool_1.Tool(builder_tool_names_1.BUILDER_TOOLS.UPDATE_TASK)
-            .description('Update selected body fields of an existing target-agent scheduled task in place, preserving ' +
-            'its id and config reference. Returns { ok: true, id, name, configMutated: true, agentId } ' +
-            'or { ok: false, errors }.')
-            .input(updateTaskInputSchema)
-            .handler(async ({ taskId, updates }) => {
+    }
+    buildCreateSkillsTool(agentId, projectId, user) {
+        return new tool_1.Tool(builder_tool_names_1.BUILDER_TOOLS.CREATE_SKILLS)
+            .description('Create and store one or more agent skills (reusable, load-on-demand capabilities) in a ' +
+            'single call. Pass every skill you currently know how to write in one `skills` array — do ' +
+            "not spread multiple fully-specified skills across separate calls; each skill's instructions " +
+            'field carries its own structured template. The whole batch is all-or-nothing: an invalid or ' +
+            'duplicate-named skill rejects every skill in the call. This does NOT attach the skills to the ' +
+            'agent config; follow up with agent-context with type "config" and patch_config (or write_config) to add a ' +
+            '`{ type: "skill", id }` entry per skill to `skills`. Returns { ok: true, skills: [{ id, name }, ' +
+            '...] } (same order as input, bodies are not echoed back) or { ok: false, errors }.')
+            .systemInstruction('Never create a vague or placeholder skill. The description field is the routing contract the ' +
+            'runtime uses to decide when to load the skill; the instructions must follow the required ' +
+            'structured Markdown template (Overview, Inputs, Steps, Rules, Example, Gotchas) with each ' +
+            'applicable section filled in with concrete, specific content. If you do not have enough domain ' +
+            "detail to write a genuinely useful skill, derive it from the user's goal as stated assumptions " +
+            'listed in your summary; ask the user clarifying questions only when even a reasonable ' +
+            'assumption is impossible. Use allowedTools only with exact target-agent tool names. Use references ' +
+            'only for markdown supporting files under the references/ directory — references are not ' +
+            'automatically loaded, so instructions must say exactly when to load each one by path; scripts and ' +
+            'non-markdown linked files are not supported. Do not invent tool names or reference paths. Batch ' +
+            'every skill you currently know how to write into one call.')
+            .input(zod_1.z.object({
+            skills: zod_1.z
+                .array(createSkillInputSchema)
+                .min(1)
+                .max(20)
+                .describe('Every skill to create, in the order they should be created.'),
+        }))
+            .handler(async ({ skills }) => {
+            const editorLock = await this.getEditorLockFailure(agentId);
+            if (editorLock)
+                return editorLock;
             try {
-                const updated = await this.agentTaskService.update(agentId, projectId, taskId, updates, {
+                const created = await this.agentSkillsService.createSkills(agentId, projectId, skills, {
                     user,
                     modifiedBy: 'builder',
                 });
-                return { ok: true, id: updated.id, name: updated.name };
+                return {
+                    ok: true,
+                    skills: created.map(({ id, skill }) => ({ id, name: skill.name })),
+                };
             }
             catch (e) {
                 return {
@@ -945,94 +751,41 @@ let AgentsBuilderToolsService = class AgentsBuilderToolsService {
             }
         })
             .build();
-        const createTasksTool = new tool_1.Tool(builder_tool_names_1.BUILDER_TOOLS.CREATE_TASKS)
-            .description('Create one or more recurring scheduled tasks for the target agent (name + objective + cron ' +
-            'schedule per task) in a single call. Pass every task you currently know how to write in one ' +
-            "`tasks` array — do not spread multiple fully-specified tasks across separate calls; each task's " +
-            'objective field carries its own structured template. The whole batch is all-or-nothing: an ' +
-            'invalid cron or objective rejects every task in the call. This adds a `{ type: "task", id, ' +
-            'enabled }` ref per task to the agent config (config.tasks) and each task starts running once ' +
-            'the agent is (re)published via `publish_agent`. Returns { ok: true, configMutated: true, agentId, tasks: [{ id, name, enabled }, ...] } (same ' +
-            'order as input, objectives and crons are not echoed back) or { ok: false, errors }.')
-            .systemInstruction('Never create a task with a vague, broad, or placeholder objective, an objective missing any ' +
-            'required section, or an unclear schedule. Each objective must follow the required structured ' +
-            'Markdown template (Objective, Context, Steps, Output, Constraints, Success criteria) with every ' +
-            'section filled in with concrete, run-specific content. Agent Instructions still apply and ' +
-            'configured Skills remain available during scheduled runs, so never repeat universal rules or ' +
-            "copy reusable procedures into an objective. If anything is ambiguous, derive it from the user's goal as " +
-            'stated assumptions listed in your summary; ask the user clarifying questions with ask_questions ' +
-            'only when even a reasonable assumption is impossible, before calling ' +
-            'create_tasks. A task can only use tools the agent already has: if any step in an objective ' +
-            'requires a tool, integration, or web search the agent is missing, you MUST add it to the agent ' +
-            'config (patch_config/write_config) BEFORE calling create_tasks — otherwise the task will fail at ' +
-            'runtime. Batch every task you currently know how to write into one call.')
+    }
+    buildCustomToolTool(agentId, projectId, user) {
+        return new tool_1.Tool(builder_tool_names_1.BUILDER_TOOLS.BUILD_CUSTOM_TOOL)
+            .description('Compile and store a custom tool. Pass the complete TypeScript source ' +
+            'using `export default new Tool(...)` builder chain. The code is validated in a ' +
+            'sandbox and saved against the agent. The returned `id` equals the tool name ' +
+            'declared in the code (e.g. `new Tool("my_tool")` → id `"my_tool"`). ' +
+            'This does NOT register the tool in the agent config — follow up with ' +
+            'patch_config (or write_config) to add `{ type: "custom", id: "<tool name>" }` ' +
+            'to `tools`.' +
+            'Returns { ok: true, id, name } or { ok: false, errors }.')
             .input(zod_1.z.object({
-            tasks: zod_1.z
-                .array(zod_1.z.object({
-                name: api_types_1.agentTaskSchema.shape.name.describe('Short, human-readable task name.'),
-                objective: api_types_1.agentTaskSchema.shape.objective.describe(task_objective_template_1.TASK_OBJECTIVE_GUIDANCE),
-                cronExpression: api_types_1.agentTaskSchema.shape.cronExpression.describe('A 5-field cron expression for when the task runs, e.g. "0 9 * * 1-5" = weekdays at 09:00.'),
-                timezone: api_types_1.agentTaskSchema.shape.timezone.describe('IANA timezone the cron runs in, e.g. "Europe/London". Set it when the user names a timezone or a location; omit it to use the instance timezone.'),
-            }))
-                .min(1)
-                .max(20)
-                .describe('Every task to create, in the order they should be created.'),
+            code: zod_1.z
+                .string()
+                .describe('Complete TypeScript source using export default new Tool(...)'),
         }))
-            .handler(async ({ tasks, }) => {
-            let created;
+            .handler(async ({ code }, ctx) => {
+            const editorLock = await this.getEditorLockFailure(agentId);
+            if (editorLock)
+                return editorLock;
             try {
-                created = await this.agentTaskService.createTasks(agentId, projectId, tasks.map((task) => ({ ...task, enabled: true })), { user, modifiedBy: 'builder' });
+                const descriptor = await this.secureRuntime.describeToolSecurely(code);
+                const built = await this.agentCustomToolsService.buildCustomTool(agentId, projectId, code, descriptor, { user, modifiedBy: 'builder' });
+                return { ok: true, id: built.id, name: descriptor.name, changed: built.changed };
             }
             catch (e) {
+                if (ctx.abortSignal ? ctx.abortSignal.aborted : (0, agents_1.isAbortError)(e))
+                    throw e;
                 return {
                     ok: false,
                     errors: [{ message: e instanceof Error ? e.message : String(e) }],
                 };
             }
-            return {
-                ok: true,
-                tasks: created.map(({ id, name }) => ({ id, name, enabled: true })),
-            };
         })
             .build();
-        const listWorkflowsTool = new tool_1.Tool(builder_tool_names_1.BUILDER_TOOLS.LIST_WORKFLOWS)
-            .description('List the n8n workflows that can be attached as tools via `type: "workflow"` in the agent config. ' +
-            `Only returns workflows that start with a '${api_types_1.WORKFLOW_TOOL_TRIGGER_DISPLAY_NAME}' trigger. ` +
-            'The published agent cannot call a workflow with `published: false` until the user publishes it. ' +
-            'Pass `searchTerm` to narrow by workflow name; ' +
-            'omitting it returns the 10 most recently updated attachable workflows.')
-            .input(zod_1.z.object({
-            searchTerm: zod_1.z
-                .string()
-                .optional()
-                .describe('Optional workflow-name search term. Omit to return the first 10 results.'),
-        }))
-            .handler(async ({ searchTerm }) => {
-            return {
-                workflows: await this.attachableWorkflowsService.list(user, projectId, searchTerm),
-            };
-        })
-            .build();
-        return [
-            buildCustomToolTool,
-            createSkillsTool,
-            listSkillsTool,
-            readSkillTool,
-            this.withConfigMutationMarker(updateSkillTool, agentId),
-            this.withConfigMutationMarker(createTasksTool, agentId),
-            listTasksTool,
-            this.withConfigMutationMarker(updateTaskTool, agentId),
-            listWorkflowsTool,
-            (0, get_resource_locator_options_tool_1.buildGetResourceLocatorOptionsTool)({
-                dynamicNodeParametersService: this.dynamicNodeParametersService,
-                nodeTypes: this.nodeTypes,
-                user,
-                projectId,
-            }),
-            ...this.agentsToolsService.getSharedTools(credentialProvider, 'Read-only inspection of available credentials. Use ask_credential to let the user ' +
-                'pick the credential to wire into a node tool — never copy ids from this list directly ' +
-                'into the config.'),
-        ];
     }
     async getConfigSnapshot(agentId, projectId) {
         const agent = await this.agentsService.findById(agentId, projectId);
@@ -1042,6 +795,9 @@ let AgentsBuilderToolsService = class AgentsBuilderToolsService {
         return snapshotFromConfig(config);
     }
     async applyCredentialToMcpServer(agentId, projectId, serverName, credentialId, user) {
+        if (await this.getEditorLockFailure(agentId)) {
+            return { applied: false };
+        }
         const snapshot = await this.getConfigSnapshot(agentId, projectId);
         const config = snapshot.config;
         const servers = config?.mcpServers;
@@ -1070,10 +826,171 @@ let AgentsBuilderToolsService = class AgentsBuilderToolsService {
         });
         return { applied: true };
     }
+    async getFreshConfigSnapshot(agentId, projectId, baseConfigHash) {
+        try {
+            const snapshot = await this.getConfigSnapshot(agentId, projectId);
+            if (baseConfigHash !== snapshot.configHash) {
+                return { ok: false, stage: 'stale', errors: [STALE_CONFIG_ERROR] };
+            }
+            return { ok: true, snapshot };
+        }
+        catch (e) {
+            return {
+                ok: false,
+                stage: 'stale',
+                errors: [{ path: '(root)', message: e instanceof Error ? e.message : String(e) }],
+            };
+        }
+    }
+    validateBuilderConfig(incoming, currentConfig) {
+        const parsed = parseBuilderWriteConfig(incoming, currentConfig);
+        if (!parsed.success)
+            return { ok: false, errors: (0, api_types_1.formatZodErrors)(parsed.error) };
+        const emptyInstructions = (0, agent_config_1.rejectIfEmptyInstructions)(parsed.data, CLI_AGENT_CONFIG_MESSAGES);
+        if (emptyInstructions)
+            return { ok: false, errors: emptyInstructions };
+        const unsupportedWebSearch = (0, agent_config_1.rejectIfUnsupportedNativeWebSearch)(parsed.data);
+        if (unsupportedWebSearch)
+            return { ok: false, errors: unsupportedWebSearch };
+        const dynamicSelectorFromAi = (0, agent_config_1.rejectIfDynamicSelectorUsesFromAi)(parsed.data, currentConfig, this.nodeTypes, CLI_AGENT_CONFIG_MESSAGES);
+        if (dynamicSelectorFromAi)
+            return { ok: false, errors: dynamicSelectorFromAi };
+        const config = applyPromptCachingBuilderDefaults((0, agent_config_1.applyNativeWebSearchDefaultOn)(parsed.data));
+        return { ok: true, config };
+    }
+    async saveBuilderConfig(agentId, projectId, user, config, baseConfigHash) {
+        try {
+            await this.agentConfigService.updateConfig(agentId, projectId, config, user, {
+                baseConfigHash,
+                modifiedBy: 'builder',
+            });
+            return { ok: true };
+        }
+        catch (e) {
+            return {
+                ok: false,
+                stage: e instanceof conflict_error_1.ConflictError ? 'stale' : 'schema',
+                errors: [{ path: '(root)', message: e instanceof Error ? e.message : String(e) }],
+            };
+        }
+    }
+    async writeBuilderConfig(agentId, projectId, user, json, baseConfigHash) {
+        const editorLock = await this.getEditorLockFailure(agentId);
+        if (editorLock)
+            return editorLock;
+        const parsed = (0, api_types_1.tryParseConfigJson)(json);
+        if (!parsed.ok)
+            return { ok: false, errors: parsed.errors };
+        const fresh = await this.getFreshConfigSnapshot(agentId, projectId, baseConfigHash);
+        if (!fresh.ok)
+            return fresh;
+        const validated = this.validateBuilderConfig(parsed.data, fresh.snapshot.config);
+        if (!validated.ok)
+            return validated;
+        return await this.saveBuilderConfig(agentId, projectId, user, validated.config, fresh.snapshot.configHash);
+    }
+    async patchBuilderConfig(agentId, projectId, user, operations, baseConfigHash) {
+        const editorLock = await this.getEditorLockFailure(agentId);
+        if (editorLock)
+            return { ...editorLock, stage: 'locked' };
+        const parsed = (0, api_types_1.tryParseConfigJson)(operations);
+        if (!parsed.ok)
+            return { ok: false, stage: 'parse', errors: parsed.errors };
+        const fresh = await this.getFreshConfigSnapshot(agentId, projectId, baseConfigHash);
+        if (!fresh.ok)
+            return fresh;
+        if (!fresh.snapshot.config) {
+            return {
+                ok: false,
+                stage: 'patch',
+                errors: [{ path: '(root)', message: 'Agent has no JSON config yet.' }],
+            };
+        }
+        const patched = await this.applyConfigPatch(parsed.data, fresh.snapshot.config);
+        if (!patched.ok)
+            return patched;
+        const validated = this.validateBuilderConfig(patched.config, fresh.snapshot.config);
+        if (!validated.ok)
+            return { ...validated, stage: 'schema' };
+        return await this.saveBuilderConfig(agentId, projectId, user, validated.config, fresh.snapshot.configHash);
+    }
+    async applyConfigPatch(operations, config) {
+        const jsonpatch = (await import('fast-json-patch')).default;
+        const ops = operations;
+        const patchError = jsonpatch.validate(ops, config);
+        if (patchError) {
+            const opPath = patchError.operation?.path ?? '(root)';
+            return {
+                ok: false,
+                stage: 'patch',
+                errors: [{ path: opPath, message: patchError.message ?? 'Invalid patch operation' }],
+            };
+        }
+        return { ok: true, config: jsonpatch.applyPatch(jsonpatch.deepClone(config), ops).newDocument };
+    }
+    async formatDraftTestResult(result, ctx, agentId, user, previewPath) {
+        if (result.status === 'session_not_found') {
+            return {
+                status: 'error',
+                code: 'session_not_found',
+                message: 'Session not found.',
+            };
+        }
+        if (result.status === 'agent_misconfigured') {
+            return {
+                status: 'error',
+                code: 'agent_misconfigured',
+                message: "This agent isn't ready to run yet. Finish configuring it and try again.",
+                missing: result.missing,
+            };
+        }
+        if (result.status === 'completed')
+            return result;
+        const approvals = (0, agent_test_run_service_1.collectStandardApprovals)(result);
+        const firstApproval = approvals?.[0];
+        if (firstApproval) {
+            const { continuation, ...approval } = firstApproval;
+            return await ctx.suspend(approval, { continuation });
+        }
+        return await this.cancelUnsupportedDraftTest(result, agentId, user, previewPath);
+    }
+    async cancelUnsupportedDraftTest(result, agentId, user, previewPath) {
+        const cancelled = await this.agentTestRunService.cancelSuspendedRuns({
+            agentId,
+            suspensions: result.suspensions,
+            userId: user.id,
+        });
+        if (!cancelled) {
+            return {
+                status: 'error',
+                code: 'cancellation_failed',
+                message: 'This test needs approval, but its suspended run could not be cancelled. Open Preview before continuing this session.',
+                sessionId: result.sessionId,
+                previewPath,
+            };
+        }
+        return {
+            status: 'approval_required',
+            response: result.response,
+            sessionId: result.sessionId,
+            ...(result.executionId ? { executionId: result.executionId } : {}),
+            suspensions: result.suspensions.map(({ runId, toolCallId, toolName }) => ({
+                runId,
+                toolCallId,
+                toolName,
+            })),
+            previewPath,
+        };
+    }
+    createModelLookup(user, projectId, options) {
+        return {
+            list: async (credentialId, credentialType, provider) => await this.builderModelLiveLookupService.list(user, projectId, credentialId, credentialType, provider, { useEvalModelCatalog: options?.useEvalModelCatalog === true }),
+        };
+    }
 };
 exports.AgentsBuilderToolsService = AgentsBuilderToolsService;
 exports.AgentsBuilderToolsService = AgentsBuilderToolsService = __decorate([
     (0, di_1.Service)(),
-    __metadata("design:paramtypes", [agents_service_1.AgentsService, agent_config_service_1.AgentConfigService, agent_custom_tools_service_1.AgentCustomToolsService, agent_integration_persistence_service_1.AgentIntegrationPersistenceService, agent_skills_service_1.AgentSkillsService, agent_secure_runtime_1.AgentSecureRuntime, attachable_workflows_service_1.AttachableWorkflowsService, agents_tools_service_1.AgentsToolsService, builder_model_live_lookup_service_1.BuilderModelLiveLookupService, mcp_registry_service_1.McpRegistryService, oauth_service_1.OauthService, credential_types_1.CredentialTypes, agent_task_service_1.AgentTaskService, agent_publish_service_1.AgentPublishService, agent_test_run_service_1.AgentTestRunService, ai_service_1.AiService, ai_gateway_service_1.AiGatewayService, backend_network_1.OutboundHttp, dynamic_node_parameters_service_1.DynamicNodeParametersService, node_types_1.NodeTypes, free_ai_credits_service_1.FreeAiCreditsService, telemetry_1.Telemetry])
+    __metadata("design:paramtypes", [backend_common_1.Logger, agents_service_1.AgentsService, agent_config_service_1.AgentConfigService, agent_custom_tools_service_1.AgentCustomToolsService, agent_integration_persistence_service_1.AgentIntegrationPersistenceService, agent_skills_service_1.AgentSkillsService, agent_secure_runtime_1.AgentSecureRuntime, agents_tools_service_1.AgentsToolsService, builder_model_live_lookup_service_1.BuilderModelLiveLookupService, mcp_registry_service_1.McpRegistryService, oauth_service_1.OauthService, credential_types_1.CredentialTypes, agent_task_service_1.AgentTaskService, agent_publish_service_1.AgentPublishService, agent_test_run_service_1.AgentTestRunService, ai_service_1.AiService, ai_gateway_service_1.AiGatewayService, backend_network_1.OutboundHttp, dynamic_node_parameters_service_1.DynamicNodeParametersService, node_types_1.NodeTypes, free_ai_credits_service_1.FreeAiCreditsService, telemetry_1.Telemetry, instance_ai_agent_context_adapter_1.InstanceAiAgentContextAdapterService, collaboration_service_1.CollaborationService])
 ], AgentsBuilderToolsService);
 //# sourceMappingURL=agents-builder-tools.service.js.map