@rekog/mcp-nest 1.9.10 → 2.0.0-alpha.0

package/src/mcp/services/handlers/mcp-handler.base.ts

@@ -1,203 +0,0 @@
-import { ExceptionFilter, Logger, Type } from '@nestjs/common';
-import { ModuleRef, Reflector } from '@nestjs/core';
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import {
-  CallToolResult,
-  McpError,
-  Progress,
-  ErrorCode,
-} from '@modelcontextprotocol/sdk/types.js';
-import {
-  Context,
-  McpRequest,
-  SerializableValue,
-  HttpRequest,
-} from '../../interfaces';
-import { McpOptions } from '../../interfaces/mcp-options.interface';
-import {
-  DiscoveredCapability,
-  McpRegistryDiscoveryService,
-} from '../mcp-registry-discovery.service';
-import { createMcpLogger } from '../../utils/mcp-logger.factory';
-import {
-  EXCEPTION_FILTERS_METADATA,
-  FILTER_CATCH_EXCEPTIONS,
-} from '@nestjs/common/constants';
-import { ExecutionContextHost } from '@nestjs/core/helpers/execution-context-host';
-
-export abstract class McpHandlerBase {
-  protected logger: Logger;
-
-  protected constructor(
-    protected readonly moduleRef: ModuleRef,
-    protected readonly registry: McpRegistryDiscoveryService,
-    private readonly reflector: Reflector,
-    loggerContext: string,
-    options?: McpOptions,
-  ) {
-    this.logger = createMcpLogger(loggerContext, options);
-  }
-
-  protected createContext(
-    mcpServer: McpServer,
-    mcpRequest: McpRequest,
-  ): Context {
-    // handless stateless traffic where notifications and progress are not supported
-    if ((mcpServer.server.transport as any).sessionId === undefined) {
-      return this.createStatelessContext(mcpServer, mcpRequest);
-    }
-
-    const progressToken = mcpRequest.params?._meta?.progressToken;
-    return {
-      reportProgress: async (progress: Progress) => {
-        if (progressToken) {
-          await mcpServer.server.notification({
-            method: 'notifications/progress',
-            params: {
-              ...progress,
-              progressToken,
-            } as Progress,
-          });
-        }
-      },
-      log: {
-        debug: (message: string, context?: SerializableValue) => {
-          void mcpServer.server.sendLoggingMessage({
-            level: 'debug',
-            data: { message, context },
-          });
-        },
-        error: (message: string, context?: SerializableValue) => {
-          void mcpServer.server.sendLoggingMessage({
-            level: 'error',
-            data: { message, context },
-          });
-        },
-        info: (message: string, context?: SerializableValue) => {
-          void mcpServer.server.sendLoggingMessage({
-            level: 'info',
-            data: { message, context },
-          });
-        },
-        warn: (message: string, context?: SerializableValue) => {
-          void mcpServer.server.sendLoggingMessage({
-            level: 'warning',
-            data: { message, context },
-          });
-        },
-      },
-      mcpServer,
-      mcpRequest,
-    };
-  }
-
-  protected createStatelessContext(
-    mcpServer: McpServer,
-    mcpRequest: McpRequest,
-  ): Context {
-    const warn = (fn: string) => {
-      this.logger.warn(`Stateless context: '${fn}' is not supported.`);
-    };
-    return {
-      // eslint-disable-next-line @typescript-eslint/require-await,@typescript-eslint/no-unused-vars
-      reportProgress: async (_progress: Progress) => {
-        warn('reportProgress not supported in stateless');
-      },
-      log: {
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        debug: (_message: string, _data?: SerializableValue) => {
-          warn('server report logging not supported in stateless');
-        },
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        error: (_message: string, _data?: SerializableValue) => {
-          warn('server report logging not supported in stateless');
-        },
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        info: (_message: string, _data?: SerializableValue) => {
-          warn('server report logging not supported in stateless');
-        },
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        warn: (_message: string, _data?: SerializableValue) => {
-          warn('server report logging not supported in stateless');
-        },
-      },
-      mcpServer,
-      mcpRequest,
-    };
-  }
-
-  protected createErrorResponse(errorText: string): CallToolResult | never {
-    throw new McpError(ErrorCode.InternalError, errorText);
-  }
-
-  protected handleError(
-    error: Error,
-    capabilityInfo: DiscoveredCapability<object>,
-    httpRequest: HttpRequest,
-  ) {
-    this.logger.error(error);
-
-    // Re-throw McpErrors (like validation errors) so they are handled by the MCP protocol layer
-    if (error instanceof McpError) {
-      throw error;
-    }
-
-    const clazz = capabilityInfo.providerClass as new () => unknown;
-    const method = clazz.prototype[capabilityInfo.methodName] as (
-      ...args: unknown[]
-    ) => unknown;
-
-    const methodFilters =
-      this.reflector.get<Type<ExceptionFilter>[]>(
-        EXCEPTION_FILTERS_METADATA,
-        method,
-      ) ?? [];
-
-    const classFilters =
-      this.reflector.get<Type<ExceptionFilter>[]>(
-        EXCEPTION_FILTERS_METADATA,
-        clazz,
-      ) ?? [];
-
-    const allFilters = [...methodFilters, ...classFilters];
-
-    for (const FilterClass of allFilters) {
-      if (this.isExceptionFiltered(error, FilterClass)) {
-        const filterInstance = new FilterClass();
-        const host = new ExecutionContextHost(
-          [httpRequest.raw],
-          capabilityInfo.providerClass as Type,
-          method,
-        );
-        host.setType('http');
-        const result = filterInstance.catch(error, host);
-
-        const text =
-          typeof result === 'string' ? result : JSON.stringify(result);
-
-        return this.createErrorResponse(text);
-      }
-    }
-
-    return this.createErrorResponse(error.message);
-  }
-
-  private getExceptionTypes(filter: Type<ExceptionFilter>): Type<Error>[] {
-    return (
-      this.reflector.get<Type<Error>[]>(FILTER_CATCH_EXCEPTIONS, filter) ?? []
-    );
-  }
-
-  private isExceptionFiltered(
-    error: Error,
-    filter: Type<ExceptionFilter>,
-  ): boolean {
-    const exceptionTypes = this.getExceptionTypes(filter);
-
-    if (exceptionTypes.length === 0) {
-      return true;
-    }
-
-    return exceptionTypes.some((type) => error instanceof type);
-  }
-}

