@muzikanto/nestjs-mcp 1.2.0 → 1.3.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @muzikanto/nestjs-mcp
 
+## 1.3.0
+
+### Minor Changes
+
+- a5c79ec: add guards and interceptors
+
 ## 1.2.0
 
 ### Minor Changes

package/README.md

@@ -36,6 +36,7 @@ NestJS MCP (Model Context Protocol) module — allows you to create “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)  
+- Support http adapters (default fastify)
 - Full TypeScript typing  
 
 ---
@@ -46,7 +47,7 @@ NestJS MCP (Model Context Protocol) module — allows you to create “tools”,
 yarn add @muzikanto/nestjs-mcp
 ```
 
-Peer dependencies: `@nestjs/common, @nestjs/core, reflect-metadata`
+Peer dependencies: `@nestjs/common, @nestjs/core, @nestjs/swagger, reflect-metadata`
 
 ## Usage
 
@@ -280,27 +281,32 @@ export class TestResource implements IMcpResource<{ userId: string }> {
 
 ### Auth guard
 ```ts
-import { McpModule } from '@muzikanto/nestjs-mcp';
-import { Module, CanActivate, ExecutionContext, Injectable } from "@nestjs/common";
+import { IMcpTool, McpTool } from '@muzikanto/nestjs-mcp';
+import { UseGuards } from '@nestjs/common';
+import { CanActivate, ExecutionContext, Injectable } from '@nestjs/common';
+import { Observable } from 'rxjs';
 
 @Injectable()
