n8n 2.34.3 → 2.35.0

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