@rekog/mcp-nest 1.9.4 → 1.9.6

package/src/mcp/services/mcp-dynamic-registry.service.ts

@@ -0,0 +1,236 @@
+import { Injectable, Inject, Logger } from '@nestjs/common';
+import { z } from 'zod';
+import {
+  DynamicToolDefinition,
+  DynamicToolHandler,
+} from '../interfaces/dynamic-tool.interface';
+import {
+  DynamicResourceDefinition,
+  DynamicResourceHandler,
+} from '../interfaces/dynamic-resource.interface';
+import {
+  DynamicPromptDefinition,
+  DynamicPromptHandler,
+} from '../interfaces/dynamic-prompt.interface';
+import { McpRegistryDiscoveryService } from './mcp-registry-discovery.service';
+import type { McpOptions } from '../interfaces';
+import { createMcpLogger } from '../utils/mcp-logger.factory';
+import { ToolMetadata } from '../decorators/tool.decorator';
+import { ResourceMetadata } from '../decorators/resource.decorator';
+import { PromptMetadata } from '../decorators/prompt.decorator';
+
+/**
+ * Symbol used to identify dynamic tools in the registry.
+ * When a tool's providerClass equals this token, it's a dynamic tool.
+ */
+export const DYNAMIC_TOOL_HANDLER_TOKEN = Symbol('DYNAMIC_TOOL_HANDLER');
+export const DYNAMIC_RESOURCE_HANDLER_TOKEN = Symbol(
+  'DYNAMIC_RESOURCE_HANDLER',
+);
+export const DYNAMIC_PROMPT_HANDLER_TOKEN = Symbol('DYNAMIC_PROMPT_HANDLER');
+
+/**
+ * Global maps of dynamic capability handlers, scoped by moduleId.
+ * Using module-level Maps ensures handlers persist across different
+ * McpRegistryService instances that may be created by the DI container.
+ */
+const globalHandlers = new Map<string, Map<string, DynamicToolHandler>>();
+const globalResourceHandlers = new Map<
+  string,
+  Map<string, DynamicResourceHandler>
+>();
+const globalPromptHandlers = new Map<
+  string,
+  Map<string, DynamicPromptHandler>
+>();
+
+/**
+ * Service for programmatically registering MCP tools at runtime.
+ *
+ * Use this to register tools with descriptions/parameters from databases
+ * or other dynamic sources during application bootstrap.
+ *
+ * @example
+ * ```typescript
+ * @Injectable()
+ * export class DynamicToolsService implements OnModuleInit {
+ *   constructor(
+ *     private readonly capabilityBuilder: McpRegistryService,
+ *     private readonly dbService: DatabaseService,
+ *   ) {}
+ *
+ *   async onModuleInit() {
+ *     const collections = await this.dbService.getCollections();
+ *
+ *     this.capabilityBuilder.registerTool({
+ *       name: 'search-knowledge',
+ *       description: `Search collections: ${collections.join(', ')}`,
+ *       parameters: z.object({ query: z.string() }),
+ *       handler: async (args, context) => {
+ *         const results = await this.dbService.search(args.query);
+ *         return { content: [{ type: 'text', text: JSON.stringify(results) }] };
+ *       },
+ *     });
+ *   }
+ * }
+ * ```
+ */
+@Injectable()
+export class McpRegistryService {
+  private readonly logger: Logger;
+
+  constructor(
+    private readonly registry: McpRegistryDiscoveryService,
+    @Inject('MCP_MODULE_ID') private readonly mcpModuleId: string,
+    @Inject('MCP_OPTIONS') private readonly options: McpOptions,
+  ) {
+    this.logger = createMcpLogger(McpRegistryService.name, this.options);
+    [globalHandlers, globalResourceHandlers, globalPromptHandlers].forEach(
+      (store) => {
+        if (!store.has(mcpModuleId)) {
+          store.set(mcpModuleId, new Map());
+        }
+      },
+    );
+  }
+
+  /**
+   * Register a dynamic tool for the current MCP server.
+   *
+   * Tools registered here will appear in the `tools/list` response and
+   * can be called via `tools/call` just like decorator-based tools.
+   *
+   * @param definition - The tool definition including name, description, parameters, and handler
+   *
+   * @example
+   * ```typescript
+   * registry.registerTool({
+   *   name: 'search-knowledge',
+   *   description: await getDescriptionFromDB(),
+   *   parameters: z.object({ query: z.string() }),
+   *   handler: async (args, context) => {
+   *     const results = await searchService.search(args.query);
+   *     return { content: [{ type: 'text', text: JSON.stringify(results) }] };
+   *   },
+   * });
+   * ```
+   */
+  registerTool(definition: DynamicToolDefinition): void {
+    this.logger.debug(`Registering dynamic tool: ${definition.name}`);
+
+    // Store the handler for later execution (scoped by moduleId)
+    const moduleHandlers = globalHandlers.get(this.mcpModuleId)!;
+    moduleHandlers.set(definition.name, definition.handler);
+
+    // Default to empty object schema if no parameters provided (matches @Tool decorator behavior)
+    const parameters = definition.parameters ?? z.object({});
+
+    // Build metadata matching ToolMetadata interface
+    const metadata: ToolMetadata = {
+      name: definition.name,
+      description: definition.description,
+      parameters,
+      outputSchema: definition.outputSchema,
+      annotations: definition.annotations,
+      _meta: definition._meta,
+      isPublic: definition.isPublic,
+      requiredScopes: definition.requiredScopes,
+      requiredRoles: definition.requiredRoles,
+    };
+
+    // Register with the registry
+    this.registry.registerDynamicCapability(this.mcpModuleId, {
+      type: 'tool',
+      metadata,
+      providerClass: DYNAMIC_TOOL_HANDLER_TOKEN,
+      methodName: definition.name,
+    });
+  }
+
+  getHandler(toolName: string): DynamicToolHandler | undefined {
+    return globalHandlers.get(this.mcpModuleId)?.get(toolName);
+  }
+
+  static getHandlerByModuleId(
+    mcpModuleId: string,
+    toolName: string,
+  ): DynamicToolHandler | undefined {
+    return globalHandlers.get(mcpModuleId)?.get(toolName);
+  }
+
+  registerResource(definition: DynamicResourceDefinition): void {
+    this.logger.debug(`Registering dynamic resource: ${definition.uri}`);
+
+    globalResourceHandlers
+      .get(this.mcpModuleId)!
+      .set(definition.uri, definition.handler);
+
+    const metadata: ResourceMetadata = {
+      uri: definition.uri,
+      name: definition.name ?? definition.uri,
+      description: definition.description,
+      mimeType: definition.mimeType,
+      _meta: definition._meta,
+    };
+
+    this.registry.registerDynamicCapability(this.mcpModuleId, {
+      type: 'resource',
+      metadata,
+      providerClass: DYNAMIC_RESOURCE_HANDLER_TOKEN,
+      methodName: definition.uri,
+    });
+  }
+
+  static getResourceHandlerByModuleId(
+    mcpModuleId: string,
+    uri: string,
+  ): DynamicResourceHandler | undefined {
+    return globalResourceHandlers.get(mcpModuleId)?.get(uri);
+  }
+
+  registerPrompt(definition: DynamicPromptDefinition): void {
+    this.logger.debug(`Registering dynamic prompt: ${definition.name}`);
+
+    globalPromptHandlers
+      .get(this.mcpModuleId)!
+      .set(definition.name, definition.handler);
+
+    const metadata: PromptMetadata = {
+      name: definition.name,
+      description: definition.description,
+      parameters: definition.parameters,
+    };
+
+    this.registry.registerDynamicCapability(this.mcpModuleId, {
+      type: 'prompt',
+      metadata,
+      providerClass: DYNAMIC_PROMPT_HANDLER_TOKEN,
+      methodName: definition.name,
+    });
+  }
+
+  static getPromptHandlerByModuleId(
+    mcpModuleId: string,
+    name: string,
+  ): DynamicPromptHandler | undefined {
+    return globalPromptHandlers.get(mcpModuleId)?.get(name);
+  }
+
+  removeTool(name: string): void {
+    this.logger.debug(`Removing dynamic tool: ${name}`);
+    globalHandlers.get(this.mcpModuleId)?.delete(name);
+    this.registry.removeDynamicCapability(this.mcpModuleId, 'tool', name);
+  }
+
+  removeResource(uri: string): void {
+    this.logger.debug(`Removing dynamic resource: ${uri}`);
+    globalResourceHandlers.get(this.mcpModuleId)?.delete(uri);
+    this.registry.removeDynamicCapability(this.mcpModuleId, 'resource', uri);
+  }
+
+  removePrompt(name: string): void {
+    this.logger.debug(`Removing dynamic prompt: ${name}`);
+    globalPromptHandlers.get(this.mcpModuleId)?.delete(name);
+    this.registry.removeDynamicCapability(this.mcpModuleId, 'prompt', name);
+  }
+}