package/src/mcp/services/handlers/mcp-prompts.handler.ts

@@ -1,143 +0,0 @@
-import { Inject, Injectable, Optional, Scope } from '@nestjs/common';
-import { ContextIdFactory, ModuleRef, Reflector } from '@nestjs/core';
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import {
-  ErrorCode,
-  GetPromptRequestSchema,
-  ListPromptsRequestSchema,
-  McpError,
-  PromptArgument,
-} from '@modelcontextprotocol/sdk/types.js';
-import {
-  DiscoveredCapability,
-  McpRegistryDiscoveryService,
-} from '../mcp-registry-discovery.service';
-import { McpHandlerBase } from './mcp-handler.base';
-import { HttpRequest } from '../../interfaces/http-adapter.interface';
-import type { McpOptions } from '../../interfaces/mcp-options.interface';
-import { PromptMetadata } from '../../decorators';
-import {
-  McpRegistryService,
-  DYNAMIC_PROMPT_HANDLER_TOKEN,
-} from '../mcp-dynamic-registry.service';
-
-@Injectable({ scope: Scope.REQUEST })
-export class McpPromptsHandler extends McpHandlerBase {
-  constructor(
-    moduleRef: ModuleRef,
-    registry: McpRegistryDiscoveryService,
-    reflector: Reflector,
-    @Inject('MCP_MODULE_ID') private readonly mcpModuleId: string,
-    @Optional() @Inject('MCP_OPTIONS') options?: McpOptions,
-  ) {
-    super(moduleRef, registry, reflector, McpPromptsHandler.name, options);
-  }
-
-  registerHandlers(mcpServer: McpServer, httpRequest: HttpRequest) {
-    if (this.registry.getPrompts(this.mcpModuleId).length === 0) {
-      this.logger.debug('No prompts registered, skipping prompt handlers');
-      return;
-    }
-    mcpServer.server.setRequestHandler(ListPromptsRequestSchema, () => {
-      this.logger.debug('ListPromptsRequestSchema is being called');
-
-      const prompts = this.registry
-        .getPrompts(this.mcpModuleId)
-        .map((prompt) => ({
-          name: prompt.metadata.name,
-          description: prompt.metadata.description,
-          arguments: prompt.metadata.parameters
-            ? Object.entries(prompt.metadata.parameters.shape).map(
-                ([name, field]): PromptArgument => ({
-                  name,
-                  description: field.description,
-                  required: !field.isOptional(),
-                }),
-              )
-            : [],
-        }));
-
-      return {
-        prompts,
-      };
-    });
-
-    mcpServer.server.setRequestHandler(
-      GetPromptRequestSchema,
-      async (request) => {
-        this.logger.debug('GetPromptRequestSchema is being called');
-        let promptInfo: DiscoveredCapability<PromptMetadata> | undefined;
-
-        try {
-          const name = request.params.name;
-          promptInfo = this.registry.findPrompt(this.mcpModuleId, name);
-
-          if (!promptInfo) {
-            throw new McpError(
-              ErrorCode.MethodNotFound,
-              `Unknown prompt: ${name}`,
-            );
-          }
-
-          const context = this.createContext(mcpServer, request);
-
-          if (promptInfo.providerClass === DYNAMIC_PROMPT_HANDLER_TOKEN) {
-            const handler = McpRegistryService.getPromptHandlerByModuleId(
-              this.mcpModuleId,
-              name,
-            );
-
-            if (!handler) {
-              throw new McpError(
-                ErrorCode.MethodNotFound,
-                `Handler not found for dynamic prompt: ${name}`,
-              );
-            }
-
-            const result = await handler(
-              request.params.arguments,
-              context,
-              httpRequest.raw,
-            );
-
-            this.logger.debug('GetPromptRequestSchema result', result);
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-            return result;
-          }
-
-          const contextId = ContextIdFactory.getByRequest(httpRequest);
-          this.moduleRef.registerRequestByContextId(httpRequest, contextId);
-
-          const promptInstance = await this.moduleRef.resolve(
-            promptInfo.providerClass,
-            contextId,
-            { strict: false },
-          );
-
-          if (!promptInstance) {
-            throw new McpError(
-              ErrorCode.MethodNotFound,
-              `Unknown prompt: ${name}`,
-            );
-          }
-
-          const methodName = promptInfo.methodName;
-
-          const result = await promptInstance[methodName].call(
-            promptInstance,
-            request.params.arguments,
-            context,
-            httpRequest.raw,
-          );
-
-          this.logger.debug('GetPromptRequestSchema result', result);
-
-          // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-          return result;
-        } catch (error) {
-          this.handleError(error as Error, promptInfo!, httpRequest);
-        }
-      },
-    );
-  }
-}

