n8n 2.34.4 → 2.35.1

package/dist/modules/mcp/tools/agents/agent-reference.d.ts

@@ -5,5 +5,5 @@ export declare const AGENT_CONFIG_JSON_SCHEMA: import("zod-to-json-schema").Json
         [key: string]: import("zod-to-json-schema").JsonSchema7Type;
     } | undefined;
 };
-export declare const AGENT_BUILDER_GUIDE = "# n8n Agent management\n\nUse the Agent MCP tools to create and edit persisted n8n Agents. The MCP client is the\norchestrator: there is no nested conversational Agent Builder.\n\n## Choose an Agent or workflow\n\nAn n8n Agent is a first-class persisted resource with its own instructions, model, tools, skills,\ntasks, memory, integrations, and lifecycle. An AI Agent node is a node inside a workflow whose\ntrigger, surrounding graph, and lifecycle are owned by that workflow.\n\nIf the request is actually a fixed trigger or schedule with enumerable, repeatable steps, it is\nprobably a workflow \u2014 explain the mismatch and ask before building the alternative. Never substitute\na Chat Trigger plus an AI Agent node for a requested n8n Agent.\n\n## Build sequence\n\n1. Use search_projects to identify the project, or search_agents and get_agent for an existing Agent.\n   By-ID tools (get_agent, mutate_agent, validate_agent, publish_agent, unpublish_agent,\n   revert_agent, list_agent_versions, delete_agent, update_agent_integration) take an agentId alone\n   and resolve the project from it.\n2. Use discover_agent_assets plus list_credentials, search_nodes, get_node_types, and\n   explore_node_resources to ground model, tool, workflow, integration, and credential choices.\n3. For a new Agent, call create_agent with the initial config after discovering its assets. The\n   top-level name is injected into config; omit config only when the Agent ID is needed first.\n4. Call mutate_agent once per logical sidecar or subsequent mutation, always passing the latest\n   configHash. Skills, tasks, and custom tools are created after the Agent because they need\n   server-generated IDs.\n5. Call validate_agent and resolve every reported error. A valid Agent is a completed draft; do not\n   publish it merely to finish the build.\n6. Report that the draft is ready, include a clickable link using the `url` returned by\n   validate_agent, and ask whether the user wants to publish it.\n7. Call publish_agent only when the user explicitly requested publication, activation, deployment,\n   or making the Agent live, or confirms publication after the build.\n8. Use update_agent_integration to configure chat integrations. Configuration never publishes the\n   Agent. A configured channel stays inactive until explicit publication unless the Agent already has an active version.\n\n## Publication approval\n\nBuilding, editing, validating, or configuring an Agent never implies permission to publish or\nrepublish it. Leave the Agent as a draft by default. An explicit request to publish, activate,\ndeploy, or make live counts as approval; otherwise ask after validation and wait for the answer\nbefore calling publish_agent. Configuring a channel on an already published Agent connects it\nimmediately, so confirm that external connection before calling update_agent_integration.\n\n## Version history\n\nlist_agent_versions lists an Agent's published versions; get_agent with a versionId inspects one\nbefore acting on it. revert_agent restores the draft from a version without publishing, returning a\nfresh configHash for further mutations. publish_agent with a versionId republishes that version\ndirectly, leaving the draft untouched; as a (re)publication it requires the same explicit approval.\n\nIn publish, unpublish, and revert responses, `activeVersionId` identifies the live published\nversion (null when unpublished) while `versionId` is the draft's internal pointer \u2014 do not report\n`versionId` as a published version.\n\n## mutate_agent operations\n\nPass a single `operation` object whose `type` selects the mutation. Each operation's fields sit\ndirectly on that object \u2014 there is no `value` wrapper. For example:\n\n```json\n{ \"type\": \"config.patch\", \"patch\": [{ \"op\": \"add\", \"path\": \"/tools/-\", \"value\": { \"type\": \"workflow\", \"workflow\": \"My Workflow\", \"name\": \"my_tool\" } }] }\n```\n\n- config.replace: Set `config` to the complete editable Agent JSON configuration. Must not include\n  integrations; use update_agent_integration for those.\n- config.patch: Set `patch` to an array of RFC 6902 operations (add, remove, replace, move, copy,\n  test). Paths under /integrations are rejected; use update_agent_integration for those.\n- skill.upsert: Set `skill` to the complete skill body. Omit `skillId` to create and attach a new\n  skill, or pass it to replace an existing skill body.\n- skill.delete: Set `skillId` to the skill to delete; its config reference is removed.\n- task.upsert: Set `task` to the complete task body. Omit `taskId` to create and attach a new\n  scheduled task, or pass it to replace an existing one. `enabled` controls the task config reference.\n- task.delete: Set `taskId` to the task to delete; its config reference is removed.\n- customTool.upsert: Set `code` to the tool source; it is compiled, validated, stored, and attached.\n  Only `@n8n/agents` and `zod` imports are available. The default export must be a Tool builder\n  chain with `description`, `input` (a Zod schema), and `handler`; `output` is optional:\n\n  ```typescript\n  import { Tool } from '@n8n/agents';\n  import { z } from 'zod';\n\n  export default new Tool('get_current_datetime')\n  \t.description('Return the current date and time as an ISO 8601 string')\n  \t.input(z.object({}))\n  \t.handler(async () => new Date().toISOString());\n  ```\n- customTool.delete: Set `toolId` to the custom tool to delete; its config reference is removed.\n\nEvery mutation requires baseConfigHash from get_agent or the previous successful mutation. Mutation\nresponses contain only the next configHash and the affected resource ID, not the full Agent. On a\nstale_config response, call get_agent and retry against the returned snapshot.\n\n## Agent JSON configuration\n\nThe required runnable fields are name, model, credential, and instructions. Common optional fields\ninclude tools, skills, tasks, memory, subAgents, providerTools, mcpServers, vectorStores,\npersonalisation, and config. Integrations are not part of this config (see below).\n\nTool references use these forms:\n\n- Custom tool: { \"type\": \"custom\", \"id\": \"tool_name\" }\n- Workflow tool: { \"type\": \"workflow\", \"workflow\": \"Workflow Name\", \"name\": \"tool_name\" }\n- Node tool: { \"type\": \"node\", \"name\": \"tool_name\", \"node\": { \"nodeType\": \"...\",\n  \"nodeTypeVersion\": 1, \"nodeParameters\": {}, \"credentials\": {} } }\n\nCreating a resource does not give the Agent access to it. For example, a data table created with\ncreate_data_table is only usable by the Agent once it is attached as a node tool\n(n8n-nodes-base.dataTable); discover it with search_nodes usage=\"agentTool\" like any other node.\n\nSub-agents are not tool entries. Configure them under the top-level `subAgents` field:\n{ \"subAgents\": { \"agents\": [{ \"agentId\": \"...\", \"useWhen\": \"...\" }] } }\n\nDo not guess node parameters or stable resource IDs. Discover the node definition and live resource\noptions first. Never place credential secret data in Agent configuration or MCP tool arguments; use\ncredential IDs returned by list_credentials.\n\nSkills and tasks have separately persisted bodies. Always manage them through mutate_agent instead\nof manually inventing their IDs. Saved sub-agents must be published Agents from the same project.\nUse discover_agent_assets with kind=subagents to obtain valid IDs.\n\nChat integrations are conversation surfaces, not ordinary node tools. Use an integration when users\nshould invoke and converse with the Agent in Slack, Telegram, or Linear. Use a node/workflow tool\nwhen the Agent only needs to call that service as an API.\n\nIntegrations are persisted separately from editable config. get_agent reports them in a read-only\nintegrations field, but config.replace and config.patch can't add, change, or remove them, and they\nnever appear in the config schema above. Manage them exclusively with update_agent_integration,\nwhich validates the credential and persists the configuration without publishing. A configured\nchannel stays inactive until publish_agent is called unless the Agent already has an active version;\nin that case, it connects immediately to the existing active snapshot.\n\n## MCP servers\n\nThe top-level `mcpServers` config array connects external MCP tool catalogs to the Agent. Discover\nregistry-backed servers with discover_agent_assets kind=mcpServers, or use a URL the user provides.\nWhen the server requires authentication, resolve an accessible credential ID with list_credentials\nfirst; the same ID is passed to verification and stored in the config entry. Credentials cannot be\ncreated through these tools \u2014 when none exists, ask the user to create one in n8n.\n\nBefore writing an entry into mcpServers, call verify_agent_mcp_server with the same name, url,\ntransport, authentication, and credential. The server does not need to be attached to the Agent\nfirst: verification opens a temporary connection and returns the server's live tools. validate_agent\nnever performs this handshake, so an unverified entry can pass validation and still fail at runtime.\nConfirm the returned tools cover the requested capability and use the list to populate toolFilter\ninstead of guessing tool names. If verification fails, report the error and resolve it with the user\ninstead of persisting a broken server. Only when the user cannot supply the URL or credential yet,\npersist the known fields without inventing values and skip verification.\n";
+export declare const AGENT_BUILDER_GUIDE = "# n8n Agent management\n\nUse the Agent MCP tools to create and edit persisted n8n Agents. The MCP client is the\norchestrator: there is no nested conversational Agent Builder.\n\n## Choose an Agent or workflow\n\nAn n8n Agent is a first-class persisted resource with its own instructions, model, tools, skills,\ntasks, memory, integrations, and lifecycle. An AI Agent node is a node inside a workflow whose\ntrigger, surrounding graph, and lifecycle are owned by that workflow.\n\nIf the request is actually a fixed trigger or schedule with enumerable, repeatable steps, it is\nprobably a workflow \u2014 explain the mismatch and ask before building the alternative. Never substitute\na Chat Trigger plus an AI Agent node for a requested n8n Agent.\n\n## Build sequence\n\n1. Use search_projects to identify the project, or search_agents and get_agent for an existing Agent.\n   By-ID tools (get_agent, mutate_agent, validate_agent, call_agent, publish_agent,\n   unpublish_agent, revert_agent, list_agent_versions, delete_agent, update_agent_integration) take\n   an agentId alone and resolve the project from it.\n2. Use discover_agent_assets plus list_credentials, search_nodes, get_node_types, and\n   explore_node_resources to ground model, tool, workflow, integration, and credential choices.\n3. For a new Agent, call create_agent with the initial config after discovering its assets. The\n   top-level name is injected into config; omit config only when the Agent ID is needed first.\n4. Call mutate_agent once per logical sidecar or subsequent mutation, always passing the latest\n   configHash. Skills, tasks, and custom tools are created after the Agent because they need\n   server-generated IDs.\n5. Call validate_agent and resolve every reported error. A valid Agent is a completed draft; do not\n   publish it merely to finish the build.\n6. After validation succeeds, if call_agent is available and authorized, send one representative\n   message before reporting the draft ready. Otherwise, report the successfully validated draft\n   ready without a test run.\n7. Report that the draft is ready, include a clickable link using the `url` returned by\n   validate_agent, and ask whether the user wants to publish it.\n8. Call publish_agent only when the user explicitly requested publication, activation, deployment,\n   or making the Agent live, or confirms publication after the build.\n9. Use update_agent_integration to configure chat integrations. Configuration never publishes the\n   Agent. A configured channel stays inactive until explicit publication unless the Agent already has an active version.\n\n## Draft test runs\n\ncall_agent verifies the draft Agent's behavior through built-in Preview chat, not configured channel\ntriggers, platform context, message delivery, or replies. Real tools and credentials are used, so\nside effects are possible. If the test exposes errors, report them and ask whether to fix them rather\nthan mutating the Agent automatically. Every approval decision must come from the human; resume each\nreturned approval individually.\n\n## Publication approval\n\nBuilding, editing, validating, or configuring an Agent never implies permission to publish or\nrepublish it. Leave the Agent as a draft by default. An explicit request to publish, activate,\ndeploy, or make live counts as approval; otherwise ask after validation and wait for the answer\nbefore calling publish_agent. Configuring a channel on an already published Agent connects it\nimmediately, so confirm that external connection before calling update_agent_integration.\n\n## Version history\n\nlist_agent_versions lists an Agent's published versions; get_agent with a versionId inspects one\nbefore acting on it. revert_agent restores the draft from a version without publishing, returning a\nfresh configHash for further mutations. publish_agent with a versionId republishes that version\ndirectly, leaving the draft untouched; as a (re)publication it requires the same explicit approval.\n\nIn publish, unpublish, and revert responses, `activeVersionId` identifies the live published\nversion (null when unpublished) while `versionId` is the draft's internal pointer \u2014 do not report\n`versionId` as a published version.\n\n## mutate_agent operations\n\nPass a single `operation` object whose `type` selects the mutation. Each operation's fields sit\ndirectly on that object \u2014 there is no `value` wrapper. For example:\n\n```json\n{ \"type\": \"config.patch\", \"patch\": [{ \"op\": \"add\", \"path\": \"/tools/-\", \"value\": { \"type\": \"workflow\", \"workflow\": \"My Workflow\", \"name\": \"my_tool\" } }] }\n```\n\n- config.replace: Set `config` to the complete editable Agent JSON configuration. Must not include\n  integrations; use update_agent_integration for those.\n- config.patch: Set `patch` to an array of RFC 6902 operations (add, remove, replace, move, copy,\n  test). Paths under /integrations are rejected; use update_agent_integration for those.\n- skill.upsert: Set `skill` to the complete skill body. Omit `skillId` to create and attach a new\n  skill, or pass it to replace an existing skill body.\n- skill.delete: Set `skillId` to the skill to delete; its config reference is removed.\n- task.upsert: Set `task` to the complete task body. Omit `taskId` to create and attach a new\n  scheduled task, or pass it to replace an existing one. `enabled` controls the task config reference.\n- task.delete: Set `taskId` to the task to delete; its config reference is removed.\n- customTool.upsert: Set `code` to the tool source; it is compiled, validated, stored, and attached.\n  Only `@n8n/agents` and `zod` imports are available. The default export must be a Tool builder\n  chain with `description`, `input` (a Zod schema), and `handler`; `output` is optional:\n\n  ```typescript\n  import { Tool } from '@n8n/agents';\n  import { z } from 'zod';\n\n  export default new Tool('get_current_datetime')\n  \t.description('Return the current date and time as an ISO 8601 string')\n  \t.input(z.object({}))\n  \t.handler(async () => new Date().toISOString());\n  ```\n- customTool.delete: Set `toolId` to the custom tool to delete; its config reference is removed.\n\nEvery mutation requires baseConfigHash from get_agent or the previous successful mutation. Mutation\nresponses contain only the next configHash and the affected resource ID, not the full Agent. On a\nstale_config response, call get_agent and retry against the returned snapshot.\n\n## Agent JSON configuration\n\nThe required runnable fields are name, model, credential, and instructions. Common optional fields\ninclude tools, skills, tasks, memory, subAgents, providerTools, mcpServers, vectorStores,\npersonalisation, and config. Integrations are not part of this config (see below).\n\nTool references use these forms:\n\n- Custom tool: { \"type\": \"custom\", \"id\": \"tool_name\" }\n- Workflow tool: { \"type\": \"workflow\", \"workflow\": \"Workflow Name\", \"name\": \"tool_name\" }\n- Node tool: { \"type\": \"node\", \"name\": \"tool_name\", \"node\": { \"nodeType\": \"...\",\n  \"nodeTypeVersion\": 1, \"nodeParameters\": {}, \"credentials\": {} } }\n\nCreating a resource does not give the Agent access to it. For example, a data table created with\ncreate_data_table is only usable by the Agent once it is attached as a node tool\n(n8n-nodes-base.dataTable); discover it with search_nodes usage=\"agentTool\" like any other node.\n\nSub-agents are not tool entries. Configure them under the top-level `subAgents` field:\n{ \"subAgents\": { \"agents\": [{ \"agentId\": \"...\", \"useWhen\": \"...\" }] } }\n\nDo not guess node parameters or stable resource IDs. Discover the node definition and live resource\noptions first. Never place credential secret data in Agent configuration or MCP tool arguments; use\ncredential IDs returned by list_credentials.\n\nSkills and tasks have separately persisted bodies. Always manage them through mutate_agent instead\nof manually inventing their IDs. Saved sub-agents must be published Agents from the same project.\nUse discover_agent_assets with kind=subagents to obtain valid IDs.\n\nChat integrations are conversation surfaces, not ordinary node tools. Use an integration when users\nshould invoke and converse with the Agent in Slack, Telegram, or Linear. Use a node/workflow tool\nwhen the Agent only needs to call that service as an API.\n\nIntegrations are persisted separately from editable config. get_agent reports them in a read-only\nintegrations field, but config.replace and config.patch can't add, change, or remove them, and they\nnever appear in the config schema above. Manage them exclusively with update_agent_integration,\nwhich validates the credential and persists the configuration without publishing. A configured\nchannel stays inactive until publish_agent is called unless the Agent already has an active version;\nin that case, it connects immediately to the existing active snapshot.\n\n## MCP servers\n\nThe top-level `mcpServers` config array connects external MCP tool catalogs to the Agent. Discover\nregistry-backed servers with discover_agent_assets kind=mcpServers, or use a URL the user provides.\nWhen the server requires authentication, resolve an accessible credential ID with list_credentials\nfirst; the same ID is passed to verification and stored in the config entry. Credentials cannot be\ncreated through these tools \u2014 when none exists, ask the user to create one in n8n.\n\nBefore writing an entry into mcpServers, call verify_agent_mcp_server with the same name, url,\ntransport, authentication, and credential. The server does not need to be attached to the Agent\nfirst: verification opens a temporary connection and returns the server's live tools. validate_agent\nnever performs this handshake, so an unverified entry can pass validation and still fail at runtime.\nConfirm the returned tools cover the requested capability and use the list to populate toolFilter\ninstead of guessing tool names. If verification fails, report the error and resolve it with the user\ninstead of persisting a broken server. Only when the user cannot supply the URL or credential yet,\npersist the known fields without inventing values and skip verification.\n";
 export declare const AGENT_BUILDER_REFERENCE: string;