-export class TestGuard implements CanActivate {
-    canActivate(context: ExecutionContext): Promise<boolean> {
-      const request = context.switchToHttp().getRequest();
-      const authHeader = request.headers['authorization'];
-    
-      return true;
-    }
+class TestGuard implements CanActivate {
+  canActivate(context: ExecutionContext): boolean | Promise<boolean> | Observable<boolean> {
+    console.log('TestGuard called');
+    return true;
+  }
 }
 
-@Module({
-  imports: [
-    McpModule.forRoot({
-      guard: TestGuard
-    }),
-  ],
-})
-export class AppModule {}
+@UseGuard(TestGuard)
+@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);
+    return { success: true };
+  }
+}
 ```
 
 ### Integration with OpenAI Function Calls

package/dist/mcp-server/config.d.ts

@@ -0,0 +1,6 @@
+import { IHttpAdapter } from "./utils/http-adapter";
+export declare const MCP_CONFIG_TOKEN = "mcl:config-token";
+export type IMcpConfig = {
+    httpAdapter: IHttpAdapter;
+};
+export declare const InjectMcpConfig: () => PropertyDecorator & ParameterDecorator;

package/dist/mcp-server/config.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InjectMcpConfig = exports.MCP_CONFIG_TOKEN = void 0;
+const common_1 = require("@nestjs/common");
+exports.MCP_CONFIG_TOKEN = "mcl:config-token";
+const InjectMcpConfig = () => (0, common_1.Inject)(exports.MCP_CONFIG_TOKEN);
+exports.InjectMcpConfig = InjectMcpConfig;

package/dist/mcp-server/decorators/mcp-tool.decorator.d.ts

@@ -2,19 +2,16 @@ import "reflect-metadata";
 import type * as z3 from "zod/v3";
 type AnySchema = z3.ZodTypeAny;
 type ZodRawShapeCompat = Record<string, AnySchema>;
-export type IMcpToolContext = {
-    request: any;
-};
 export interface IMcpTool<Payload = any, Result = any> {
     name: string;
     title?: string;
     description?: string;
     inputSchema?: ZodRawShapeCompat;
-    execute(input: Payload, context: IMcpToolContext): Promise<Result>;
+    execute(input: Payload): Promise<Result>;
 }
 export declare const MCP_TOOL_METADATA = "mcp:tool-class";
 /**
  * Декоратор класса для MCP тулзы
  */
-export declare const McpTool: () => (target: any) => void;
+export declare const McpTool: () => ClassDecorator;
 export {};

package/dist/mcp-server/mcp.controller.d.ts

@@ -4,22 +4,15 @@ import { McpMessageDto } from "./dto/McpMessage.dto";
 import { McpToolsDto } from "./dto/McpTools.dto";
 import { McpPromptsDto } from "./dto/McpPrompts.dto";
 import { McpPromptMessagesDto } from "./dto/McpPromptMessages.dto";
-import { IRequest, IResponse } from "./utils/http";
+import { IMcpConfig } from "./config";
 export declare class McpController {
     private readonly service;
     private readonly guard;
-    constructor(service: McpService, guard: CanActivate);
-    handleSse(req: IRequest, res: IResponse): Promise<void>;
-    handleSseMessages(req: IRequest, res: IResponse): Promise<void>;
-    handleTool(body: McpMessageDto, request: any, context: ExecutionContext): Promise<{
-        success: boolean;
-        data: any;
-        error?: undefined;
-    } | {
-        success: boolean;
-        error: any;
-        data?: undefined;
-    }>;
+    private readonly config;
+    constructor(service: McpService, guard: CanActivate, config: IMcpConfig);
+    handleSse(rawReq: any, rawRes: any, context: ExecutionContext): Promise<void>;
+    handleSseMessages(rawReq: any, rawRes: any, context: ExecutionContext): Promise<void>;
+    handleTool(body: McpMessageDto, request: any, context: ExecutionContext): Promise<any>;
     getTools(context: ExecutionContext): Promise<McpToolsDto>;
     getPrompts(context: ExecutionContext): Promise<McpPromptsDto>;
     getPrompt(name: string, body: object, context: ExecutionContext): Promise<McpPromptMessagesDto>;

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

@@ -22,22 +22,34 @@ const McpPrompts_dto_1 = require("./dto/McpPrompts.dto");
 const McpPromptMessages_dto_1 = require("./dto/McpPromptMessages.dto");
 const context_decorator_1 = require("./utils/context.decorator");
 const inject_tokens_1 = require("./utils/inject-tokens");
+const config_1 = require("./config");
+const rxjs_1 = require("rxjs");
 let McpController = class McpController {
     service;
     guard;
-    constructor(service, guard) {
+    config;
+    constructor(service, guard, config) {
         this.service = service;
         this.guard = guard;
+        this.config = config;
     }
-    async handleSse(req, res) {
-        await this.service.handleSse(req, res);
+    async handleSse(rawReq, rawRes, context) {
+        await this.checkGuard(context);
+        const request = this.config.httpAdapter.getRequest(rawReq);
+        const response = this.config.httpAdapter.getResponse(rawRes);
+        await this.service.handleSse(request, response, context);
     }
-    async handleSseMessages(req, res) {
-        await this.service.handleSseMessage(req, res);
+    async handleSseMessages(rawReq, rawRes, context) {
+        await this.checkGuard(context);
+        const request = this.config.httpAdapter.getRequest(rawReq);
+        const response = this.config.httpAdapter.getResponse(rawRes);
+        await this.service.handleSseMessage(request, response);
     }
     async handleTool(body, request, context) {
         await this.checkGuard(context);
-        return this.service.sendMessage(body, { request });
+        const observable = await this.service.executeTool(body, context);
+        const result = await (0, rxjs_1.firstValueFrom)(observable);
+        return result;
     }
     async getTools(context) {
         await this.checkGuard(context);
@@ -51,7 +63,8 @@ let McpController = class McpController {
     }
     async getPrompt(name, body, context) {
         await this.checkGuard(context);
-        const messages = await this.service.getPrompt(name, body);
+        const observable = await this.service.executePrompt(name, body, context);
+        const messages = await (0, rxjs_1.firstValueFrom)(observable);
         return {
             messages,
         };
@@ -70,8 +83,9 @@ __decorate([
     }),
     __param(0, (0, common_1.Req)()),
     __param(1, (0, common_1.Res)()),
+    __param(2, (0, context_decorator_1.Context)()),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:paramtypes", [Object, Object, Object]),
     __metadata("design:returntype", Promise)
 ], McpController.prototype, "handleSse", null);
 __decorate([
@@ -81,8 +95,9 @@ __decorate([
     }),
     __param(0, (0, common_1.Req)()),
     __param(1, (0, common_1.Res)()),
+    __param(2, (0, context_decorator_1.Context)()),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:paramtypes", [Object, Object, Object]),
     __metadata("design:returntype", Promise)
 ], McpController.prototype, "handleSseMessages", null);
 __decorate([
@@ -177,5 +192,6 @@ __decorate([
 exports.McpController = McpController = __decorate([
     (0, common_1.Controller)("mcp"),
     __param(1, (0, common_1.Inject)(inject_tokens_1.MCP_GUARD)),
-    __metadata("design:paramtypes", [mcp_service_1.McpService, Object])
+    __param(2, (0, config_1.InjectMcpConfig)()),
+    __metadata("design:paramtypes", [mcp_service_1.McpService, Object, Object])
 ], McpController);

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

@@ -35,7 +35,7 @@ let McpExplorer = class McpExplorer {
             if (typeof instance.execute !== "function") {
                 throw new Error(`MCP Tool ${instance.name} must implement IMcpTool with execute() method`);
             }
-            this.mcpService.registerTool(instance.name, instance);
+            this.mcpService.registerTool(instance.name, { instance, metatype });
         });
         providers.forEach(({ instance, metatype }) => {
             if (!instance || !metatype)
@@ -47,7 +47,7 @@ let McpExplorer = class McpExplorer {
             if (typeof instance.execute !== "function") {
                 throw new Error(`MCP Prompt ${instance.name} must implement IMcpPrompt with execute() method`);
             }
-            this.mcpService.registerPrompt(instance.name, instance);
+            this.mcpService.registerPrompt(instance.name, { instance, metatype });
         });
         providers.forEach(({ instance, metatype }) => {
             if (!instance || !metatype)
@@ -59,7 +59,7 @@ let McpExplorer = class McpExplorer {
             if (typeof instance.execute !== "function") {
                 throw new Error(`MCP Resource ${instance.name} must implement IMcpResource with execute() method`);
             }
-            this.mcpService.registerResource(instance.name, instance);
+            this.mcpService.registerResource(instance.name, { instance, metatype });
         });
     }
 };

package/dist/mcp-server/mcp.module.d.ts

@@ -1,6 +1,10 @@
 import { CanActivate, DynamicModule, ModuleMetadata, Provider } from "@nestjs/common";
+import { IHttpAdapter } from "./utils/http-adapter";
 type Metadata = Pick<ModuleMetadata, "providers" | "imports" | "exports"> & {
     guard?: Provider<CanActivate>;
+    name?: string;
+    version?: string;
+    httpAdapter?: IHttpAdapter;
 };
 export declare class McpModule {
     static forRoot(metadata?: Metadata): DynamicModule;

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

@@ -14,9 +14,17 @@ const mcp_service_1 = require("./mcp.service");
 const mcp_explorer_1 = require("./mcp.explorer");
 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 publicGuard = { canActivate: () => Promise.resolve(true) };
 let McpModule = McpModule_1 = class McpModule {
     static forRoot(metadata = {}) {
+        const configProviver = {
+            provide: config_1.MCP_CONFIG_TOKEN,
+            useValue: {
+                httpAdapter: metadata.httpAdapter || http_adapter_1.DEFAULT_FASTIFY_ADAPTER,
+            },
+        };
         const guardProvider = metadata.guard
             ? { provide: inject_tokens_1.MCP_GUARD, useExisting: metadata.guard }
             : {
@@ -29,6 +37,7 @@ let McpModule = McpModule_1 = class McpModule {
             providers: [
                 mcp_service_1.McpService,
                 mcp_explorer_1.McpExplorer,
+                configProviver,
                 guardProvider,
                 ...(metadata.guard ? [metadata.guard] : []),
                 ...(metadata.providers || []),

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

@@ -1,8 +1,9 @@
-import { OnModuleInit } from "@nestjs/common";
-import { IMcpTool, IMcpToolContext } from "./decorators/mcp-tool.decorator";
+import { ExecutionContext, OnModuleInit } from "@nestjs/common";
+import { IMcpTool } from "./decorators/mcp-tool.decorator";
 import { IMcpPrompt } from "./decorators/mcp-prompt.decorator";
-import { IRequest, IResponse } from "./utils/http";
+import { IRequest, IResponse } from "./utils/http-adapter";
 import { IMcpResource } from "./decorators/mcp-resource.decorator";
+import { ModuleRef } from "@nestjs/core";
 export interface McpMessage {
     type: string;
     payload: any;
@@ -13,13 +14,15 @@ export interface McpResponse {
     error?: string;
 }
 export declare class McpService implements OnModuleInit {
+    protected readonly moduleRef: ModuleRef;
     private tools;
     private prompts;
     private resources;
     private ajv;
     private sessions;
+    constructor(moduleRef: ModuleRef);
     onModuleInit(): void;
-    handleSse(req: IRequest, res: IResponse): Promise<void>;
+    handleSse(_: IRequest, res: IResponse, context: ExecutionContext): Promise<void>;
     handleSseMessage(req: IRequest, res: IResponse): Promise<void>;
     /**
      * Возвращает список зарегистрированных тулз
@@ -36,24 +39,26 @@ export declare class McpService implements OnModuleInit {
         title: string | undefined;
         inputSchema: any;
     }[];
-    registerTool(name: string, handler: IMcpTool): void;
-    registerPrompt(name: string, handler: IMcpPrompt): void;
-    registerResource(name: string, handler: IMcpResource): void;
-    getPrompt(name: string, payload: object): Promise<import("./decorators/mcp-prompt.decorator").IMcpPromptMessage[]>;
+    registerTool(name: string, handler: {
+        instance: IMcpTool;
+        metatype: Function;
+    }): void;
+    registerPrompt(name: string, handler: {
+        instance: IMcpPrompt;
+        metatype: Function;
+    }): void;
+    registerResource(name: string, handler: {
+        instance: IMcpResource;
+        metatype: Function;
+    }): void;
+    executePrompt(name: string, payload: object, context: ExecutionContext): Promise<import("rxjs").Observable<any>>;
     /**
      * Отправить сообщение в MCP "сервер"
      */
-    sendMessage(msg: {
+    executeTool(msg: {
         type: string;
         payload: any;
-    }, context: IMcpToolContext): Promise<{
-        success: boolean;
-        data: any;
-        error?: undefined;
-    } | {
-        success: boolean;
-        error: any;
-        data?: undefined;
-    }>;
+    }, context: ExecutionContext): Promise<import("rxjs").Observable<any>>;
+    executeResource(name: string, uri: URL, vars: Record<string, any>, context: ExecutionContext): Promise<import("rxjs").Observable<any>>;
     private createServer;
 }

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

@@ -5,6 +5,9 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     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.McpService = void 0;
 const common_1 = require("@nestjs/common");
@@ -12,45 +15,53 @@ const ajv_1 = require("ajv");
 const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
 const sse_js_1 = require("@modelcontextprotocol/sdk/server/sse.js");
 const zod_1 = require("./utils/zod");
+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");
 let McpService = class McpService {
+    moduleRef;
     tools = new Map();
     prompts = new Map();
     resources = new Map();
     ajv = new ajv_1.default();
     sessions = new Map();
+    constructor(moduleRef) {
+        this.moduleRef = moduleRef;
+    }
     onModuleInit() {
         // console.log('MCP Service initialized');
     }
-    async handleSse(req, res) {
+    async handleSse(_, res, context) {
         try {
-            const transport = new sse_js_1.SSEServerTransport("/api/mcp/messages", res.raw || res);
+            const transport = new sse_js_1.SSEServerTransport("/api/mcp/messages", res.original);
             const sessionId = transport.sessionId;
             this.sessions.set(sessionId, transport);
-            res.raw.on("close", () => {
+            res.original.on("close", () => {
                 this.sessions.delete(sessionId);
             });
-            const server = this.createServer();
+            const server = this.createServer(context);
             await server.connect(transport);
         }
         catch (e) {
-            res.status(500).send("Failed to initialize session");
+            res.send(500, "Failed to initialize session");
         }
     }
     async handleSseMessage(req, res) {
         const sessionId = req.query.sessionId;
         const transport = this.sessions.get(sessionId);
         if (transport) {
-            await transport.handlePostMessage(req.raw || req, res.raw || res, req.body);
+            await transport.handlePostMessage(req.original, res.original, req.body);
         }
         else {
-            res.status(500).send("Failed to handle message");
+            res.send(500, "Failed to handle message");
         }
     }
     /**
      * Возвращает список зарегистрированных тулз
      */
     listTools() {
-        return Array.from(this.tools.values()).map((t) => ({
+        return Array.from(this.tools.values()).map(({ instance: t }) => ({
             name: t.name,
             title: t.title,
             description: t.description,
@@ -58,7 +69,7 @@ let McpService = class McpService {
         }));
     }
     listPrompts() {
-        return Array.from(this.prompts.values()).map((t) => ({
+        return Array.from(this.prompts.values()).map(({ instance: t }) => ({
             name: t.name,
             description: t.description,
             title: t.title,
@@ -74,11 +85,15 @@ let McpService = class McpService {
     registerResource(name, handler) {
         this.resources.set(name, handler);
     }
-    getPrompt(name, payload) {
+    async executePrompt(name, payload, context) {
         if (!this.prompts.has(name)) {
             throw new common_1.NotFoundException("Not found prompt");
         }
-        const prompt = this.prompts.get(name);
+        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);
@@ -88,43 +103,77 @@ let McpService = class McpService {
                 throw new common_1.NotFoundException("Invalid prompt arguments");
             }
         }
-        return prompt.execute(payload);
+        try {
+            // const result = await prompt.execute(payload);
+            const result = await (0, run_interceptors_1.runInterceptors)(this.moduleRef, metatype, context, () => {
+                return (0, rxjs_1.from)(prompt.execute(payload));
+            });
+            return result;
+        }
+        catch (err) {
+            throw new common_1.InternalServerErrorException("Failed to execute prompt");
+        }
     }
     /**
      * Отправить сообщение в MCP "сервер"
      */
-    async sendMessage(msg, context) {
-        const tool = this.tools.get(msg.type);
-        if (!tool) {
-            return { success: false, error: `Unknown tool: "${msg.type}"` };
+    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) {
-                return { success: false, error: this.ajv.errorsText(validate.errors) };
+                throw new common_1.BadRequestException(this.ajv.errorsText(validate.errors));
             }
         }
         try {
-            const result = await tool.execute(msg.payload, context);
-            return { success: true, data: result };
+            // const result = await tool.execute(msg.payload);
+            const result = await (0, run_interceptors_1.runInterceptors)(this.moduleRef, metatype, context, () => {
+                return (0, rxjs_1.from)(tool.execute(msg.payload));
+            });
+            return result;
+        }
+        catch (err) {
+            throw new common_1.InternalServerErrorException("Failed to execute tool");
+        }
+    }
+    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}"`);
+        }
+        await (0, run_guards_1.runGuards)(this.moduleRef, metatype, context);
+        try {
+            // const result = await resource.execute(uri, vars);
+            const result = await (0, run_interceptors_1.runInterceptors)(this.moduleRef, metatype, context, () => {
+                return (0, rxjs_1.from)(resource.execute(uri, vars));
+            });
+            return result;
         }
         catch (err) {
-            return { success: false, error: err.message };
+            throw new common_1.InternalServerErrorException("Failed to execute tool");
         }
     }
