@muzikanto/nestjs-mcp 1.3.0 → 1.5.1

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # @muzikanto/nestjs-mcp
 
+## 1.5.1
+
+### Patch Changes
+
+- custom mcp errors for filters
+
+## 1.5.0
+
+### Minor Changes
+
+- add UseFilters support
+
+## 1.4.0
+
+### Minor Changes
+
+- Dynamic tools, prompts, resources initialization
+
 ## 1.3.0
 
 ### Minor Changes

package/README.md

@@ -1,7 +1,7 @@
 # @muzikanto/nestjs-mcp
 
 [![npm](https://img.shields.io/npm/v/@muzikanto/nestjs-mcp)](https://www.npmjs.com/package/@muzikanto/nestjs-mcp)
-[![downloads](https://img.shields.io/npm/dt/@muzikanto/nestjs-mcp)]((https://www.npmjs.com/package/@muzikanto/nestjs-mcp))
+[![downloads](https://img.shields.io/npm/dt/@muzikanto/nestjs-mcp)](<(https://www.npmjs.com/package/@muzikanto/nestjs-mcp)>)
 [![GitHub stars](https://img.shields.io/github/stars/Muzikanto/nestjs-mcp?style=social)](https://github.com/Muzikanto/nestjs-mcp)
 [![License](https://img.shields.io/npm/l/@muzikanto/nestjs-mcp)](https://github.com/Muzikanto/nestjs-mcp/blob/main/LICENSE)
 
@@ -10,6 +10,7 @@ NestJS MCP (Model Context Protocol) module — allows you to create “tools”,
 ---
 
 ## Contents
+
 - [Features](#features)
 - [Installation](#installation)
 - [Usage](#usage)
@@ -17,11 +18,18 @@ NestJS MCP (Model Context Protocol) module — allows you to create “tools”,
   - [Create MCP tool](#create-mcp-tool)
   - [Create MCP prompt](#create-mcp-prompt)
   - [Create MCP resource](#create-mcp-resource)
+  - [Dynamic creation](#dynamic-creation)
   - [Calling MCP tools via HTTP](#calling-mcp-tools-via-http)
   - [Calling MCP prompt via HTTP](#obtain-prompt)
   - [Obtaining all tools](#obtaining-all-tools)
   - [Obtaining all prompts](#obtaining-all-prompts)
-  - [Auth guard](#auth-guard)
+  - [Guards](#guards)
+    - [For one](#for-one)
+    - [For all](#for-all)
+  - [Interceptors](#interceptors)
+    - [For one](#for-one-1)
+    - [For all](#for-all-1)
+  - [Filters](#filters)
   - [Integration with OpenAI Function Calls](#integration-with-openai-function-calls)
 
 ## Features
@@ -30,14 +38,15 @@ NestJS MCP (Model Context Protocol) module — allows you to create “tools”,
 - Register MCP prompts using the `@McpPrompt()` decorator
 - Automatic detection of all providers (tools) in the module
 - Input data validation
-- SSE endpoints for MCP  (`GET /mcp/sse, POST /mcp/messages`)
-- Endpoint for calling tool (`POST /mcp/toos`)  
-- Endpoint for a list of all tools (`GET /mcp/tools`)  
+- SSE endpoints for MCP (`GET /mcp/sse, POST /mcp/messages`)
+- Endpoint for calling tool (`POST /mcp/toos`)
+- Endpoint for a list of all tools (`GET /mcp/tools`)
 - Endpoint for calling prompt (`POST /mcp/prompts/:name`)
-- Endpoint for a list of all prompts (`GET /mcp/prompts`)  
-- Easy integration with LLM (OpenAI Function Calls)  
+- Endpoint for a list of all prompts (`GET /mcp/prompts`)
+- Easy integration with LLM (OpenAI Function Calls)
 - Support http adapters (default fastify)
-- Full TypeScript typing  
+- Full TypeScript typing
+- Support `@UseGuards`, `@UseInterceptors`, `@UseFilters`
 
 ---
 
@@ -54,10 +63,10 @@ Peer dependencies: `@nestjs/common, @nestjs/core, @nestjs/swagger, reflect-metad
 ### Connecting the MCP module
 
 ```ts
-import { Module } from '@nestjs/common';
-import { McpModule } from '@muzikanto/nestjs-mcp';
-import { TelegramSendMessageTool } from './tools/telegram-send-message.tool';
-import { TelegramAutoReplyPrompt } from './prompts/telegram-auto-reply.prompt';
+import { Module } from "@nestjs/common";
+import { McpModule } from "@muzikanto/nestjs-mcp";
+import { TelegramSendMessageTool } from "./tools/telegram-send-message.tool";
+import { TelegramAutoReplyPrompt } from "./prompts/telegram-auto-reply.prompt";
 
 @Module({
   imports: [
@@ -72,13 +81,13 @@ export class AppModule {}
 ### Create MCP tool
 
 ```ts
-import { IMcpTool, McpTool } from '@muzikanto/nestjs-mcp';
-import { Telegraf } from 'telegraf';
-import z from 'zod';
+import { IMcpTool, McpTool } from "@muzikanto/nestjs-mcp";
+import { Telegraf } from "telegraf";
+import z from "zod";
 
 const schema = {
-  chatId: z.string().describe('Telegram chat id'),  // строка с описанием
-  text: z.string().describe('Message text'),  // строка с описанием
+  chatId: z.string().describe("Telegram chat id"), // строка с описанием
+  text: z.string().describe("Message text"), // строка с описанием
 };
 
 @McpTool()
@@ -86,7 +95,7 @@ export class TelegramSendMessageTool implements IMcpTool<
   { chatId: string; text: string },
   { success: boolean }
 > {
-  name = 'telegram.sendMessage';
+  name = "telegram.sendMessage";
 
   inputSchema = schema;
 
@@ -113,7 +122,8 @@ POST /mcp
 }
 ```
 
-Ответ 
+Ответ
+
 ```json
 {
   "data": {
@@ -134,7 +144,7 @@ GET /mcp/tool
     "inputSchema": {
       "type": "object",
       "properties": {
-          "chatId": {
+        "chatId": {
           "type": "number",
           "description": "Telegram chat ID"
         },
@@ -143,10 +153,7 @@ GET /mcp/tool
           "description": "Message text"
         }
       },
-      "required": [
-          "chatId",
-          "text"
-      ]
+      "required": ["chatId", "text"]
     }
   }
 ]
@@ -155,29 +162,33 @@ GET /mcp/tool
 ### Create MCP prompt
 
 ```ts
-import { IMcpPrompt, McpPrompt } from '@muzikanto/nestjs-mcp';
-import z from 'zod';
+import { IMcpPrompt, McpPrompt } from "@muzikanto/nestjs-mcp";
+import z from "zod";
 
 const schema = {
-  chatId: z.string().describe('Telegram chat id'),  // строка с описанием
-  text: z.string().describe('Message text'),  // строка с описанием
+  chatId: z.string().describe("Telegram chat id"), // строка с описанием
+  text: z.string().describe("Message text"), // строка с описанием
 };
 
 @McpPrompt()
-export class TelegramAutoReplyPrompt implements IMcpPrompt<{ text: string; chatId: number; }> {
-  name = 'telegram_auto_reply';
-  description = 'Generate a short, fiendly reply to an incoming Telegram message and send it back to the same chat using teegram.sendMessage tool';
+export class TelegramAutoReplyPrompt implements IMcpPrompt<{
+  text: string;
+  chatId: number;
+}> {
+  name = "telegram_auto_reply";
+  description =
+    "Generate a short, fiendly reply to an incoming Telegram message and send it back to the same chat using teegram.sendMessage tool";
   schema = schema;
 
   async execute({ text, chatId }: { text: string; chatId: number }) {
     return [
       {
         role: "system",
-        content: `You are a friendly Telegram bot. Reply briefly and to the point.`
+        content: `You are a friendly Telegram bot. Reply briefly and to the point.`,
       },
       {
         role: "user",
-        content: text
+        content: text,
       },
       {
         role: "assistant",
@@ -185,10 +196,10 @@ export class TelegramAutoReplyPrompt implements IMcpPrompt<{ text: string; chatI
           name: "telegram.sendMessage",
           arguments: {
             chatId,
-            text: "{{model_output}}"
-          }
-        }
-      }
+            text: "{{model_output}}",
+          },
+        },
+      },
     ];
   }
 }
@@ -206,7 +217,7 @@ GET /mcp/prompts
     "inputSchema": {
       "type": "object",
       "properties": {
-          "chatId": {
+        "chatId": {
           "type": "number",
           "description": "Telegram chat ID"
         },
@@ -215,10 +226,7 @@ GET /mcp/prompts
           "description": "Message text"
         }
       },
-      "required": [
-          "chatId",
-          "text"
-      ]
+      "required": ["chatId", "text"]
     }
   }
 ]
@@ -236,42 +244,43 @@ POST /mcp/prompts/telegram_auto_reply
 ```
 
 Response
+
 ```json
 {
   "messages": [
-      {
-        "role": "system",
-        "content": "You are a friendly Telegram bot. Reply briefly and to the point."
-      },
-      {
-        "role": "user",
-        "content": "Hi. How are you ?"
-      },
-      {
-        "role": "assistant",
-        "tool_call": {
-          "name": "telegram.sendMessage",
-          "arguments": {
-            "chatId": 100000000,
-            "text": "{{model_output}}"
-          }
+    {
+      "role": "system",
+      "content": "You are a friendly Telegram bot. Reply briefly and to the point."
+    },
+    {
+      "role": "user",
+      "content": "Hi. How are you ?"
+    },
+    {
+      "role": "assistant",
+      "tool_call": {
+        "name": "telegram.sendMessage",
+        "arguments": {
+          "chatId": 100000000,
+          "text": "{{model_output}}"
         }
       }
-    ]
+    }
+  ]
 }
 ```
 
 ### Create MCP resource
 
 ```ts
-import { IMcpResource, McpResource } from '@muzikanto/nestjs-mcp';
+import { IMcpResource, McpResource } from "@muzikanto/nestjs-mcp";
 
 @McpResource()
 export class TestResource implements IMcpResource<{ userId: string }> {
-  name = 'users.get';
-  uri = 'users://{userId}';
-  title = 'Get test user';
-  description = 'Get user by id';
+  name = "users.get";
+  uri = "users://{userId}";
+  title = "Get test user";
+  description = "Get user by id";
 
   async execute(url: URL, vars: { userId: string }) {
     return [{ uri: url.href, text: `Hello ${vars.userId}` }];
@@ -279,17 +288,64 @@ export class TestResource implements IMcpResource<{ userId: string }> {
 }
 ```
 
-### Auth guard
+### Dynamic creation
+
 ```ts
-import { IMcpTool, McpTool } from '@muzikanto/nestjs-mcp';
-import { UseGuards } from '@nestjs/common';
-import { CanActivate, ExecutionContext, Injectable } from '@nestjs/common';
-import { Observable } from 'rxjs';
+import { McpDynamicService } from "@muzikanto/nestjs-mcp";
+import { Injectable } from "@nestjs/common";
+import { ExampleInterceptor } from "./example.interceptor";
+import { ExampleGuard } from "./example.guard";
+
+@Injectable()
+export class McpDynamic {
+  constructor(protected readonly mcpDynamicService: McpDynamicService) {}
+
+  onModuleInit() {
+    this.mcpDynamicService.registerTool({
+      name: "dynamic_tool",
+      title: "Dynamic tool",
+      execute: () => Promise.resolve("test"),
+      guards: [ExampleGuard],
+      interceptors: [ExampleInterceptor],
+    });
+
+    this.mcpDynamicService.registerPrompt({
+      name: "dynamic_prompt",
+      title: "Dynamic prompt",
+      execute: () => Promise.resolve([{ role: "assistant", content: "test" }]),
+      guards: [ExampleGuard],
+      interceptors: [ExampleInterceptor],
+    });
+
+    this.mcpDynamicService.registerResource<{ testId: string }>({
+      name: "dynamic_resource",
+      title: "Dynamic resource",
+      uri: "dynamic://test/{testId}",
+      execute: (uri, input) =>
+        Promise.resolve([{ uri: uri.href, text: `ID: ${input.testId}` }]),
+      guards: [ExampleGuard],
+      interceptors: [ExampleInterceptor],
+    });
+  }
+}
+```
+
+### Guards
+
+### For one
+
+```ts
+import { IMcpTool, McpTool } from "@muzikanto/nestjs-mcp";
+import { UseGuards } from "@nestjs/common";
+import { CanActivate, ExecutionContext, Injectable } from "@nestjs/common";
+import { Observable } from "rxjs";
 
 @Injectable()
 class TestGuard implements CanActivate {
-  canActivate(context: ExecutionContext): boolean | Promise<boolean> | Observable<boolean> {
-    console.log('TestGuard called');
+  canActivate(
+    context: ExecutionContext,
+  ): boolean | Promise<boolean> | Observable<boolean> {
+    console.log("TestGuard called");
     return true;
   }
 }
@@ -300,7 +356,75 @@ export class TelegramSendMessageTool implements IMcpTool<
   { chatId: string; text: string },
   { success: boolean }
 > {
-  name = 'telegram.sendMessage';
+  name = "telegram.sendMessage";
+
+  async execute() {
+    await this.bot.telegram.sendMessage(input.chatId, input.text);
+    return { success: true };
+  }
+}
+```
+
+#### For all
+
+```ts
+import { McpModule } from "@muzikanto/nestjs-mcp";
+import { Module } from "@nestjs/common";
+import { TestGuard } from "./other/test.guard";
+import { ToolWithoutGuards } from "./test.tool";
+import { APP_GUARD } from "@nestjs/core";
+
+@Module({
+  imports: [
+    McpModule.forRoot({
+      providers: [
+        ToolWithoutGuards,
+        TestGuard,
+        { provide: APP_GUARD, useExisting: TestGuard },
+      ],
+    }),
+  ],
+})
+export class TestModule {}
+```
+
+### Interceptors
+
+#### For one
+
+```ts
+import { IMcpTool, McpTool } from "@muzikanto/nestjs-mcp";
+import {
+  ExecutionContext,
+  NestInterceptor,
+  CallHandler,
+  Injectable,
+  UseInterceptors,
+} from "@nestjs/common";
+import { map } from "rxjs";
+
+@Injectable()
+export class ExampleInterceptor implements NestInterceptor {
+  intercept(context: ExecutionContext, next: CallHandler) {
+    console.log("Before execute");
+
+    return next.handle().pipe(
+      map((data: unknown) => {
+        console.log("After execute", data);
+
+        return data;
+      }),
+    );
+  }
+}
+
+@UseInterceptors(TestInterceptor)
+@McpTool()
+export class TelegramSendMessageTool implements IMcpTool<
+  { chatId: string; text: string },
+  { success: boolean }
+> {
+  name = "telegram.sendMessage";
 
   async execute() {
     await this.bot.telegram.sendMessage(input.chatId, input.text);
@@ -309,6 +433,64 @@ export class TelegramSendMessageTool implements IMcpTool<
 }
 ```
 
+#### For all
+
+```ts
+import { McpModule } from "@muzikanto/nestjs-mcp";
+import { Module } from "@nestjs/common";
+import { TestInterceptor } from "./other/test.interceptor";
+import { ToolWithoutInterceptors } from "./test.tool";
+import { APP_INTERCEPTOR } from "@nestjs/core";
+
+@Module({
+  imports: [
+    McpModule.forRoot({
+      providers: [
+        ToolWithoutInterceptors,
+        TestGuard,
+        { provide: APP_INTERCEPTOR, useExisting: TestInterceptor },
+      ],
+    }),
+  ],
+})
+export class TestModule {}
+```
+
+### Filters
+
+```ts
+import { IMcpTool, McpTool, McpUnauthorizedException } from "@muzikanto/nestjs-mcp";
+import {
+  ExceptionFilter,
+  Catch,
+  ArgumentsHost,
+  UseFilters,
+} from "@nestjs/common";
+
+@Catch(McpUnauthorizedException)
+class ExampleFilter implements ExceptionFilter {
+  catch(exception: unknown, host: ArgumentsHost) {
+    return {
+      isError: true,
+      text: (exception as Error).message,
+    };
+  }
+}
+
+@UseFilters(ExampleFilter)
+@McpTool()
+export class TelegramSendMessageTool implements IMcpTool<
+  { chatId: string; text: string },
+  { success: boolean }
+> {
+  name = "telegram.sendMessage";
+
+  async execute() {
+    throw new NotImplementedException();
+  }
+}
+```
+
 ### Integration with OpenAI Function Calls
 
 ```ts
@@ -374,7 +556,9 @@ async function callMcpTool(toolName: string, payload: Record<string, any>) {
 ```
 
 ## Contributing
+
 Contributions are welcome! Please open issues or submit PRs.
 
 ## Changelog
+
 See [CHANGELOG](https://github.com/Muzikanto/nestjs-mcp/blob/main/CHANGELOG.md) for detailed version history and updates.

package/dist/index.d.ts

@@ -4,3 +4,5 @@ export * from "./mcp-server/decorators/mcp-prompt.decorator";
 export * from "./mcp-server/decorators/mcp-resource.decorator";
 export * from "./mcp-client/mcp-client.module";
 export * from "./mcp-client/mcp-client.service";
+export * from "./mcp-server/mcp-dynamic.service";
+export * from "./mcp-server/exceptions";

package/dist/index.js

@@ -20,3 +20,5 @@ __exportStar(require("./mcp-server/decorators/mcp-prompt.decorator"), exports);
 __exportStar(require("./mcp-server/decorators/mcp-resource.decorator"), exports);
 __exportStar(require("./mcp-client/mcp-client.module"), exports);
 __exportStar(require("./mcp-client/mcp-client.service"), exports);
+__exportStar(require("./mcp-server/mcp-dynamic.service"), exports);
+__exportStar(require("./mcp-server/exceptions"), exports);

package/dist/mcp-server/exceptions/index.d.ts

@@ -0,0 +1,31 @@
+import { HttpException, HttpStatus } from "@nestjs/common";
+export declare class McpException extends HttpException {
+    constructor(message: string, status?: HttpStatus, options?: {
+        cause?: unknown;
+    });
+}
+export declare class McpBadRequestException extends McpException {
+    constructor(message: string, options?: {
+        cause?: unknown;
+    });
+}
+export declare class McpNotFoundException extends McpException {
+    constructor(message: string, options?: {
+        cause?: unknown;
+    });
+}
+export declare class McpInternalServerErrorException extends McpException {
+    constructor(message: string, options?: {
+        cause?: unknown;
+    });
+}
+export declare class McpUnauthorizedException extends McpException {
+    constructor(message: string, options?: {
+        cause?: unknown;
+    });
+}
+export declare class McpNotImplementedException extends McpException {
+    constructor(message: string, options?: {
+        cause?: unknown;
+    });
+}

package/dist/mcp-server/exceptions/index.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.McpNotImplementedException = exports.McpUnauthorizedException = exports.McpInternalServerErrorException = exports.McpNotFoundException = exports.McpBadRequestException = exports.McpException = void 0;
+const common_1 = require("@nestjs/common");
+class McpException extends common_1.HttpException {
+    constructor(message, status = common_1.HttpStatus.INTERNAL_SERVER_ERROR, options) {
+        super({ message, ...(options?.cause ? { cause: options.cause } : {}) }, status);
+    }
+}
+exports.McpException = McpException;
+class McpBadRequestException extends McpException {
+    constructor(message, options) {
+        super(message, common_1.HttpStatus.BAD_REQUEST, options);
+    }
+}
+exports.McpBadRequestException = McpBadRequestException;
+class McpNotFoundException extends McpException {
+    constructor(message, options) {
+        super(message, common_1.HttpStatus.NOT_FOUND, options);
+    }
+}
+exports.McpNotFoundException = McpNotFoundException;
+class McpInternalServerErrorException extends McpException {
+    constructor(message, options) {
+        super(message, common_1.HttpStatus.INTERNAL_SERVER_ERROR, options);
+    }
+}
+exports.McpInternalServerErrorException = McpInternalServerErrorException;
+class McpUnauthorizedException extends McpException {
+    constructor(message, options) {
+        super(message, common_1.HttpStatus.UNAUTHORIZED, options);
+    }
+}
+exports.McpUnauthorizedException = McpUnauthorizedException;
+class McpNotImplementedException extends McpException {
+    constructor(message, options) {
+        super(message, common_1.HttpStatus.NOT_IMPLEMENTED, options);
+    }
+}
+exports.McpNotImplementedException = McpNotImplementedException;

package/dist/mcp-server/mcp-dynamic.service.d.ts

@@ -0,0 +1,31 @@
+import { CanActivate, NestInterceptor, Type } from "@nestjs/common";
+import { ModuleRef } from "@nestjs/core";
+import { McpService } from "./mcp.service";
+import { IMcpTool } from "./decorators/mcp-tool.decorator";
+import { IMcpResource } from "./decorators/mcp-resource.decorator";
+import { IMcpPrompt } from "./decorators/mcp-prompt.decorator";
+export type IMcpDynamicTool<Input, Result> = IMcpTool<Input, Result> & {
+    guards?: Type<CanActivate>[];
+    interceptors?: Type<NestInterceptor>[];
+};
+export type IMcpDynamicPrompt<Input> = IMcpPrompt<Input> & {
+    guards?: Type<CanActivate>[];
+    interceptors?: Type<NestInterceptor>[];
+};
+export type IMcpDynamicResource<Input> = IMcpResource<Input> & {
+    guards?: Type<CanActivate>[];
+    interceptors?: Type<NestInterceptor>[];
+};
+export declare class McpDynamicService {
+    private readonly moduleRef;
+    private readonly mcpService;
+    constructor(moduleRef: ModuleRef, mcpService: McpService);
+    /** Динамически регистрирует MCP tools */
+    registerTool<Input, Result>(tool: IMcpDynamicTool<Input, Result>): Promise<void>;
+    /** Динамически регистрирует MCP prompts */
+    registerPrompt<Input>(prompt: IMcpDynamicPrompt<Input>): Promise<void>;
+    /** Динамически регистрирует MCP resources */
+    registerResource<Input>(resource: IMcpDynamicResource<Input>): Promise<void>;
+    protected applyGuards(item: Function, guards: Type<CanActivate>[]): void;
+    protected applyInterceptors(item: Function, interceptors: Type<NestInterceptor>[]): void;
+}

package/dist/mcp-server/mcp-dynamic.service.js

@@ -0,0 +1,100 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.McpDynamicService = void 0;
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+const mcp_service_1 = require("./mcp.service");
+const constants_1 = require("@nestjs/common/constants");
+let McpDynamicService = class McpDynamicService {
+    moduleRef;
+    mcpService;
+    constructor(moduleRef, mcpService) {
+        this.moduleRef = moduleRef;
+        this.mcpService = mcpService;
+    }
+    /** Динамически регистрирует MCP tools */
+    async registerTool(tool) {
+        const DynamicToolClass = class {
+            name = tool.name;
+            title = tool.title;
+            description = tool.description;
+            execute = tool.execute;
+            inputSchema = tool.inputSchema;
+        };
+        if (tool.guards) {
+            this.applyGuards(DynamicToolClass, tool.guards);
+        }
+        if (tool.interceptors) {
+            this.applyInterceptors(DynamicToolClass, tool.interceptors);
+        }
+        const instance = await this.moduleRef.create(DynamicToolClass);
+        this.mcpService.registerTool(instance.name, {
+            instance,
+            metatype: DynamicToolClass,
+        });
+    }
+    /** Динамически регистрирует MCP prompts */
+    async registerPrompt(prompt) {
+        const DynamicPromptClass = class {
+            name = prompt.name;
+            title = prompt.title;
+            description = prompt.description;
+            execute = prompt.execute;
+            inputSchema = prompt.inputSchema;
+        };
+        if (prompt.guards) {
+            this.applyGuards(DynamicPromptClass, prompt.guards);
+        }
+        if (prompt.interceptors) {
+            this.applyInterceptors(DynamicPromptClass, prompt.interceptors);
+        }
+        const instance = await this.moduleRef.create(DynamicPromptClass);
+        this.mcpService.registerPrompt(instance.name, {
+            instance,
+            metatype: DynamicPromptClass,
+        });
+    }
+    /** Динамически регистрирует MCP resources */
+    async registerResource(resource) {
+        const DynamicResourceClass = class {
+            name = resource.name;
+            title = resource.title;
+            uri = resource.uri;
+            description = resource.description;
+            execute = resource.execute;
+            list = resource.list;
+        };
+        if (resource.guards) {
+            this.applyGuards(DynamicResourceClass, resource.guards);
+        }
+        if (resource.interceptors) {
+            this.applyInterceptors(DynamicResourceClass, resource.interceptors);
+        }
+        const instance = await this.moduleRef.create(DynamicResourceClass);
+        this.mcpService.registerResource(instance.name, {
+            instance,
+            metatype: DynamicResourceClass,
+        });
+    }
+    applyGuards(item, guards) {
+        Reflect.defineMetadata(constants_1.GUARDS_METADATA, guards, item);
+    }
+    applyInterceptors(item, interceptors) {
+        Reflect.defineMetadata(constants_1.INTERCEPTORS_METADATA, interceptors, item);
+    }
+};
+exports.McpDynamicService = McpDynamicService;
+exports.McpDynamicService = McpDynamicService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [core_1.ModuleRef,
+        mcp_service_1.McpService])
+], McpDynamicService);

package/dist/mcp-server/mcp.module.js

@@ -16,6 +16,7 @@ const mcp_controller_1 = require("./mcp.controller");
 const inject_tokens_1 = require("./utils/inject-tokens");
 const config_1 = require("./config");
 const http_adapter_1 = require("./utils/http-adapter");
+const mcp_dynamic_service_1 = require("./mcp-dynamic.service");
 const publicGuard = { canActivate: () => Promise.resolve(true) };
 let McpModule = McpModule_1 = class McpModule {
     static forRoot(metadata = {}) {
@@ -37,12 +38,13 @@ let McpModule = McpModule_1 = class McpModule {
             providers: [
                 mcp_service_1.McpService,
                 mcp_explorer_1.McpExplorer,
+                mcp_dynamic_service_1.McpDynamicService,
                 configProviver,
                 guardProvider,
                 ...(metadata.guard ? [metadata.guard] : []),
                 ...(metadata.providers || []),
             ],
-            exports: [mcp_service_1.McpService, ...(metadata.exports || [])],
+            exports: [mcp_dynamic_service_1.McpDynamicService, ...(metadata.exports || [])],
             controllers: [mcp_controller_1.McpController],
         };
     }

package/dist/mcp-server/mcp.service.js

@@ -19,6 +19,8 @@ const run_guards_1 = require("./utils/run-guards");
 const core_1 = require("@nestjs/core");
 const run_interceptors_1 = require("./utils/run-interceptors");
 const rxjs_1 = require("rxjs");
+const run_fillters_1 = require("./utils/run-fillters");
+const exceptions_1 = require("./exceptions");
 let McpService = class McpService {
     moduleRef;
     tools = new Map();
@@ -87,77 +89,89 @@ let McpService = class McpService {
     }
     async executePrompt(name, payload, context) {
         if (!this.prompts.has(name)) {
-            throw new common_1.NotFoundException("Not found prompt");
-        }
-        const { instance: prompt, metatype } = this.prompts.get(name) || {};
-        if (!prompt || !metatype) {
-            throw new common_1.NotFoundException(`Unknown prompt: "${name}"`);
-        }
-        await (0, run_guards_1.runGuards)(this.moduleRef, metatype, context);
-        // Валидация через AJV, если есть inputSchema
-        if (prompt.inputSchema) {
-            const zodSchema = (0, zod_1.zodToJsonSchema)(prompt.inputSchema);
-            const validate = this.ajv.compile(zodSchema);
-            const valid = validate(payload);
-            if (!valid) {
-                throw new common_1.NotFoundException("Invalid prompt arguments");
-            }
+            throw new exceptions_1.McpNotFoundException("Not found prompt");
         }
+        const { instance: prompt, metatype } = this.prompts.get(name);
         try {
+            await (0, run_guards_1.runGuards)(this.moduleRef, metatype, context);
+            // Валидация через AJV, если есть inputSchema
+            if (prompt.inputSchema) {
+                const zodSchema = (0, zod_1.zodToJsonSchema)(prompt.inputSchema);
+                const validate = this.ajv.compile(zodSchema);
+                const valid = validate(payload);
+                if (!valid) {
+                    throw new exceptions_1.McpBadRequestException("Invalid prompt arguments");
+                }
+            }
             // const result = await prompt.execute(payload);
-            const result = await (0, run_interceptors_1.runInterceptors)(this.moduleRef, metatype, context, () => {
+            const stream = await (0, run_interceptors_1.runInterceptors)(this.moduleRef, metatype, context, () => {
                 return (0, rxjs_1.from)(prompt.execute(payload));
             });
-            return result;
+            return stream.pipe((0, rxjs_1.catchError)((err) => (0, rxjs_1.from)((0, run_fillters_1.runFilters)(this.moduleRef, metatype, err, context))));
         }
         catch (err) {
-            throw new common_1.InternalServerErrorException("Failed to execute prompt");
+            const result = await (0, run_fillters_1.runFilters)(this.moduleRef, metatype, err, context);
+            if (result) {
+                return (0, rxjs_1.of)(result);
+            }
+            // Пробрасываем дальше, чтобы Observable корректно завершился
+            return (0, rxjs_1.throwError)(() => err);
         }
     }
     /**
      * Отправить сообщение в MCP "сервер"
      */
     async executeTool(msg, context) {
-        const { instance: tool, metatype } = this.tools.get(msg.type) || {};
-        if (!tool || !metatype) {
-            throw new common_1.NotFoundException(`Unknown tool: "${msg.type}"`);
-        }
-        await (0, run_guards_1.runGuards)(this.moduleRef, metatype, context);
-        // Валидация через AJV, если есть inputSchema
-        if (tool.inputSchema) {
-            const zodSchema = (0, zod_1.zodToJsonSchema)(tool.inputSchema);
-            const validate = this.ajv.compile(zodSchema);
-            const valid = validate(msg.payload);
-            if (!valid) {
-                throw new common_1.BadRequestException(this.ajv.errorsText(validate.errors));
-            }
+        if (!this.tools.has(msg.type)) {
+            throw new exceptions_1.McpNotFoundException("Not found tool");
         }
+        const { instance: tool, metatype } = this.tools.get(msg.type);
         try {
+            await (0, run_guards_1.runGuards)(this.moduleRef, metatype, context);
+            // Валидация через AJV, если есть inputSchema
+            if (tool.inputSchema) {
+                const zodSchema = (0, zod_1.zodToJsonSchema)(tool.inputSchema);
+                const validate = this.ajv.compile(zodSchema);
+                const valid = validate(msg.payload);
+                if (!valid) {
+                    throw new exceptions_1.McpBadRequestException(this.ajv.errorsText(validate.errors));
+                }
+            }
             // const result = await tool.execute(msg.payload);
-            const result = await (0, run_interceptors_1.runInterceptors)(this.moduleRef, metatype, context, () => {
+            const stream = await (0, run_interceptors_1.runInterceptors)(this.moduleRef, metatype, context, () => {
                 return (0, rxjs_1.from)(tool.execute(msg.payload));
             });
-            return result;
+            return stream.pipe((0, rxjs_1.catchError)((err) => (0, rxjs_1.from)((0, run_fillters_1.runFilters)(this.moduleRef, metatype, err, context))));
         }
         catch (err) {
-            throw new common_1.InternalServerErrorException("Failed to execute tool");
+            const result = await (0, run_fillters_1.runFilters)(this.moduleRef, metatype, err, context);
+            if (result) {
+                return (0, rxjs_1.of)(result);
+            }
+            // Пробрасываем дальше, чтобы Observable корректно завершился
+            return (0, rxjs_1.throwError)(() => err);
         }
     }
     async executeResource(name, uri, vars, context) {
-        const { instance: resource, metatype } = this.resources.get(name) || {};
-        if (!resource || !metatype) {
-            throw new common_1.NotFoundException(`Unknown resource: "${name}"`);
+        if (!this.resources.has(name)) {
+            throw new exceptions_1.McpNotFoundException("Not found prompt");
         }
-        await (0, run_guards_1.runGuards)(this.moduleRef, metatype, context);
+        const { instance: resource, metatype } = this.resources.get(name);
         try {
+            await (0, run_guards_1.runGuards)(this.moduleRef, metatype, context);
             // const result = await resource.execute(uri, vars);
-            const result = await (0, run_interceptors_1.runInterceptors)(this.moduleRef, metatype, context, () => {
+            const stream = await (0, run_interceptors_1.runInterceptors)(this.moduleRef, metatype, context, () => {
                 return (0, rxjs_1.from)(resource.execute(uri, vars));
             });
-            return result;
+            return stream.pipe((0, rxjs_1.catchError)((err) => (0, rxjs_1.from)((0, run_fillters_1.runFilters)(this.moduleRef, metatype, err, context))));
         }
         catch (err) {
-            throw new common_1.InternalServerErrorException("Failed to execute tool");
+            const result = await (0, run_fillters_1.runFilters)(this.moduleRef, metatype, err, context);
+            if (result) {
+                return (0, rxjs_1.of)(result);
+            }
+            // Пробрасываем дальше, чтобы Observable корректно завершился
+            return (0, rxjs_1.throwError)(() => err);
         }
     }
     createServer(context) {
@@ -181,8 +195,9 @@ let McpService = class McpService {
                     };
                 }
                 catch (e) {
-                    console.error(e);
-                    throw new Error(`Faild to execute tool ${tool.name}`);
+                    throw new exceptions_1.McpInternalServerErrorException(`Faild to execute tool ${tool.name}`, {
+                        cause: e,
+                    });
                 }
             });
         }
@@ -208,7 +223,9 @@ let McpService = class McpService {
                     return { messages: messages };
                 }
                 catch (e) {
-                    throw new Error(`Faild to execute tool ${prompt.name}`);
+                    throw new exceptions_1.McpInternalServerErrorException(`Faild to execute tool ${prompt.name}`, {
+                        cause: e,
+                    });
                 }
             });
         }
@@ -233,7 +250,9 @@ let McpService = class McpService {
                     return { contents: result };
                 }
                 catch (e) {
-                    throw new Error(`Faild to execute tool ${prompt.name}`);
+                    throw new exceptions_1.McpInternalServerErrorException(`Faild to execute tool ${prompt.name}`, {
+                        cause: e,
+                    });
                 }
             });
         }

package/dist/mcp-server/utils/run-fillters.d.ts

@@ -0,0 +1,3 @@
+import { ArgumentsHost } from "@nestjs/common";
+import { ModuleRef } from "@nestjs/core";
+export declare function runFilters(moduleRef: ModuleRef, metatype: Function, exception: unknown, host: ArgumentsHost): Promise<any>;

package/dist/mcp-server/utils/run-fillters.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runFilters = runFilters;
+const constants_1 = require("@nestjs/common/constants");
+async function runFilters(moduleRef, metatype, exception, host) {
+    const resolveFilter = async (Filter) => {
+        if (typeof Filter !== "function") {
+            return Filter;
+        }
+        try {
+            return moduleRef.get(Filter, { strict: false });
+        }
+        catch {
+            try {
+                return await moduleRef.create(Filter);
+            }
+            catch {
+                return new Filter();
+            }
+        }
+    };
+    const filters = Reflect.getMetadata(constants_1.EXCEPTION_FILTERS_METADATA, metatype) || [];
+    for (const Filter of filters) {
+        const filterInstance = await resolveFilter(Filter);
+        const filterExceptions = (Reflect.getMetadata(constants_1.FILTER_CATCH_EXCEPTIONS, Filter) || []);
+        if (!filterExceptions ||
+            !filterExceptions.some((ex) => exception instanceof ex)) {
+            continue;
+        }
+        // ВАЖНО: filter сам обрабатывает exception
+        const result = await filterInstance.catch(exception, host);
+        // Nest прекращает выполнение после первого подходящего filter
+        return result;
+    }
+    // если фильтров нет — пробрасываем ошибку дальше
+    throw exception;
+}

package/dist/mcp-server/utils/run-guards.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runGuards = runGuards;
-const common_1 = require("@nestjs/common");
 const constants_1 = require("@nestjs/common/constants");
+const exceptions_1 = require("../exceptions");
 /**
  * Универсальный helper для проверки массивов NestJS Guards
  */
@@ -28,7 +28,7 @@ async function runGuards(moduleRef, metatype, context) {
         const guardInstance = await resolveGuard(Guard);
         const can = await guardInstance.canActivate(context);
         if (!can) {
-            throw new common_1.UnauthorizedException("Guard blocked execution");
+            throw new exceptions_1.McpUnauthorizedException("Guard blocked execution");
         }
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@muzikanto/nestjs-mcp",
-  "version": "1.3.0",
+  "version": "1.5.1",
   "description": "NestJS MCP (Model Context Protocol) module for creating tools for LLM or HTTP with validation, decorators, and OpenAI Function Calls integration.",
   "keywords": [
     "nestjs",
@@ -20,7 +20,7 @@
     "build": "tsc",
     "prepublishOnly": "npm run build",
     "lint": "prettier --check 'src/**/*.ts'",
-    "format": "prettier --write 'src/**/*.ts'",
+    "format": "prettier --write 'src/**/*.ts' 'example/**/*.ts' 'README.md'",
     "ch": "changeset",
     "vers": "changeset version",
     "pub": "changeset publish"