package/src/mcp/services/handlers/mcp-resources.handler.ts

@@ -1,183 +0,0 @@
-import {
-  Inject,
-  Injectable,
-  InjectionToken,
-  Optional,
-  Scope,
-} from '@nestjs/common';
-import { ContextIdFactory, ModuleRef, Reflector } from '@nestjs/core';
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import {
-  ErrorCode,
-  ListResourcesRequestSchema,
-  ListResourceTemplatesRequestSchema,
-  McpError,
-  ReadResourceRequestSchema,
-  ReadResourceResult,
-} from '@modelcontextprotocol/sdk/types.js';
-import { McpRegistryDiscoveryService } from '../mcp-registry-discovery.service';
-import { McpHandlerBase } from './mcp-handler.base';
-import type { Context, McpOptions } from '../../interfaces';
-import { HttpRequest } from '../../interfaces/http-adapter.interface';
-import {
-  McpRegistryService,
-  DYNAMIC_RESOURCE_HANDLER_TOKEN,
-} from '../mcp-dynamic-registry.service';
-
-@Injectable({ scope: Scope.REQUEST })
-export class McpResourcesHandler extends McpHandlerBase {
-  constructor(
-    moduleRef: ModuleRef,
-    registry: McpRegistryDiscoveryService,
-    reflector: Reflector,
-    @Inject('MCP_MODULE_ID') private readonly mcpModuleId: string,
-    @Optional() @Inject('MCP_OPTIONS') options?: McpOptions,
-  ) {
-    super(moduleRef, registry, reflector, McpResourcesHandler.name, options);
-  }
-
-  registerHandlers(mcpServer: McpServer, httpRequest: HttpRequest) {
-    const resources = this.registry.getResources(this.mcpModuleId);
-    const resourceTemplates = this.registry.getResourceTemplates(
-      this.mcpModuleId,
-    );
-    if (resources.length === 0 && resourceTemplates.length === 0) {
-      this.logger.debug(
-        'No resources or resource templates registered, skipping resource handlers',
-      );
-      return;
-    }
-
-    mcpServer.server.setRequestHandler(ListResourcesRequestSchema, () => {
-      this.logger.debug('ListResourcesRequestSchema is being called');
-      return {
-        resources: this.registry
-          .getResources(this.mcpModuleId)
-          .map((resources) => resources.metadata),
-      };
-    });
-
-    mcpServer.server.setRequestHandler(
-      ListResourceTemplatesRequestSchema,
-      () => {
-        this.logger.debug('ListResourceTemplatesRequestSchema is being called');
-        return {
-          resourceTemplates: this.registry
-            .getResourceTemplates(this.mcpModuleId)
-            .map((resourceTemplate) => resourceTemplate.metadata),
-        };
-      },
-    );
-
-    mcpServer.server.setRequestHandler(
-      ReadResourceRequestSchema,
-      async (request) => {
-        this.logger.debug('ReadResourceRequestSchema is being called');
-
-        const uri = request.params.uri;
-        const resourceInfo = this.registry.findResourceByUri(
-          this.mcpModuleId,
-          uri,
-        );
-        const resourceTemplateInfo = this.registry.findResourceTemplateByUri(
-          this.mcpModuleId,
-          uri,
-        );
-
-        try {
-          let providerClass: InjectionToken;
-          let params: Record<string, unknown> = {};
-          let methodName: string;
-          if (resourceTemplateInfo) {
-            providerClass = resourceTemplateInfo.resourceTemplate.providerClass;
-            params = {
-              ...resourceTemplateInfo.params,
-              ...request.params,
-            };
-            methodName = resourceTemplateInfo.resourceTemplate.methodName;
-          } else if (resourceInfo) {
-            providerClass = resourceInfo.resource.providerClass;
-
-            params = {
-              ...resourceInfo.params,
-              ...request.params,
-            };
-            methodName = resourceInfo.resource.methodName;
-          } else {
-            throw new McpError(
-              ErrorCode.MethodNotFound,
-              `Unknown resource: ${uri}`,
-            );
-          }
-          return await this.handleRequest(
-            httpRequest,
-            providerClass,
-            uri,
-            this.createContext(mcpServer, request),
-            params,
-            methodName,
-          );
-        } catch (error) {
-          return this.handleError(
-            error as Error,
-            (resourceInfo?.resource ?? resourceTemplateInfo?.resourceTemplate)!,
-            httpRequest,
-          );
-        }
-      },
-    );
-  }
-
-  private async handleRequest(
-    httpRequest: HttpRequest,
-    providerClass: InjectionToken,
-    uri: string,
-    context: Context,
-    requestParams: Record<string, unknown>,
-    methodName: string,
-  ) {
-    if (providerClass === DYNAMIC_RESOURCE_HANDLER_TOKEN) {
-      const handler = McpRegistryService.getResourceHandlerByModuleId(
-        this.mcpModuleId,
-        methodName,
-      );
-
-      if (!handler) {
-        throw new McpError(
-          ErrorCode.MethodNotFound,
-          `Handler not found for dynamic resource: ${uri}`,
-        );
-      }
-
-      const result = await handler(requestParams, context, httpRequest.raw);
-      this.logger.debug('ReadResourceRequestSchema result', result);
-      return result as ReadResourceResult;
-    }
-
-    const contextId = ContextIdFactory.getByRequest(httpRequest);
-    this.moduleRef.registerRequestByContextId(httpRequest, contextId);
-
-    const resourceInstance = await this.moduleRef.resolve(
-      providerClass,
-      contextId,
-      { strict: false },
-    );
-
-    if (!resourceInstance) {
-      throw new McpError(
-        ErrorCode.MethodNotFound,
-        `Unknown resource template: ${uri}`,
-      );
-    }
-    const result = await resourceInstance[methodName].call(
-      resourceInstance,
-      requestParams,
-      context,
-      httpRequest,
-    );
-
-    this.logger.debug('ReadResourceRequestSchema result', result);
-
-    return result as ReadResourceResult;
-  }
-}