-    createServer() {
+    createServer(context) {
         const server = new mcp_js_1.McpServer({ version: "1", name: "test" }, {});
-        for (const [toolName, tool] of this.tools.entries()) {
+        for (const [toolName, { instance: tool }] of this.tools.entries()) {
             server.registerTool(tool.name, {
                 title: tool.title,
                 description: tool.description,
                 inputSchema: tool.inputSchema,
-            }, async (params) => {
+            }, async (payload) => {
                 try {
-                    const result = await tool.execute({ ...params }, { request: undefined });
+                    // const result = await tool.execute(
+                    //   { ...payload },
+                    // );
+                    const observable = await this.executeTool({ type: tool.name, payload }, context);
+                    const result = await (0, rxjs_1.firstValueFrom)(observable);
                     return {
                         content: [
                             { text: JSON.stringify(result), type: "text" },
@@ -137,15 +186,17 @@ let McpService = class McpService {
                 }
             });
         }
-        for (const [promptName, prompt] of this.prompts.entries()) {
+        for (const [promptName, { instance: prompt }] of this.prompts.entries()) {
             server.registerPrompt(prompt.name, {
                 title: prompt.title,
                 description: prompt.description,
                 argsSchema: prompt.inputSchema,
-            }, async (params) => {
+            }, async (payload) => {
                 try {
-                    const openaiMessage = await prompt.execute({ ...params });
-                    const messages = openaiMessage.map((el) => ({
+                    // const result = await prompt.execute({ ...params });
+                    const observable = await this.executePrompt(prompt.name, payload, context);
+                    const result = await (0, rxjs_1.firstValueFrom)(observable);
+                    const messages = result.map((el) => ({
                         role: (el.role === "system" ? "assistant" : el.role),
                         content: el.tool_call
                             ? {
@@ -161,7 +212,7 @@ let McpService = class McpService {
                 }
             });
         }
-        for (const [_, resource] of this.resources.entries()) {
+        for (const [_, { instance: resource }] of this.resources.entries()) {
             const resourceList = resource.list;
             server.registerResource(resource.name, new mcp_js_1.ResourceTemplate(resource.uri, {
                 list: resourceList
@@ -176,8 +227,10 @@ let McpService = class McpService {
                 description: resource.description,
             }, async (url, variables) => {
                 try {
-                    const resources = await resource.execute(url, variables);
-                    return { contents: resources };
+                    // const resources = await resource.execute(url, variables);
+                    const observable = await this.executeResource(resource.name, url, variables, context);
+                    const result = await (0, rxjs_1.firstValueFrom)(observable);
+                    return { contents: result };
                 }
                 catch (e) {
                     throw new Error(`Faild to execute tool ${prompt.name}`);
@@ -189,5 +242,6 @@ let McpService = class McpService {
 };
 exports.McpService = McpService;
 exports.McpService = McpService = __decorate([
-    (0, common_1.Injectable)()
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [core_1.ModuleRef])
 ], McpService);

package/dist/mcp-server/utils/http-adapter.d.ts

@@ -0,0 +1,18 @@
+import { AuthInfo } from "@modelcontextprotocol/sdk/server/auth/types";
+import { IncomingMessage, ServerResponse } from "http";
+export type IRequest = {
+    original: IncomingMessage & {
+        auth?: AuthInfo;
+    };
+    query?: object;
+    body?: object;
+};
+export type IResponse = {
+    original: ServerResponse;
+    send: (statusCode: number, result: string) => void;
+};
+export type IHttpAdapter = {
+    getRequest: (req: any) => IRequest;
+    getResponse: (res: any) => IResponse;
+};
+export declare const DEFAULT_FASTIFY_ADAPTER: IHttpAdapter;

package/dist/mcp-server/utils/http-adapter.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_FASTIFY_ADAPTER = void 0;
+exports.DEFAULT_FASTIFY_ADAPTER = {
+    getRequest: (fastifyRequest) => {
+        return {
+            original: fastifyRequest.raw,
+            body: fastifyRequest.body,
+            query: fastifyRequest.query,
+        };
+    },
+    getResponse: (fastifyResponse) => {
+        return {
+            original: fastifyResponse.raw,
+            send: (code, result) => fastifyResponse.status(code).send(result),
+        };
+    },
+};

package/dist/mcp-server/utils/ref.d.ts

@@ -0,0 +1 @@
+export declare const MCP_MODULE_REF_METADATA = "mcp:module-ref";

package/dist/mcp-server/utils/ref.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MCP_MODULE_REF_METADATA = void 0;
+exports.MCP_MODULE_REF_METADATA = 'mcp:module-ref';

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

@@ -0,0 +1,6 @@
+import { ExecutionContext } from "@nestjs/common";
+import { ModuleRef } from "@nestjs/core";
+/**
+ * Универсальный helper для проверки массивов NestJS Guards
+ */
+export declare function runGuards(moduleRef: ModuleRef, metatype: Function, context: ExecutionContext): Promise<void>;

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

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runGuards = runGuards;
+const common_1 = require("@nestjs/common");
+const constants_1 = require("@nestjs/common/constants");
+/**
+ * Универсальный helper для проверки массивов NestJS Guards
+ */
+async function runGuards(moduleRef, metatype, context) {
+    const resolveGuard = async (Guard) => {
+        if (typeof Guard !== "function") {
+            return Guard;
+        }
+        try {
+            return moduleRef.get(Guard, { strict: false });
+        }
+        catch {
+            try {
+                return await moduleRef.create(Guard);
+            }
+            catch {
+                return new Guard();
+            }
+        }
+    };
+    const guards = Reflect.getMetadata(constants_1.GUARDS_METADATA, metatype) || [];
+    for (const Guard of guards) {
+        const guardInstance = await resolveGuard(Guard);
+        const can = await guardInstance.canActivate(context);
+        if (!can) {
+            throw new common_1.UnauthorizedException("Guard blocked execution");
+        }
+    }
+}

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

@@ -0,0 +1,11 @@
+import { ExecutionContext, NestInterceptor, Type } from '@nestjs/common';
+import { Observable } from 'rxjs';
+import 'reflect-metadata';
+/**
+ * Helper для запуска цепочки NestJS Interceptors полностью через Observable
+ */
+export declare function runInterceptorsObservable(interceptors: Type<NestInterceptor>[] | undefined, context: ExecutionContext, nextFn: () => any): Observable<any>;
+/**
+ * Декоратор класса, который оборачивает execute и запускает interceptors через Observable
+ */
+export declare function WithNestInterceptors(): ClassDecorator;

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

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runInterceptorsObservable = runInterceptorsObservable;
+exports.WithNestInterceptors = WithNestInterceptors;
+const rxjs_1 = require("rxjs");
+require("reflect-metadata");
+const constants_1 = require("@nestjs/common/constants");
+/**
+ * Helper для запуска цепочки NestJS Interceptors полностью через Observable
+ */
+function runInterceptorsObservable(interceptors = [], context, nextFn) {
+    let handler = nextFn;
+    // Применяем interceptors в обратном порядке
+    for (const InterceptorClass of interceptors.reverse()) {
+        const interceptorInstance = new InterceptorClass();
+        const originalHandler = handler;
+        // handler = функция, которая возвращает Observable
+        handler = () => {
+            const result = interceptorInstance.intercept(context, {
+                handle: () => (0, rxjs_1.of)(originalHandler()), // handle всегда Observable
+            });
+            return result;
+        };
+    }
+    // Возвращаем результат как Observable
+    return handler();
+}
+/**
+ * Декоратор класса, который оборачивает execute и запускает interceptors через Observable
+ */
+function WithNestInterceptors() {
+    return (target) => {
+        const originalExecute = target.prototype.execute;
+        if (originalExecute) {
+            target.prototype.execute = async function (input, context) {
+                const appliedInterceptors = Reflect.getMetadata(constants_1.INTERCEPTORS_METADATA, target) || [];
+                // Превращаем результат execute в Observable
+                const executeObservable = () => (originalExecute.call(this, input));
+                return runInterceptorsObservable(appliedInterceptors, context, executeObservable);
+            };
+        }
+    };
+}

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

@@ -0,0 +1,7 @@
+import { ExecutionContext } from "@nestjs/common";
+import { ModuleRef } from "@nestjs/core";
+import { Observable } from "rxjs";
+/**
+ * Универсальный helper для запуска массива NestJS Interceptors через DI
+ */
+export declare function runInterceptors(moduleRef: ModuleRef, metatype: Function, context: ExecutionContext, nextFn: () => Observable<any>): Promise<Observable<any>>;

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

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runInterceptors = runInterceptors;
+const rxjs_1 = require("rxjs");
+const constants_1 = require("@nestjs/common/constants");
+/**
+ * Универсальный helper для запуска массива NestJS Interceptors через DI
+ */
+async function runInterceptors(moduleRef, metatype, context, nextFn) {
+    const resolveInterceptor = async (Interceptor) => {
+        if (typeof Interceptor !== "function") {
+            return Interceptor;
+        }
+        try {
+            return moduleRef.get(Interceptor, { strict: false });
+        }
+        catch {
+            try {
+                return await moduleRef.create(Interceptor);
+            }
+            catch {
+                return new Interceptor();
+            }
+        }
+    };
+    const interceptors = Reflect.getMetadata(constants_1.INTERCEPTORS_METADATA, metatype) || [];
+    // Применяем interceptors в обратном порядке (как NestJS)
+    let handler = nextFn;
+    for (const InterceptorClass of interceptors.reverse()) {
+        const interceptorInstance = await resolveInterceptor(InterceptorClass);
+        const originalHandler = handler;
+        handler = () => {
+            const result = interceptorInstance.intercept(context, {
+                handle: () => originalHandler(),
+            });
+            return result instanceof rxjs_1.Observable ? result : (0, rxjs_1.from)(result);
+        };
+    }
+    return handler();
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@muzikanto/nestjs-mcp",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "NestJS MCP (Model Context Protocol) module for creating tools for LLM or HTTP with validation, decorators, and OpenAI Function Calls integration.",
   "keywords": [
     "nestjs",
@@ -35,6 +35,7 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.26.0",
     "ajv": "^8.18.0",
+    "rxjs": "^7.8.2",
     "zod": "^4.3.6",
     "zod-to-json-schema": "^3.25.1"
   },