package/dist/modules/mcp/tools/agents/agent-reference.js

@@ -26,9 +26,9 @@ a Chat Trigger plus an AI Agent node for a requested n8n Agent.
 ## Build sequence
 
 1. Use search_projects to identify the project, or search_agents and get_agent for an existing Agent.
-   By-ID tools (get_agent, mutate_agent, validate_agent, publish_agent, unpublish_agent,
-   revert_agent, list_agent_versions, delete_agent, update_agent_integration) take an agentId alone
-   and resolve the project from it.
+   By-ID tools (get_agent, mutate_agent, validate_agent, call_agent, publish_agent,
+   unpublish_agent, revert_agent, list_agent_versions, delete_agent, update_agent_integration) take
+   an agentId alone and resolve the project from it.
 2. Use discover_agent_assets plus list_credentials, search_nodes, get_node_types, and
    explore_node_resources to ground model, tool, workflow, integration, and credential choices.
 3. For a new Agent, call create_agent with the initial config after discovering its assets. The
@@ -38,13 +38,24 @@ a Chat Trigger plus an AI Agent node for a requested n8n Agent.
    server-generated IDs.
 5. Call validate_agent and resolve every reported error. A valid Agent is a completed draft; do not
    publish it merely to finish the build.
-6. Report that the draft is ready, include a clickable link using the \`url\` returned by
+6. After validation succeeds, if call_agent is available and authorized, send one representative
+   message before reporting the draft ready. Otherwise, report the successfully validated draft
+   ready without a test run.
+7. Report that the draft is ready, include a clickable link using the \`url\` returned by
    validate_agent, and ask whether the user wants to publish it.
-7. Call publish_agent only when the user explicitly requested publication, activation, deployment,
+8. Call publish_agent only when the user explicitly requested publication, activation, deployment,
    or making the Agent live, or confirms publication after the build.
-8. Use update_agent_integration to configure chat integrations. Configuration never publishes the
+9. Use update_agent_integration to configure chat integrations. Configuration never publishes the
    Agent. A configured channel stays inactive until explicit publication unless the Agent already has an active version.
 
+## Draft test runs
+
+call_agent verifies the draft Agent's behavior through built-in Preview chat, not configured channel
+triggers, platform context, message delivery, or replies. Real tools and credentials are used, so
+side effects are possible. If the test exposes errors, report them and ask whether to fix them rather
+than mutating the Agent automatically. Every approval decision must come from the human; resume each
+returned approval individually.
+
 ## Publication approval
 
 Building, editing, validating, or configuring an Agent never implies permission to publish or

package/dist/modules/mcp/tools/agents/agent-reference.js.map

@@ -1 +1 @@
-{"version":3,"file":"agent-reference.js","sourceRoot":"","sources":["../../../../../src/modules/mcp/tools/agents/agent-reference.ts"],"names":[],"mappings":";;;AAAA,8CAA2D;AAC3D,2DAAqD;AAExC,QAAA,2BAA2B,GAAG,wBAAwB,CAAC;AAIpE,MAAM,6BAA6B,GAAG,qCAAyB,CAAC,IAAI,CAAC,EAAE,YAAY,EAAE,IAAI,EAAE,CAAC,CAAC;AAEhF,QAAA,wBAAwB,GAAG,IAAA,oCAAe,EAAC,6BAA6B,EAAE;IACtF,IAAI,EAAE,iBAAiB;CACvB,CAAC,CAAC;AAEU,QAAA,mBAAmB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqJlC,CAAC;AAEW,QAAA,uBAAuB,GAAG,GAAG,QAAA,mBAAmB;;;;;EAK3D,IAAI,CAAC,SAAS,CAAC,QAAA,wBAAwB,EAAE,IAAI,EAAE,CAAC,CAAC;;CAElD,CAAC"}
+{"version":3,"file":"agent-reference.js","sourceRoot":"","sources":["../../../../../src/modules/mcp/tools/agents/agent-reference.ts"],"names":[],"mappings":";;;AAAA,8CAA2D;AAC3D,2DAAqD;AAExC,QAAA,2BAA2B,GAAG,wBAAwB,CAAC;AAIpE,MAAM,6BAA6B,GAAG,qCAAyB,CAAC,IAAI,CAAC,EAAE,YAAY,EAAE,IAAI,EAAE,CAAC,CAAC;AAEhF,QAAA,wBAAwB,GAAG,IAAA,oCAAe,EAAC,6BAA6B,EAAE;IACtF,IAAI,EAAE,iBAAiB;CACvB,CAAC,CAAC;AAEU,QAAA,mBAAmB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgKlC,CAAC;AAEW,QAAA,uBAAuB,GAAG,GAAG,QAAA,mBAAmB;;;;;EAK3D,IAAI,CAAC,SAAS,CAAC,QAAA,wBAAwB,EAAE,IAAI,EAAE,CAAC,CAAC;;CAElD,CAAC"}

package/dist/modules/mcp/tools/agents/agent-tools.service.d.ts

@@ -1,20 +1,19 @@
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { OutboundHttp, SsrfProtectionService } from '@n8n/backend-network';
 import { SsrfProtectionConfig } from '@n8n/config';
 import type { User } from '@n8n/db';
 import { CredentialsService } from '../../../../credentials/credentials.service';
 import { AgentConfigService } from '../../../../modules/agents/agent-config.service';
 import { AgentCustomToolsService } from '../../../../modules/agents/agent-custom-tools.service';
+import { AgentIntegrationManagementService } from '../../../../modules/agents/agent-integration-management.service';
 import { AgentIntegrationPersistenceService } from '../../../../modules/agents/agent-integration-persistence.service';
 import { AgentModelCatalogService } from '../../../../modules/agents/agent-model-catalog.service';
 import { AgentPublishService } from '../../../../modules/agents/agent-publish.service';
 import { AgentSkillsService } from '../../../../modules/agents/agent-skills.service';
 import { AgentTaskService } from '../../../../modules/agents/agent-task.service';
+import { AgentTestRunService } from '../../../../modules/agents/agent-test-run.service';
 import { AgentValidationService } from '../../../../modules/agents/agent-validation.service';
 import { AgentsService } from '../../../../modules/agents/agents.service';
 import { AttachableWorkflowsService } from '../../../../modules/agents/attachable-workflows.service';
-import { ChatIntegrationRegistry } from '../../../../modules/agents/integrations/agent-chat-integration';
-import { ChatIntegrationService } from '../../../../modules/agents/integrations/chat-integration.service';
 import { AgentSecureRuntime } from '../../../../modules/agents/runtime/agent-secure-runtime';
 import { McpRegistryService } from '../../../../modules/mcp-registry/registry/mcp-registry.service';
 import { NodeTypes } from '../../../../node-types';
@@ -22,6 +21,7 @@ import { OauthService } from '../../../../oauth/oauth.service';
 import { ProjectScopeService } from '../../../../permissions.ee/project-scope.service';
 import { UrlService } from '../../../../services/url.service';
 import { Telemetry } from '../../../../telemetry';
+import type { RegisterResourceFn, RegisterToolFn } from '../../mcp.types';
 export declare class McpAgentToolsService {
     private readonly telemetry;
     private readonly credentialsService;
@@ -31,11 +31,11 @@ export declare class McpAgentToolsService {
     private readonly agentPublishService;
     private readonly agentSkillsService;
     private readonly agentTaskService;
+    private readonly agentTestRunService;
     private readonly agentCustomToolsService;
     private readonly agentSecureRuntime;
     private readonly integrationPersistenceService;
-    private readonly chatIntegrationService;
-    private readonly chatIntegrationRegistry;
+    private readonly integrationManagementService;
     private readonly agentModelCatalogService;
     private readonly attachableWorkflowsService;
     private readonly mcpRegistryService;
@@ -46,14 +46,14 @@ export declare class McpAgentToolsService {
     private readonly ssrfProtectionService;
     private readonly urlService;
     private readonly projectScopeService;
-    constructor(telemetry: Telemetry, credentialsService: CredentialsService, agentsService: AgentsService, agentConfigService: AgentConfigService, agentValidationService: AgentValidationService, agentPublishService: AgentPublishService, agentSkillsService: AgentSkillsService, agentTaskService: AgentTaskService, agentCustomToolsService: AgentCustomToolsService, agentSecureRuntime: AgentSecureRuntime, integrationPersistenceService: AgentIntegrationPersistenceService, chatIntegrationService: ChatIntegrationService, chatIntegrationRegistry: ChatIntegrationRegistry, agentModelCatalogService: AgentModelCatalogService, attachableWorkflowsService: AttachableWorkflowsService, mcpRegistryService: McpRegistryService, nodeTypes: NodeTypes, oauthService: OauthService, outboundHttp: OutboundHttp, ssrfConfig: SsrfProtectionConfig, ssrfProtectionService: SsrfProtectionService, urlService: UrlService, projectScopeService: ProjectScopeService);
-    registerTools(server: McpServer, user: User, allowedToolNames?: Set<string>): void;
-    private register;
+    constructor(telemetry: Telemetry, credentialsService: CredentialsService, agentsService: AgentsService, agentConfigService: AgentConfigService, agentValidationService: AgentValidationService, agentPublishService: AgentPublishService, agentSkillsService: AgentSkillsService, agentTaskService: AgentTaskService, agentTestRunService: AgentTestRunService, agentCustomToolsService: AgentCustomToolsService, agentSecureRuntime: AgentSecureRuntime, integrationPersistenceService: AgentIntegrationPersistenceService, integrationManagementService: AgentIntegrationManagementService, agentModelCatalogService: AgentModelCatalogService, attachableWorkflowsService: AttachableWorkflowsService, mcpRegistryService: McpRegistryService, nodeTypes: NodeTypes, oauthService: OauthService, outboundHttp: OutboundHttp, ssrfConfig: SsrfProtectionConfig, ssrfProtectionService: SsrfProtectionService, urlService: UrlService, projectScopeService: ProjectScopeService);
+    registerTools(registerTool: RegisterToolFn, registerResource: RegisterResourceFn, user: User, allowedToolNames?: Set<string>): void;
     private searchAgentsTool;
     private getAgentTool;
     private createAgentTool;
     private mutateAgentTool;
     private validateAgentTool;
+    private callAgentTool;
     private publishAgentTool;
     private revertAgentTool;
     private listAgentVersionsTool;
@@ -68,6 +68,7 @@ export declare class McpAgentToolsService {
     private fetchConfigHash;
     private configFromEntity;
     private getAgentUrl;
+    private callAgent;
     private applyMutation;
     private assertSanitizeStable;
     private assertPassesConfigGuards;

package/dist/modules/mcp/tools/agents/agent-tools.service.js

@@ -23,16 +23,16 @@ const credentials_service_1 = require("../../../../credentials/credentials.servi
 const forbidden_error_1 = require("../../../../errors/response-errors/forbidden.error");
 const agent_config_service_1 = require("../../../../modules/agents/agent-config.service");
 const agent_custom_tools_service_1 = require("../../../../modules/agents/agent-custom-tools.service");
+const agent_integration_management_service_1 = require("../../../../modules/agents/agent-integration-management.service");
 const agent_integration_persistence_service_1 = require("../../../../modules/agents/agent-integration-persistence.service");
 const agent_model_catalog_service_1 = require("../../../../modules/agents/agent-model-catalog.service");
 const agent_publish_service_1 = require("../../../../modules/agents/agent-publish.service");
 const agent_skills_service_1 = require("../../../../modules/agents/agent-skills.service");
 const agent_task_service_1 = require("../../../../modules/agents/agent-task.service");
+const agent_test_run_service_1 = require("../../../../modules/agents/agent-test-run.service");
 const agent_validation_service_1 = require("../../../../modules/agents/agent-validation.service");
 const agents_service_1 = require("../../../../modules/agents/agents.service");
 const attachable_workflows_service_1 = require("../../../../modules/agents/attachable-workflows.service");
-const agent_chat_integration_1 = require("../../../../modules/agents/integrations/agent-chat-integration");
-const chat_integration_service_1 = require("../../../../modules/agents/integrations/chat-integration.service");
 const agent_config_composition_1 = require("../../../../modules/agents/json-config/agent-config-composition");
 const mcp_client_factory_1 = require("../../../../modules/agents/json-config/mcp-client-factory");
 const sanitize_unknown_agent_credentials_1 = require("../../../../modules/agents/json-config/sanitize-unknown-agent-credentials");
@@ -246,6 +246,26 @@ const updateIntegrationInput = {
         .optional()
         .describe('Integration settings; required for Telegram connect operations'),
 };
+const callAgentRequestSchema = zod_1.z.discriminatedUnion('type', [
+    zod_1.z
+        .object({
+        type: zod_1.z.literal('message'),
+        message: zod_1.z.string().trim().min(1),
+        sessionId: zod_1.z.string().trim().min(1).optional(),
+    })
+        .strict(),
+    zod_1.z
+        .object({
+        type: zod_1.z.literal('approval'),
+        approved: zod_1.z.boolean(),
+        continuation: agent_test_run_service_1.agentTestRunContinuationSchema,
+    })
+        .strict(),
+]);
+const callAgentInput = {
+    ...agentIdentityShape,
+    request: callAgentRequestSchema,
+};
 const emptyInput = {};
 function toolResult(data, isError = false) {
     return {
@@ -255,7 +275,7 @@ function toolResult(data, isError = false) {
     };
 }
 let McpAgentToolsService = class McpAgentToolsService {
-    constructor(telemetry, credentialsService, agentsService, agentConfigService, agentValidationService, agentPublishService, agentSkillsService, agentTaskService, agentCustomToolsService, agentSecureRuntime, integrationPersistenceService, chatIntegrationService, chatIntegrationRegistry, agentModelCatalogService, attachableWorkflowsService, mcpRegistryService, nodeTypes, oauthService, outboundHttp, ssrfConfig, ssrfProtectionService, urlService, projectScopeService) {
+    constructor(telemetry, credentialsService, agentsService, agentConfigService, agentValidationService, agentPublishService, agentSkillsService, agentTaskService, agentTestRunService, agentCustomToolsService, agentSecureRuntime, integrationPersistenceService, integrationManagementService, agentModelCatalogService, attachableWorkflowsService, mcpRegistryService, nodeTypes, oauthService, outboundHttp, ssrfConfig, ssrfProtectionService, urlService, projectScopeService) {
         this.telemetry = telemetry;
         this.credentialsService = credentialsService;
         this.agentsService = agentsService;
@@ -264,11 +284,11 @@ let McpAgentToolsService = class McpAgentToolsService {
         this.agentPublishService = agentPublishService;
         this.agentSkillsService = agentSkillsService;
         this.agentTaskService = agentTaskService;
+        this.agentTestRunService = agentTestRunService;
         this.agentCustomToolsService = agentCustomToolsService;
         this.agentSecureRuntime = agentSecureRuntime;
         this.integrationPersistenceService = integrationPersistenceService;
-        this.chatIntegrationService = chatIntegrationService;
-        this.chatIntegrationRegistry = chatIntegrationRegistry;
+        this.integrationManagementService = integrationManagementService;
         this.agentModelCatalogService = agentModelCatalogService;
         this.attachableWorkflowsService = attachableWorkflowsService;
         this.mcpRegistryService = mcpRegistryService;
@@ -280,17 +300,19 @@ let McpAgentToolsService = class McpAgentToolsService {
         this.urlService = urlService;
         this.projectScopeService = projectScopeService;
     }
-    registerTools(server, user, allowedToolNames) {
+    registerTools(registerTool, registerResource, user, allowedToolNames) {
+        const isCallAgentAvailable = allowedToolNames?.has(mcp_constants_1.MCP_CALL_AGENT_TOOL_NAME) ?? true;
         const registerIfAllowed = (tool) => {
             if (allowedToolNames && !allowedToolNames.has(tool.name))
                 return;
-            this.register(server, tool);
+            registerTool(tool);
         };
         registerIfAllowed(this.searchAgentsTool(user));
         registerIfAllowed(this.getAgentTool(user));
         registerIfAllowed(this.createAgentTool(user));
         registerIfAllowed(this.mutateAgentTool(user));
-        registerIfAllowed(this.validateAgentTool(user));
+        registerIfAllowed(this.validateAgentTool(user, isCallAgentAvailable));
+        registerIfAllowed(this.callAgentTool(user));
         registerIfAllowed(this.publishAgentTool(user));
         registerIfAllowed(this.unpublishAgentTool(user));
         registerIfAllowed(this.revertAgentTool(user));
@@ -302,18 +324,20 @@ let McpAgentToolsService = class McpAgentToolsService {
         registerIfAllowed(this.referenceTool(user));
         if (allowedToolNames && !allowedToolNames.has('get_agent_builder_reference'))
             return;
-        server.resource('agent-builder-reference', agent_reference_1.AGENT_BUILDER_REFERENCE_URI, { description: 'Reference for creating and managing n8n Agents through MCP.' }, () => ({
-            contents: [
-                {
-                    uri: agent_reference_1.AGENT_BUILDER_REFERENCE_URI,
-                    mimeType: 'text/markdown',
-                    text: agent_reference_1.AGENT_BUILDER_REFERENCE,
-                },
-            ],
-        }));
-    }
-    register(server, tool) {
-        server.registerTool(tool.name, tool.config, tool.handler);
+        registerResource({
+            name: 'agent-builder-reference',
+            uri: agent_reference_1.AGENT_BUILDER_REFERENCE_URI,
+            config: { description: 'Reference for creating and managing n8n Agents through MCP.' },
+            read: () => ({
+                contents: [
+                    {
+                        uri: agent_reference_1.AGENT_BUILDER_REFERENCE_URI,
+                        mimeType: 'text/markdown',
+                        text: agent_reference_1.AGENT_BUILDER_REFERENCE,
+                    },
+                ],
+            }),
+        });
     }
     searchAgentsTool(user) {
         return {
@@ -481,7 +505,7 @@ let McpAgentToolsService = class McpAgentToolsService {
             }),
         };
     }
-    validateAgentTool(user) {
+    validateAgentTool(user, isCallAgentAvailable) {
         return {
             name: 'validate_agent',
             config: {
@@ -498,14 +522,50 @@ let McpAgentToolsService = class McpAgentToolsService {
             handler: async ({ agentId }) => await this.run(user, 'validate_agent', { agentId }, async () => {
                 const agent = await this.resolveAgent(user, agentId);
                 await this.assertScope(user, agent.projectId, 'agent:read');
+                const validation = await this.validateAgent(user, agent);
+                const shouldSuggestCallAgent = validation.valid &&
+                    isCallAgentAvailable &&
+                    (await (0, check_access_1.userHasScopes)(user, ['agent:execute'], false, { projectId: agent.projectId }));
                 return {
                     ok: true,
-                    ...(await this.validateAgent(user, agent)),
+                    ...validation,
                     url: this.getAgentUrl(agent.projectId, agentId),
+                    ...(shouldSuggestCallAgent
+                        ? {
+                            nextStep: {
+                                tool: mcp_constants_1.MCP_CALL_AGENT_TOOL_NAME,
+                                reason: 'Test the runnable draft before reporting it ready',
+                            },
+                        }
+                        : {}),
                 };
             }),
         };
     }
+    callAgentTool(user) {
+        return {
+            name: mcp_constants_1.MCP_CALL_AGENT_TOOL_NAME,
+            config: {
+                description: 'Test an Agent draft through built-in Preview chat. Start or continue a conversation with a message request, or resume one returned approval after the human decides. This uses real tools and credentials, so external side effects are possible.',
+                inputSchema: callAgentInput,
+                annotations: {
+                    title: 'Call Agent',
+                    readOnlyHint: false,
+                    destructiveHint: true,
+                    idempotentHint: false,
+                    openWorldHint: true,
+                },
+            },
+            handler: async (input, extra) => {
+                const abortSignal = (0, is_record_1.isRecord)(extra) && extra.signal instanceof AbortSignal ? extra.signal : undefined;
+                return await this.run(user, mcp_constants_1.MCP_CALL_AGENT_TOOL_NAME, { agentId: input.agentId }, async () => {
+                    const agent = await this.resolveAgent(user, input.agentId);
+                    await this.assertScope(user, agent.projectId, 'agent:execute');
+                    return await this.callAgent(user, agent, input.request, abortSignal);
+                });
+            },
+        };
+    }
     publishAgentTool(user) {
         return {
             name: 'publish_agent',
@@ -813,6 +873,118 @@ let McpAgentToolsService = class McpAgentToolsService {
     getAgentUrl(projectId, agentId) {
         return `${this.urlService.getInstanceBaseUrl()}/projects/${encodeURIComponent(projectId)}/agents/${encodeURIComponent(agentId)}`;
     }
+    async callAgent(user, agent, request, abortSignal) {
+        const { id: agentId, projectId } = agent;
+        const previewUrl = `${this.getAgentUrl(projectId, agentId)}/preview`;
+        try {
+            let result;
+            if (request.type === 'message') {
+                result = await this.agentTestRunService.executeDraftRun({
+                    agentId,
+                    projectId,
+                    message: request.message,
+                    sessionId: request.sessionId,
+                    credentialProvider: this.credentialProvider(user, projectId),
+                    user,
+                    source: 'mcp',
+                    abortSignal,
+                });
+            }
+            else {
+                result = await this.agentTestRunService.resumeDraftApproval({
+                    agentId,
+                    projectId,
+                    continuation: request.continuation,
+                    approved: request.approved,
+                    user,
+                    source: 'mcp',
+                    abortSignal,
+                });
+            }
+            if (result.status === 'session_not_found') {
+                return {
+                    ok: false,
+                    status: 'error',
+                    code: 'session_not_found',
+                    message: 'Session not found.',
+                };
+            }
+            if (result.status === 'agent_misconfigured') {
+                return {
+                    ok: false,
+                    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 { ok: true, ...result };
+            const approvals = (0, agent_test_run_service_1.collectStandardApprovals)(result);
+            if (approvals) {
+                return {
+                    ok: true,
+                    status: 'suspended',
+                    response: result.response,
+                    sessionId: result.sessionId,
+                    ...(result.executionId ? { executionId: result.executionId } : {}),
+                    approvals,
+                };
+            }
+            const canOpenPreview = await (0, check_access_1.userHasScopes)(user, ['project:read', 'agent:read'], false, {
+                projectId,
+            });
+            const previewAccessNote = canOpenPreview
+                ? undefined
+                : 'Your access permits running this agent but not opening Preview. Share the Preview URL with a project member who has project and agent read access.';
+            const cancelled = await this.agentTestRunService.cancelSuspendedRuns({
+                agentId,
+                suspensions: result.suspensions,
+                userId: user.id,
+            });
+            if (!cancelled) {
+                return {
+                    ok: false,
+                    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,
+                    previewUrl,
+                    ...(previewAccessNote ? { previewAccessNote } : {}),
+                };
+            }
+            return {
+                ok: true,
+                status: 'approval_required',
+                response: result.response,
+                sessionId: result.sessionId,
+                ...(result.executionId ? { executionId: result.executionId } : {}),
+                suspensions: result.suspensions.map(({ runId, toolCallId, toolName }) => ({
+                    runId,
+                    toolCallId,
+                    toolName,
+                })),
+                previewUrl,
+                ...(previewAccessNote ? { previewAccessNote } : {}),
+            };
+        }
+        catch (error) {
+            if (error instanceof agent_test_run_service_1.InvalidAgentTestRunCheckpointError) {
+                return {
+                    ok: false,
+                    status: 'error',
+                    code: error.code,
+                    message: error.message,
+                };
+            }
+            return {
+                ok: false,
+                status: 'error',
+                code: 'execution_failed',
+                message: error instanceof Error ? error.message : 'Agent test run failed.',
+            };
+        }
+    }
     async applyMutation(user, input, config, projectId) {
         const { agentId, operation } = input;
         const telemetryContext = { user, modifiedBy: 'mcp' };
@@ -1041,25 +1213,16 @@ let McpAgentToolsService = class McpAgentToolsService {
         await this.assertScope(user, projectId, 'agent:update');
         return input.action === 'disconnect'
             ? await this.disconnectIntegration(user, input, agent)
-            : await this.connectIntegration(user, input, agent, projectId);
+            : await this.connectIntegration(user, input, agent);
     }
     async disconnectIntegration(user, input, agent) {
-        const persisted = (agent.integrations ?? []).find((item) => item.type === input.type && item.credentialId === input.credentialId);
-        const parsed = api_types_1.AgentIntegrationSchema.safeParse({
+        const { savedAgent: saved } = await this.integrationManagementService.disconnect({
+            agent,
+            user,
             type: input.type,
             credentialId: input.credentialId,
+            modifiedBy: 'mcp',
         });
-        const integration = persisted ?? (parsed.success ? parsed.data : undefined);
-        if (integration) {
-            await this.chatIntegrationService.disconnectChannel(input.agentId, integration);
-        }
-        else {
-            await this.chatIntegrationService.disconnect(input.agentId, {
-                type: input.type,
-                credentialId: input.credentialId,
-            });
-        }
-        const saved = await this.integrationPersistenceService.removeCredentialIntegration(agent, input.type, input.credentialId, { user, modifiedBy: 'mcp', broadcast: false });
         return {
             ok: true,
             agentId: input.agentId,
@@ -1070,24 +1233,18 @@ let McpAgentToolsService = class McpAgentToolsService {
             configHash: (0, agent_config_hash_1.getAgentConfigHash)(this.configFromEntity(saved)),
         };
     }
-    async connectIntegration(user, input, agent, projectId) {
+    async connectIntegration(user, input, agent) {
         const candidate = {
             type: input.type,
             credentialId: input.credentialId,
             ...(input.settings ? { settings: input.settings } : {}),
         };
-        const parsed = api_types_1.AgentIntegrationSchema.safeParse(candidate);
-        if (!parsed.success)
-            throw new n8n_workflow_1.UserError(`Invalid integration: ${parsed.error.message}`);
-        if (parsed.data.type === 'telegram' && !parsed.data.settings) {
-            throw new n8n_workflow_1.UserError('Telegram integration settings are required');
-        }
-        const credential = await this.requireAccessibleCredential(this.credentialProvider(user, projectId), input.credentialId);
-        const implementation = this.chatIntegrationRegistry.require(parsed.data.type);
-        if (!implementation.credentialTypes.includes(credential.type)) {
-            throw new n8n_workflow_1.UserError(`${implementation.displayLabel} integrations do not support ${credential.type} credentials`);
-        }
-        const saved = await this.integrationPersistenceService.saveCredentialIntegration(agent, parsed.data, { user, modifiedBy: 'mcp', broadcast: false });
+        const { savedAgent: saved } = await this.integrationManagementService.connect({
+            agent,
+            user,
+            integration: candidate,
+            modifiedBy: 'mcp',
+        });
         const result = {
             ok: true,
             agentId: input.agentId,
@@ -1099,8 +1256,6 @@ let McpAgentToolsService = class McpAgentToolsService {
         };
         if (saved.activeVersionId === null)
             return { ...result, connected: false };
-        await this.chatIntegrationService.connect(input.agentId, parsed.data, projectId);
-        await this.chatIntegrationService.broadcastIntegrationChange(input.agentId, parsed.data, 'connect');
         return {
             ...result,
             connected: true,
@@ -1152,6 +1307,6 @@ let McpAgentToolsService = class McpAgentToolsService {
 exports.McpAgentToolsService = McpAgentToolsService;
 exports.McpAgentToolsService = McpAgentToolsService = __decorate([
     (0, di_1.Service)(),
-    __metadata("design:paramtypes", [telemetry_1.Telemetry, credentials_service_1.CredentialsService, agents_service_1.AgentsService, agent_config_service_1.AgentConfigService, agent_validation_service_1.AgentValidationService, agent_publish_service_1.AgentPublishService, agent_skills_service_1.AgentSkillsService, agent_task_service_1.AgentTaskService, agent_custom_tools_service_1.AgentCustomToolsService, agent_secure_runtime_1.AgentSecureRuntime, agent_integration_persistence_service_1.AgentIntegrationPersistenceService, chat_integration_service_1.ChatIntegrationService, agent_chat_integration_1.ChatIntegrationRegistry, agent_model_catalog_service_1.AgentModelCatalogService, attachable_workflows_service_1.AttachableWorkflowsService, mcp_registry_service_1.McpRegistryService, node_types_1.NodeTypes, oauth_service_1.OauthService, backend_network_1.OutboundHttp, config_1.SsrfProtectionConfig, backend_network_1.SsrfProtectionService, url_service_1.UrlService, project_scope_service_1.ProjectScopeService])
+    __metadata("design:paramtypes", [telemetry_1.Telemetry, credentials_service_1.CredentialsService, agents_service_1.AgentsService, agent_config_service_1.AgentConfigService, agent_validation_service_1.AgentValidationService, agent_publish_service_1.AgentPublishService, agent_skills_service_1.AgentSkillsService, agent_task_service_1.AgentTaskService, agent_test_run_service_1.AgentTestRunService, agent_custom_tools_service_1.AgentCustomToolsService, agent_secure_runtime_1.AgentSecureRuntime, agent_integration_persistence_service_1.AgentIntegrationPersistenceService, agent_integration_management_service_1.AgentIntegrationManagementService, agent_model_catalog_service_1.AgentModelCatalogService, attachable_workflows_service_1.AttachableWorkflowsService, mcp_registry_service_1.McpRegistryService, node_types_1.NodeTypes, oauth_service_1.OauthService, backend_network_1.OutboundHttp, config_1.SsrfProtectionConfig, backend_network_1.SsrfProtectionService, url_service_1.UrlService, project_scope_service_1.ProjectScopeService])
 ], McpAgentToolsService);
 //# sourceMappingURL=agent-tools.service.js.map