package/src/mcp/services/handlers/mcp-tools.handler.spec.ts

@@ -1,41 +0,0 @@
-import { McpError } from '@modelcontextprotocol/sdk/types.js';
-import { z } from 'zod';
-import { McpToolsHandler } from './mcp-tools.handler';
-
-const formatToolResult = McpToolsHandler.prototype['formatToolResult'].bind({
-  buildDefaultContentBlock: McpToolsHandler.prototype['buildDefaultContentBlock'],
-});
-
-const schema = z.object({ name: z.string(), age: z.number() });
-
-describe('formatToolResult', () => {
-  it('strips extra keys from structuredContent when outputSchema is set', () => {
-    const result = formatToolResult({ name: 'Alice', age: 30, extra: true }, schema);
-
-    expect(result.structuredContent).toEqual({ name: 'Alice', age: 30 });
-    expect(result.structuredContent).not.toHaveProperty('extra');
-  });
-
-  it('keeps the original result (with extra keys) in the content text block', () => {
-    const result = formatToolResult({ name: 'Alice', age: 30, extra: true }, schema);
-    const text = JSON.parse(result.content[0].text);
-
-    expect(text).toHaveProperty('extra', true);
-  });
-
-  it('throws McpError when result does not match outputSchema', () => {
-    expect(() => formatToolResult({ name: 'Alice' }, schema)).toThrow(McpError);
-  });
-
-  it('wraps result in content block when no outputSchema is provided', () => {
-    const result = formatToolResult({ anything: 42 });
-
-    expect(result.structuredContent).toBeUndefined();
-    expect(result.content[0].text).toBe('{"anything":42}');
-  });
-
-  it('returns as-is when result already has a content array', () => {
-    const existing = { content: [{ type: 'text', text: 'hi' }] };
-    expect(formatToolResult(existing, schema)).toBe(existing);
-  });
-});