package/src/mcp/services/mcp-executor.service.ts

@@ -1,7 +1,7 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { Inject, Injectable, Logger, Optional, Scope } from '@nestjs/common';
 import { ModuleRef, Reflector } from '@nestjs/core';
-import { McpRegistryService } from './mcp-registry.service';
+import { McpRegistryDiscoveryService } from './mcp-registry-discovery.service';
 import { McpToolsHandler } from './handlers/mcp-tools.handler';
 import { McpResourcesHandler } from './handlers/mcp-resources.handler';
 import { McpPromptsHandler } from './handlers/mcp-prompts.handler';
@@ -22,7 +22,7 @@ export class McpExecutorService {
 
   constructor(
     moduleRef: ModuleRef,
-    registry: McpRegistryService,
+    registry: McpRegistryDiscoveryService,
     @Inject('MCP_MODULE_ID') mcpModuleId: string,
     @Inject('MCP_OPTIONS') options: McpOptions,
     authService: ToolAuthorizationService,

package/src/mcp/services/{mcp-registry.service.spec.ts → mcp-registry-discovery.service.spec.ts}

@@ -5,13 +5,13 @@ import {
   ValueProvider,
 } from '@nestjs/common';
 import { Test, TestingModule } from '@nestjs/testing';
-import { McpRegistryService } from './mcp-registry.service';
+import { McpRegistryDiscoveryService } from './mcp-registry-discovery.service';
 import { DiscoveryService, MetadataScanner } from '@nestjs/core';
 import { Tool } from '../decorators/tool.decorator';
 import { McpModule } from '../mcp.module';
 
-describe('McpRegistryService', () => {
-  let service: McpRegistryService;
+describe('McpRegistryDiscoveryService', () => {
+  let service: McpRegistryDiscoveryService;
   const mockMcpModuleId = 'test-mcp-module-id';
 
   const mockResource = (name: string, uri: string) => ({
@@ -31,7 +31,7 @@ describe('McpRegistryService', () => {
   beforeEach(async () => {
     const module: TestingModule = await Test.createTestingModule({
       providers: [
-        McpRegistryService,
+        McpRegistryDiscoveryService,
         {
           provide: DiscoveryService,
           useValue: {
@@ -43,7 +43,9 @@ describe('McpRegistryService', () => {
       ],
     }).compile();
 
-    service = module.get<McpRegistryService>(McpRegistryService);
+    service = module.get<McpRegistryDiscoveryService>(
+      McpRegistryDiscoveryService,
+    );
 
     const mockResources = [
       mockResource('res0', '/posts/comments'),
@@ -57,7 +59,7 @@ describe('McpRegistryService', () => {
       mockResourceTemplate('resTemplate2', '/templates/{type}/{id}'),
     ];
 
-    (service as any).discoveredToolsByMcpModuleId = new Map([
+    (service as any).discoveredCapabilitiesByMcpModuleId = new Map([
       [mockMcpModuleId, [...mockResources, ...mockResourceTemplates]],
     ]);
   });
@@ -129,7 +131,7 @@ describe('McpRegistryService', () => {
  *               |                      |
  *             ToolsA                 ToolsB
  */
-describe('McpRegistryService - Multiple discovery roots', () => {
+describe('McpRegistryDiscoveryService - Multiple discovery roots', () => {
   const mcpModuleA = McpModule.forRoot({ name: 'server-a', version: '0.0.1' });
   const mcpModuleB = McpModule.forRoot({ name: 'server-b', version: '0.0.1' });
 
@@ -169,7 +171,7 @@ describe('McpRegistryService - Multiple discovery roots', () => {
   })
   class ModuleB {}
 
-  let service: McpRegistryService;
+  let service: McpRegistryDiscoveryService;
   const idModuleA = getMcpModuleId(mcpModuleA);
   const idModuleB = getMcpModuleId(mcpModuleB);
 
@@ -178,7 +180,9 @@ describe('McpRegistryService - Multiple discovery roots', () => {
       imports: [ModuleA, ModuleB],
     }).compile();
 
-    service = module.get<McpRegistryService>(McpRegistryService);
+    service = module.get<McpRegistryDiscoveryService>(
+      McpRegistryDiscoveryService,
+    );
     service.onApplicationBootstrap();
   });
 
@@ -215,7 +219,7 @@ describe('McpRegistryService - Multiple discovery roots', () => {
  *          |
  *       Tools (forFeature to both)
  */
-describe('McpRegistryService - Single discovery root with multiple MCP servers', () => {
+describe('McpRegistryDiscoveryService - Single discovery root with multiple MCP servers', () => {
   const mcpModuleA = McpModule.forRoot({ name: 'server-a', version: '0.0.1' });
   const mcpModuleB = McpModule.forRoot({ name: 'server-b', version: '0.0.1' });
 
@@ -248,14 +252,16 @@ describe('McpRegistryService - Single discovery root with multiple MCP servers',
   })
   class AppModule {}
 
-  let service: McpRegistryService;
+  let service: McpRegistryDiscoveryService;
 
   beforeAll(async () => {
     const module: TestingModule = await Test.createTestingModule({
       imports: [AppModule],
     }).compile();
 
-    service = module.get<McpRegistryService>(McpRegistryService);
+    service = module.get<McpRegistryDiscoveryService>(
+      McpRegistryDiscoveryService,
+    );
     service.onApplicationBootstrap();
   });
 

package/src/mcp/services/{mcp-registry.service.ts → mcp-registry-discovery.service.ts}

@@ -35,9 +35,9 @@ import {
 } from '../constants/feature-registration.constants';
 
 /**
- * Interface representing a discovered tool
+ * Interface representing a discovered capability
  */
-export type DiscoveredTool<T extends object> = {
+export type DiscoveredCapability<T extends object> = {
   type: 'tool' | 'resource' | 'resource-template' | 'prompt';
   metadata: T;
   providerClass: InjectionToken;
@@ -50,10 +50,12 @@ export type InjectionTokenWithName = InjectionToken & { name: string };
  * Singleton service that discovers and registers tools during application bootstrap
  */
 @Injectable()
-export class McpRegistryService implements OnApplicationBootstrap {
+export class McpRegistryDiscoveryService implements OnApplicationBootstrap {
   private readonly logger: Logger;
-  private discoveredToolsByMcpModuleId: Map<string, DiscoveredTool<any>[]> =
-    new Map();
+  private discoveredCapabilitiesByMcpModuleId: Map<
+    string,
+    DiscoveredCapability<any>[]
+  > = new Map();
 
   constructor(
     private readonly discovery: DiscoveryService,
@@ -61,7 +63,10 @@ export class McpRegistryService implements OnApplicationBootstrap {
     private readonly modulesContainer: ModulesContainer,
     @Optional() @Inject('MCP_OPTIONS') private readonly options?: McpOptions,
   ) {
-    this.logger = createMcpLogger(McpRegistryService.name, this.options);
+    this.logger = createMcpLogger(
+      McpRegistryDiscoveryService.name,
+      this.options,
+    );
   }
 
   onApplicationBootstrap() {
@@ -386,11 +391,11 @@ export class McpRegistryService implements OnApplicationBootstrap {
       metadata['name'] = methodName;
     }
 
-    if (!this.discoveredToolsByMcpModuleId.has(mcpModuleId)) {
-      this.discoveredToolsByMcpModuleId.set(mcpModuleId, []);
+    if (!this.discoveredCapabilitiesByMcpModuleId.has(mcpModuleId)) {
+      this.discoveredCapabilitiesByMcpModuleId.set(mcpModuleId, []);
     }
 
-    this.discoveredToolsByMcpModuleId.get(mcpModuleId)?.push({
+    this.discoveredCapabilitiesByMcpModuleId.get(mcpModuleId)?.push({
       type,
       metadata,
       providerClass: token,
@@ -463,11 +468,11 @@ export class McpRegistryService implements OnApplicationBootstrap {
       baseMetadata.guards = guards;
     }
 
-    if (!this.discoveredToolsByMcpModuleId.has(mcpModuleId)) {
-      this.discoveredToolsByMcpModuleId.set(mcpModuleId, []);
+    if (!this.discoveredCapabilitiesByMcpModuleId.has(mcpModuleId)) {
+      this.discoveredCapabilitiesByMcpModuleId.set(mcpModuleId, []);
     }
 
-    this.discoveredToolsByMcpModuleId.get(mcpModuleId)?.push({
+    this.discoveredCapabilitiesByMcpModuleId.get(mcpModuleId)?.push({
       type: 'tool',
       metadata: baseMetadata,
       providerClass: token,
@@ -517,15 +522,15 @@ export class McpRegistryService implements OnApplicationBootstrap {
    * Return all discovered MCP module IDs
    */
   getMcpModuleIds(): string[] {
-    return Array.from(this.discoveredToolsByMcpModuleId.keys());
+    return Array.from(this.discoveredCapabilitiesByMcpModuleId.keys());
   }
 
   /**
    * Get all discovered tools
    */
-  getTools(mcpModuleId: string): DiscoveredTool<ToolMetadata>[] {
+  getTools(mcpModuleId: string): DiscoveredCapability<ToolMetadata>[] {
     return (
-      this.discoveredToolsByMcpModuleId
+      this.discoveredCapabilitiesByMcpModuleId
         .get(mcpModuleId)
         ?.filter((tool) => tool.type === 'tool') ?? []
     );
@@ -537,7 +542,7 @@ export class McpRegistryService implements OnApplicationBootstrap {
   findTool(
     mcpModuleId: string,
     name: string,
-  ): DiscoveredTool<ToolMetadata> | undefined {
+  ): DiscoveredCapability<ToolMetadata> | undefined {
     return this.getTools(mcpModuleId).find(
       (tool) => tool.metadata.name === name,
     );
@@ -546,9 +551,9 @@ export class McpRegistryService implements OnApplicationBootstrap {
   /**
    * Get all discovered resources
    */
-  getResources(mcpModuleId: string): DiscoveredTool<ResourceMetadata>[] {
+  getResources(mcpModuleId: string): DiscoveredCapability<ResourceMetadata>[] {
     return (
-      this.discoveredToolsByMcpModuleId
+      this.discoveredCapabilitiesByMcpModuleId
         .get(mcpModuleId)
         ?.filter((tool) => tool.type === 'resource') ?? []
     );
@@ -560,7 +565,7 @@ export class McpRegistryService implements OnApplicationBootstrap {
   findResource(
     mcpModuleId: string,
     name: string,
-  ): DiscoveredTool<ResourceMetadata> | undefined {
+  ): DiscoveredCapability<ResourceMetadata> | undefined {
     return this.getResources(mcpModuleId).find(
       (tool) => tool.metadata.name === name,
     );
@@ -571,9 +576,9 @@ export class McpRegistryService implements OnApplicationBootstrap {
    */
   getResourceTemplates(
     mcpModuleId: string,
-  ): DiscoveredTool<ResourceTemplateMetadata>[] {
+  ): DiscoveredCapability<ResourceTemplateMetadata>[] {
     return (
-      this.discoveredToolsByMcpModuleId
+      this.discoveredCapabilitiesByMcpModuleId
         .get(mcpModuleId)
         ?.filter((tool) => tool.type === 'resource-template') ?? []
     );
@@ -585,7 +590,7 @@ export class McpRegistryService implements OnApplicationBootstrap {
   findResourceTemplate(
     mcpModuleId: string,
     name: string,
-  ): DiscoveredTool<ResourceTemplateMetadata> | undefined {
+  ): DiscoveredCapability<ResourceTemplateMetadata> | undefined {
     return this.getResourceTemplates(mcpModuleId).find(
       (tool) => tool.metadata.name === name,
     );
@@ -594,9 +599,9 @@ export class McpRegistryService implements OnApplicationBootstrap {
   /**
    * Get all discovered prompts
    */
-  getPrompts(mcpModuleId: string): DiscoveredTool<PromptMetadata>[] {
+  getPrompts(mcpModuleId: string): DiscoveredCapability<PromptMetadata>[] {
     return (
-      this.discoveredToolsByMcpModuleId
+      this.discoveredCapabilitiesByMcpModuleId
         .get(mcpModuleId)
         ?.filter((tool) => tool.type === 'prompt') ?? []
     );
@@ -608,7 +613,7 @@ export class McpRegistryService implements OnApplicationBootstrap {
   findPrompt(
     mcpModuleId: string,
     name: string,
-  ): DiscoveredTool<PromptMetadata> | undefined {
+  ): DiscoveredCapability<PromptMetadata> | undefined {
     return this.getPrompts(mcpModuleId).find(
       (tool) => tool.metadata.name === name,
     );
@@ -686,7 +691,7 @@ export class McpRegistryService implements OnApplicationBootstrap {
     uri: string,
   ):
     | {
-        resource: DiscoveredTool<ResourceMetadata>;
+        resource: DiscoveredCapability<ResourceMetadata>;
         params: Record<string, string>;
       }
     | undefined {
@@ -728,7 +733,7 @@ export class McpRegistryService implements OnApplicationBootstrap {
     uri: string,
   ):
     | {
-        resourceTemplate: DiscoveredTool<ResourceTemplateMetadata>;
+        resourceTemplate: DiscoveredCapability<ResourceTemplateMetadata>;
         params: Record<string, string>;
       }
     | undefined {
@@ -785,23 +790,60 @@ export class McpRegistryService implements OnApplicationBootstrap {
 
   /**
    * Register a tool programmatically (for dynamic tools).
-   * Use McpToolBuilder.registerTool() instead of calling this directly.
+   * Use McpRegistryService.registerTool() instead of calling this directly.
    *
    * @param mcpModuleId - The module ID to register the tool with
-   * @param tool - The discovered tool object to register
+   * @param capability - The discovered capability object to register
    */
-  registerDynamicTool(
+  registerDynamicCapability<T extends object>(
+    mcpModuleId: string,
+    capability: DiscoveredCapability<T>,
+  ): void {
+    if (!this.discoveredCapabilitiesByMcpModuleId.has(mcpModuleId)) {
+      this.discoveredCapabilitiesByMcpModuleId.set(mcpModuleId, []);
+    }
+
+    const capabilities =
+      this.discoveredCapabilitiesByMcpModuleId.get(mcpModuleId)!;
+
+    const existingIndex = capabilities.findIndex(
+      (c) =>
+        c.type === capability.type && c.methodName === capability.methodName,
+    );
+
+    if (existingIndex !== -1) {
+      this.logger.warn(
+        `Dynamic ${capability.type} '${capability.methodName}' already registered in module: ${mcpModuleId}. Overwriting.`,
+      );
+      capabilities[existingIndex] = capability;
+    } else {
+      this.logger.debug(
+        `Dynamic ${capability.type} registered: ${capability.metadata['name']} in module: ${mcpModuleId}`,
+      );
+      capabilities.push(capability);
+    }
+  }
+
+  removeDynamicCapability(
     mcpModuleId: string,
-    tool: DiscoveredTool<ToolMetadata>,
+    type: DiscoveredCapability<object>['type'],
+    identifier: string,
   ): void {
-    if (!this.discoveredToolsByMcpModuleId.has(mcpModuleId)) {
-      this.discoveredToolsByMcpModuleId.set(mcpModuleId, []);
+    const capabilities =
+      this.discoveredCapabilitiesByMcpModuleId.get(mcpModuleId);
+    if (!capabilities) {
+      return;
     }
 
     this.logger.debug(
-      `Dynamic tool registered: ${tool.metadata.name} in module: ${mcpModuleId}`,
+      `Dynamic ${type} removed: ${identifier} in module: ${mcpModuleId}`,
     );
 
-    this.discoveredToolsByMcpModuleId.get(mcpModuleId)?.push(tool);
+    this.discoveredCapabilitiesByMcpModuleId.set(
+      mcpModuleId,
+      capabilities.filter(
+        (c) => !(c.type === type && c.methodName === identifier),
+      ),
+    );
   }
 }

package/src/mcp/services/mcp-sse.service.ts

@@ -4,7 +4,7 @@ import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';
 import type { McpOptions } from '../interfaces';
 import { McpExecutorService } from './mcp-executor.service';
-import { McpRegistryService } from './mcp-registry.service';
+import { McpRegistryDiscoveryService } from './mcp-registry-discovery.service';
 import { SsePingService } from './sse-ping.service';
 import { normalizeEndpoint } from '../utils/normalize-endpoint';
 import { HttpAdapterFactory } from '../adapters';
@@ -27,7 +27,7 @@ export class McpSseService {
     @Inject('MCP_MODULE_ID') private readonly mcpModuleId: string,
     private readonly applicationConfig: ApplicationConfig,
     private readonly moduleRef: ModuleRef,
-    private readonly toolRegistry: McpRegistryService,
+    private readonly toolRegistry: McpRegistryDiscoveryService,
     @Inject(SsePingService) private readonly pingService: SsePingService,
   ) {
     this.logger = createMcpLogger(McpSseService.name, this.options);

package/src/mcp/services/mcp-streamable-http.service.ts

@@ -10,7 +10,7 @@ import {
 } from '../interfaces/http-adapter.interface';
 import type { McpOptions } from '../interfaces';
 import { McpExecutorService } from './mcp-executor.service';
-import { McpRegistryService } from './mcp-registry.service';
+import { McpRegistryDiscoveryService } from './mcp-registry-discovery.service';
 import { createMcpLogger } from '../utils/mcp-logger.factory';
 import { createMcpServer } from '../utils/mcp-server.factory';
 
@@ -28,7 +28,7 @@ export class McpStreamableHttpService implements OnModuleDestroy {
     @Inject('MCP_OPTIONS') private readonly options: McpOptions,
     @Inject('MCP_MODULE_ID') private readonly mcpModuleId: string,
     private readonly moduleRef: ModuleRef,
-    private readonly toolRegistry: McpRegistryService,
+    private readonly toolRegistry: McpRegistryDiscoveryService,
   ) {
     // Determine if we're in stateless mode
     this.isStatelessMode = !!options.streamableHttp?.statelessMode;

package/src/mcp/services/tool-authorization.service.ts

@@ -1,6 +1,6 @@
 import { Injectable } from '@nestjs/common';
 import { McpError, ErrorCode } from '@modelcontextprotocol/sdk/types.js';
-import { DiscoveredTool } from './mcp-registry.service';
+import { DiscoveredCapability } from './mcp-registry-discovery.service';
 import { ToolMetadata, SecurityScheme } from '../decorators/tool.decorator';
 import { JwtPayload } from '../../authz/services/jwt-token.service';
 
@@ -17,7 +17,7 @@ export class ToolAuthorizationService {
    * @returns Array of security schemes for the tool
    */
   generateSecuritySchemes(
-    tool: DiscoveredTool<ToolMetadata>,
+    tool: DiscoveredCapability<ToolMetadata>,
     moduleHasGuards: boolean,
   ): SecurityScheme[] {
     const metadata = tool.metadata;
@@ -56,7 +56,7 @@ export class ToolAuthorizationService {
    */
   canAccessTool(
     user: JwtPayload | undefined,
-    tool: DiscoveredTool<ToolMetadata>,
+    tool: DiscoveredCapability<ToolMetadata>,
     moduleHasGuards: boolean,
     allowUnauthenticatedAccess: boolean = false,
   ): boolean {
@@ -132,7 +132,7 @@ export class ToolAuthorizationService {
    */
   validateToolAccess(
     user: JwtPayload | undefined,
-    tool: DiscoveredTool<ToolMetadata>,
+    tool: DiscoveredCapability<ToolMetadata>,
     moduleHasGuards: boolean,
     allowUnauthenticatedAccess: boolean = false,
   ): void {