@muzikanto/nestjs-mcp 1.6.0 → 1.7.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @muzikanto/nestjs-mcp
 
+## 1.7.0
+
+### Minor Changes
+
+- fix tool result format
+
 ## 1.6.0
 
 ### Minor Changes

package/README.md

@@ -85,7 +85,7 @@ export class AppModule {}
 ```ts
 import { IMcpTool, McpTool } from "@muzikanto/nestjs-mcp";
 import { Telegraf } from "telegraf";
-import z from "zod";
+import z from "zod/v3";
 
 const schema = {
   chatId: z.number().describe("Telegram chat id"), // строка с описанием
@@ -98,14 +98,16 @@ export class TelegramSendMessageTool implements IMcpTool<
   { success: boolean }
 > {
   name = "telegram.sendMessage";
-
   inputSchema = schema;
 
   constructor(private readonly bot: Telegraf) {}
 
   async execute(input: { chatId: string; text: string }) {
     await this.bot.telegram.sendMessage(input.chatId, input.text);
-    return { success: true };
+    return {
+      structuredContent: { success: true },
+      messages: [{ type: "text", text: "Success sent to user" }],
+    };
   }
 }
 ```
@@ -128,9 +130,10 @@ POST /mcp/tools
 
 ```json
 {
-  "data": {
+  "structuredContent": {
     "success": true
-  }
+  },
+  "messages": [{ "type": "text", "text": "Success sent to user" }]"
 }
 ```
 
@@ -167,7 +170,7 @@ GET /mcp/tools
 
 ```ts
 import { IMcpPrompt, McpPrompt } from "@muzikanto/nestjs-mcp";
-import z from "zod";
+import z from "zod/v3";
 
 const schema = {
   chatId: z.number().describe("Telegram chat id"), // строка с описанием
@@ -185,26 +188,28 @@ export class TelegramAutoReplyPrompt implements IMcpPrompt<{
   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.`,
-      },
-      {
-        role: "user",
-        content: text,
-      },
-      {
-        role: "assistant",
-        tool_call: {
-          name: "telegram.sendMessage",
-          arguments: {
-            chatId,
-            text: "{{model_output}}",
+    return {
+      messages: [
+        {
+          role: "system",
+          content: `You are a friendly Telegram bot. Reply briefly and to the point.`,
+        },
+        {
+          role: "user",
+          content: text,
+        },
+        {
+          role: "assistant",
+          tool_call: {
+            name: "telegram.sendMessage",
+            arguments: {
+              chatId,
+              text: "{{model_output}}",
+            },
           },
         },
-      },
-    ];
+      ],
+    };
   }
 }
 ```
@@ -349,7 +354,11 @@ export class McpDynamic {
     this.mcpDynamicService.registerTool({
       name: "dynamic_tool",
       title: "Dynamic tool",
-      execute: () => Promise.resolve("test"),
+      execute: () =>
+        Promise.resolve({
+          structuredContent: { text: "test" },
+          messages: [{ type: "text" as const, text: "test" }],
+        }),
       guards: [ExampleGuard],
       interceptors: [ExampleInterceptor],
     });
@@ -357,7 +366,8 @@ export class McpDynamic {
     this.mcpDynamicService.registerPrompt({
       name: "dynamic_prompt",
       title: "Dynamic prompt",
-      execute: () => Promise.resolve([{ role: "assistant", content: "test" }]),
+      execute: () =>
+        Promise.resolve({ messages: [{ role: "assistant", content: "test" }] }),
       guards: [ExampleGuard],
       interceptors: [ExampleInterceptor],
     });
@@ -370,6 +380,11 @@ export class McpDynamic {
         Promise.resolve([{ uri: uri.href, text: `ID: ${input.testId}` }]),
       guards: [ExampleGuard],
       interceptors: [ExampleInterceptor],
+      list: async () => {
+        return [
+          { uri: "dynamic://test/1", name: "dynamice_1", title: "Dynamic 1" },
+        ];
+      },
     });
   }
 }
@@ -405,7 +420,10 @@ export class TelegramSendMessageTool implements IMcpTool<
 
   async execute() {
     // await this.bot.telegram.sendMessage(input.chatId, input.text);
-    return { success: true };
+    return {
+      structuredContent: { success: true },
+      messages: { type: "text", text: "Success sent" },
+    };
   }
 }
 ```
@@ -473,7 +491,10 @@ export class TelegramSendMessageTool implements IMcpTool<
 
   async execute() {
     // await this.bot.telegram.sendMessage(input.chatId, input.text);
-    return { success: true };
+    return {
+      success: true,
+      messagse: [{ type: "text", text: "Success sent" }],
+    };
   }
 }
 ```
@@ -554,11 +575,12 @@ export class TelegramSendMessageTool implements IMcpTool<
 ### Integration with OpenAI Function Calls
 
 ```ts
-import axios from 'axios';
-import OpenAI from 'openai';
+import axios from "axios";
+import OpenAI from "openai";
 
-const MCP_TOOLS_URL = 'http://localhost:3000/mcp/tools';
-const MCP_TELEGRAM_PROMPT_URL = 'http://localhost:3000/mcp/prompts/telegram_auto_reply';
+const MCP_TOOLS_URL = "http://localhost:3000/mcp/tools";
+const MCP_TELEGRAM_PROMPT_URL =
+  "http://localhost:3000/mcp/prompts/telegram_auto_reply";
 
 // Create OpenAI client
 const client = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
@@ -568,7 +590,7 @@ const client = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
  */
 async function getMcpTools() {
   const response = await axios.get(MCP_TOOLS_URL);
-  return response.data.tools.map(el => ({
+  return response.data.tools.map((el) => ({
     name: el.name,
     description: el.description,
     parameters: el.inputSchema,
@@ -579,17 +601,17 @@ async function getMcpTools() {
  * Get all prompts
  */
 async function getMcpPrompt() {
-  const response = await axios.post(MCP_TELEGRAM_PROMPT_URL, {/* prompt generation arguments */});
+  const response = await axios.post(MCP_TELEGRAM_PROMPT_URL, {
+    /* prompt generation arguments */
+  });
   return response.data;
+}
 
 /**
  * Request mcp tool
  */
 async function callMcpTool(toolName: string, payload: Record<string, any>) {
-  const response = await axios.post(
-    MCP_TOOLS_URL,
-    { type: toolName, payload },
-  );
+  const response = await axios.post(MCP_TOOLS_URL, { type: toolName, payload });
   return response.data;
 }
 
@@ -601,10 +623,10 @@ async function callMcpTool(toolName: string, payload: Record<string, any>) {
   const promptResponse = await getMcpPrompt();
 
   const completion = await client.chat.completions.create({
-    model: 'gpt-4.1-mini',
+    model: "gpt-4.1-mini",
     messages: promptResponse.messages,
     functions: toolsResponse.tools,
-    function_call: 'auto',
+    function_call: "auto",
   });
 
   const message = completion.choices[0].message;
@@ -613,8 +635,8 @@ async function callMcpTool(toolName: string, payload: Record<string, any>) {
     const { name, arguments: argsJson } = message.function_call;
     const args = JSON.parse(argsJson);
 
-    const result = await callMcpTool(name, args);
-    console.log('Result from MCP tool:', result);
+    const { messages, structuredContent } = await callMcpTool(name, args);
+    console.log("Result from MCP tool:", messages, structuredContent);
   }
 })();
 ```

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

@@ -1,12 +1,12 @@
 import { HttpService } from "@nestjs/axios";
 import { McpToolsDto } from "../mcp-server/dto/McpTools.dto";
 import { McpPromptsDto } from "../mcp-server/dto/McpPrompts.dto";
-import { McpPromptMessagesDto } from "../mcp-server/dto/McpPromptMessages.dto";
+import { McpPromptResultDto } from "../mcp-server/dto/McpPrompResult.dto";
 export declare class McpClientService {
     private readonly httpService;
     constructor(httpService: HttpService);
     getAllTools(): Promise<McpToolsDto>;
     getAllPrompts(): Promise<McpPromptsDto>;
-    getPromptByName<Payload = any>(promptName: string, params: Payload): Promise<McpPromptMessagesDto>;
+    getPromptByName<Payload = any>(promptName: string, params: Payload): Promise<McpPromptResultDto>;
     callMcpTool<Payload = any, Result = any>(toolName: string, payload: Payload): Promise<Result>;
 }

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

@@ -3,20 +3,21 @@ import { McpService } from "../services/mcp.service";
 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 { McpPromptResultDto } from "../dto/McpPrompResult.dto";
 import { IMcpConfig } from "../config";
 import { McpResourcesDto } from "../dto/McpResources.dto";
 import { McpResourceItemsDto } from "../dto/McpResourceItems.dto";
 import { McpResourceRequestDto } from "../dto/McpResourceRequest.dto";
+import { McpToolResultDto } from "../dto/McpToolResult.dto";
 export declare class McpController {
     private readonly service;
     private readonly guard;
     private readonly config;
     constructor(service: McpService, guard: CanActivate, config: IMcpConfig);
-    handleTool(body: McpMessageDto, request: any, context: ExecutionContext): Promise<any>;
+    handleTool(body: McpMessageDto, request: any, context: ExecutionContext): Promise<McpToolResultDto>;
     getTools(context: ExecutionContext): Promise<McpToolsDto>;
     getPrompts(context: ExecutionContext): Promise<McpPromptsDto>;
-    getPrompt(name: string, body: object, context: ExecutionContext): Promise<McpPromptMessagesDto>;
+    getPrompt(name: string, body: object, context: ExecutionContext): Promise<McpPromptResultDto>;
     getResources(context: ExecutionContext): Promise<McpResourcesDto>;
     executeResource(name: string, body: McpResourceRequestDto, context: ExecutionContext): Promise<McpResourceItemsDto>;
     private checkGuard;

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

@@ -19,7 +19,7 @@ const McpMessage_dto_1 = require("../dto/McpMessage.dto");
 const swagger_1 = require("@nestjs/swagger");
 const McpTools_dto_1 = require("../dto/McpTools.dto");
 const McpPrompts_dto_1 = require("../dto/McpPrompts.dto");
-const McpPromptMessages_dto_1 = require("../dto/McpPromptMessages.dto");
+const McpPrompResult_dto_1 = require("../dto/McpPrompResult.dto");
 const context_decorator_1 = require("../utils/context.decorator");
 const inject_tokens_1 = require("../utils/inject-tokens");
 const config_1 = require("../config");
@@ -28,6 +28,7 @@ const McpResources_dto_1 = require("../dto/McpResources.dto");
 const McpResourceItems_dto_1 = require("../dto/McpResourceItems.dto");
 const McpResourceRequest_dto_1 = require("../dto/McpResourceRequest.dto");
 const uri_1 = require("../utils/uri");
+const McpToolResult_dto_1 = require("../dto/McpToolResult.dto");
 let McpController = class McpController {
     service;
     guard;
@@ -56,10 +57,8 @@ let McpController = class McpController {
     async getPrompt(name, body, context) {
         await this.checkGuard(context);
         const observable = await this.service.executePrompt(name, body, context);
-        const messages = await (0, rxjs_1.firstValueFrom)(observable);
-        return {
-            messages,
-        };
+        const result = await (0, rxjs_1.firstValueFrom)(observable);
+        return result;
     }
     async getResources(context) {
         await this.checkGuard(context);
@@ -91,6 +90,7 @@ __decorate([
         summary: "Request tool",
     }),
     (0, swagger_1.ApiResponse)({
+        type: McpToolResult_dto_1.McpToolResultDto,
         status: 200,
         description: "Tool execution result",
     }),
@@ -155,7 +155,7 @@ __decorate([
     (0, swagger_1.ApiResponse)({
         status: 200,
         description: "Prompt messages",
-        type: McpPromptMessages_dto_1.McpPromptMessagesDto,
+        type: McpPrompResult_dto_1.McpPromptResultDto,
     }),
     (0, swagger_1.ApiNotFoundResponse)({
         description: "Not found prompt",

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

@@ -2,7 +2,11 @@ import "reflect-metadata";
 import type * as z3 from "zod/v3";
 type AnySchema = z3.ZodTypeAny;
 type ZodRawShapeCompat = Record<string, AnySchema>;
-export type IMcpPromptMessage = {
+export type IMcpPromptResult = {
+    messages: IMcpPromptResultMessage[];
+    description?: string;
+};
+export type IMcpPromptResultMessage = {
     role: "user" | "assistant" | "system";
     content?: string;
     tool_call?: {
@@ -10,12 +14,12 @@ export type IMcpPromptMessage = {
         arguments: object;
     };
 };
-export interface IMcpPrompt<Payload = any, Result extends IMcpPromptMessage[] = IMcpPromptMessage[]> {
+export interface IMcpPrompt<Payload = any> {
     name: string;
     title?: string;
     description?: string;
     inputSchema?: ZodRawShapeCompat;
-    execute(input: Payload): Promise<Result>;
+    execute(input: Payload): Promise<IMcpPromptResult>;
 }
 export declare const MCP_PROMPT_METADATA = "mcp:prompt-class";
 /**

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

@@ -1,5 +1,5 @@
 import { RequestHandlerExtra } from "@modelcontextprotocol/sdk/shared/protocol";
-import { ServerNotification, ServerRequest } from "@modelcontextprotocol/sdk/types";
+import { Resource, ServerNotification, ServerRequest } from "@modelcontextprotocol/sdk/types";
 import "reflect-metadata";
 export type IMcpResourceResult = {
     uri: string;
@@ -16,6 +16,8 @@ export interface IMcpResource<Payload = any> {
     uri: string;
     title?: string;
     description?: string;
+    annotations?: Resource["annotations"];
+    _meta?: Resource["_meta"];
     execute(url: URL, input: Payload): Promise<IMcpResourceResult[]>;
     list?(extra: RequestHandlerExtra<ServerRequest, ServerNotification>): Promise<IMcpResourceListItem[]>;
 }

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

@@ -1,13 +1,25 @@
+import { ToolAnnotations } from "@modelcontextprotocol/sdk/types";
 import "reflect-metadata";
 import type * as z3 from "zod/v3";
 type AnySchema = z3.ZodTypeAny;
 type ZodRawShapeCompat = Record<string, AnySchema>;
-export interface IMcpTool<Payload = any, Result = any> {
+export type IMcpToolResult<Result extends Record<string, unknown>> = {
+    structuredContent?: Result;
+    messages: Array<{
+        type: "text";
+        text: string;
+    }>;
+    isError?: boolean;
+};
+export interface IMcpTool<Payload = any, Result extends Record<string, unknown> = Record<string, unknown>> {
     name: string;
     title?: string;
     description?: string;
     inputSchema?: ZodRawShapeCompat;
-    execute(input: Payload): Promise<Result>;
+    outputSchema?: ZodRawShapeCompat;
+    annotations?: ToolAnnotations;
+    _meta?: Record<string, unknown>;
+    execute(input: Payload): Promise<IMcpToolResult<Result>>;
 }
 export declare const MCP_TOOL_METADATA = "mcp:tool-class";
 /**

package/dist/mcp-server/dto/McpPrompResult.dto.d.ts

@@ -0,0 +1,5 @@
+import { McpPromptMessageDto } from "./McpPromptMessage.dto";
+export declare class McpPromptResultDto {
+    messages: McpPromptMessageDto[];
+    description?: string;
+}

package/dist/mcp-server/dto/McpPrompResult.dto.js

@@ -0,0 +1,31 @@
+"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.McpPromptResultDto = void 0;
+const swagger_1 = require("@nestjs/swagger");
+const McpPromptMessage_dto_1 = require("./McpPromptMessage.dto");
+class McpPromptResultDto {
+    messages;
+    description;
+}
+exports.McpPromptResultDto = McpPromptResultDto;
+__decorate([
+    (0, swagger_1.ApiProperty)({
+        type: McpPromptMessage_dto_1.McpPromptMessageDto,
+        isArray: true,
+        description: "Messages list",
+    }),
+    __metadata("design:type", Array)
+], McpPromptResultDto.prototype, "messages", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({ type: "string", nullable: true }),
+    __metadata("design:type", String)
+], McpPromptResultDto.prototype, "description", void 0);

package/dist/mcp-server/dto/McpPromptMessage.dto.d.ts

@@ -0,0 +1,5 @@
+export declare class McpPromptMessageDto {
+    role: string;
+    content?: string;
+    tool_call?: object;
+}

package/dist/mcp-server/dto/McpPromptMessage.dto.js

@@ -0,0 +1,40 @@
+"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.McpPromptMessageDto = void 0;
+const swagger_1 = require("@nestjs/swagger");
+class McpPromptMessageDto {
+    role;
+    content;
+    tool_call;
+}
+exports.McpPromptMessageDto = McpPromptMessageDto;
+__decorate([
+    (0, swagger_1.ApiProperty)({ type: "string", description: "AI role" }),
+    __metadata("design:type", String)
+], McpPromptMessageDto.prototype, "role", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({
+        type: "string",
+        description: "Request ai message",
+        nullable: true,
+    }),
+    __metadata("design:type", String)
+], McpPromptMessageDto.prototype, "content", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({
+        type: "object",
+        description: "Tool call context",
+        nullable: true,
+        additionalProperties: false,
+    }),
+    __metadata("design:type", Object)
+], McpPromptMessageDto.prototype, "tool_call", void 0);

package/dist/mcp-server/dto/McpTool.dto.d.ts

@@ -3,4 +3,5 @@ export declare class McpToolDto {
     title?: string;
     description?: string;
     inputSchema?: any;
+    outputSchema?: any;
 }

package/dist/mcp-server/dto/McpTool.dto.js

@@ -16,6 +16,7 @@ class McpToolDto {
     title;
     description;
     inputSchema;
+    outputSchema;
 }
 exports.McpToolDto = McpToolDto;
 __decorate([
@@ -47,3 +48,12 @@ __decorate([
     }),
     __metadata("design:type", Object)
 ], McpToolDto.prototype, "inputSchema", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({
+        type: "object",
+        description: "Tool result schema",
+        nullable: true,
+        additionalProperties: false,
+    }),
+    __metadata("design:type", Object)
+], McpToolDto.prototype, "outputSchema", void 0);

package/dist/mcp-server/dto/McpToolResult.dto.d.ts

@@ -0,0 +1,6 @@
+import { McpToolResultMessageDto } from "./McpToolResultMessage.dto";
+export declare class McpToolResultDto {
+    structuredContent?: any;
+    messages: McpToolResultMessageDto[];
+    isError?: boolean;
+}

package/dist/mcp-server/dto/McpToolResult.dto.js

@@ -0,0 +1,32 @@
+"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.McpToolResultDto = void 0;
+const swagger_1 = require("@nestjs/swagger");
+const McpToolResultMessage_dto_1 = require("./McpToolResultMessage.dto");
+class McpToolResultDto {
+    structuredContent;
+    messages;
+    isError;
+}
+exports.McpToolResultDto = McpToolResultDto;
+__decorate([
+    (0, swagger_1.ApiProperty)({ description: "Tool result", nullable: true }),
+    __metadata("design:type", Object)
+], McpToolResultDto.prototype, "structuredContent", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({ type: McpToolResultMessage_dto_1.McpToolResultMessageDto, isArray: true }),
+    __metadata("design:type", Array)
+], McpToolResultDto.prototype, "messages", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({ type: "boolean", nullable: true }),
+    __metadata("design:type", Boolean)
+], McpToolResultDto.prototype, "isError", void 0);

package/dist/mcp-server/dto/McpToolResultMessage.dto.d.ts

@@ -0,0 +1,4 @@
+export declare class McpToolResultMessageDto {
+    type: string;
+    text: string;
+}

package/dist/mcp-server/dto/McpToolResultMessage.dto.js

@@ -0,0 +1,26 @@
+"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.McpToolResultMessageDto = void 0;
+const swagger_1 = require("@nestjs/swagger");
+class McpToolResultMessageDto {
+    type;
+    text;
+}
+exports.McpToolResultMessageDto = McpToolResultMessageDto;
+__decorate([
+    (0, swagger_1.ApiProperty)({ type: "string", description: "Message type" }),
+    __metadata("design:type", String)
+], McpToolResultMessageDto.prototype, "type", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({ type: "string", description: "Message text" }),
+    __metadata("design:type", String)
+], McpToolResultMessageDto.prototype, "text", void 0);

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

@@ -1,11 +1,13 @@
 import { HttpException, HttpStatus } from "@nestjs/common";
+import { ErrorObject } from "ajv";
 export declare class McpException extends HttpException {
     constructor(message: string, status?: HttpStatus, options?: {
         cause?: unknown;
     });
 }
 export declare class McpBadRequestException extends McpException {
-    constructor(message: string, options?: {
+    errors?: ErrorObject[];
+    constructor(message: string, errors: ErrorObject[] | undefined, options?: {
         cause?: unknown;
     });
 }

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

@@ -9,8 +9,10 @@ class McpException extends common_1.HttpException {
 }
 exports.McpException = McpException;
 class McpBadRequestException extends McpException {
-    constructor(message, options) {
+    errors;
+    constructor(message, errors, options) {
         super(message, common_1.HttpStatus.BAD_REQUEST, options);
+        this.errors = errors;
     }
 }
 exports.McpBadRequestException = McpBadRequestException;

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

@@ -4,7 +4,7 @@ import { McpService } from "../services/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> & {
+export type IMcpDynamicTool<Input, Result extends Record<string, unknown>> = IMcpTool<Input, Result> & {
     guards?: Type<CanActivate>[];
     interceptors?: Type<NestInterceptor>[];
 };
@@ -21,7 +21,7 @@ export declare class McpDynamicService {
     private readonly mcpService;
     constructor(moduleRef: ModuleRef, mcpService: McpService);
     /** Динамически регистрирует MCP tools */
-    registerTool<Input, Result>(tool: IMcpDynamicTool<Input, Result>): Promise<void>;
+    registerTool<Input, Result extends Record<string, unknown>>(tool: IMcpDynamicTool<Input, Result>): Promise<void>;
     /** Динамически регистрирует MCP prompts */
     registerPrompt<Input>(prompt: IMcpDynamicPrompt<Input>): Promise<void>;
     /** Динамически регистрирует MCP resources */

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

@@ -29,6 +29,9 @@ let McpDynamicService = class McpDynamicService {
             description = tool.description;
             execute = tool.execute;
             inputSchema = tool.inputSchema;
+            outputSchema = tool.outputSchema;
+            annotations = tool.annotations;
+            _meta = tool._meta;
         };
         if (tool.guards) {
             this.applyGuards(DynamicToolClass, tool.guards);
@@ -72,6 +75,8 @@ let McpDynamicService = class McpDynamicService {
             description = resource.description;
             execute = resource.execute;
             list = resource.list;
+            annotations = resource.annotations;
+            _meta = resource._meta;
         };
         if (resource.guards) {
             this.applyGuards(DynamicResourceClass, resource.guards);

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

@@ -1,8 +1,9 @@
 import { ExecutionContext, OnModuleInit } from "@nestjs/common";
-import { IMcpTool } from "../decorators/mcp-tool.decorator";
-import { IMcpPrompt } from "../decorators/mcp-prompt.decorator";
-import { IMcpResource } from "../decorators/mcp-resource.decorator";
+import { IMcpTool, IMcpToolResult } from "../decorators/mcp-tool.decorator";
+import { IMcpPrompt, IMcpPromptResult } from "../decorators/mcp-prompt.decorator";
+import { IMcpResource, IMcpResourceResult } from "../decorators/mcp-resource.decorator";
 import { ModuleRef } from "@nestjs/core";
+import { Observable } from "rxjs";
 import { IMcpConfig } from "../config";
 export interface McpMessage {
     type: string;
@@ -39,6 +40,7 @@ export declare class McpService implements OnModuleInit {
         title: string | undefined;
         description: string | undefined;
         inputSchema: any;
+        outputSchema: any;
     }[];
     listPrompts(): {
         name: string;
@@ -64,13 +66,13 @@ export declare class McpService implements OnModuleInit {
         instance: IMcpResource;
         metatype: Function;
     }): void;
-    executePrompt(name: string, payload: object, context: ExecutionContext): Promise<import("rxjs").Observable<any>>;
+    executePrompt(name: string, payload: object, context: ExecutionContext): Promise<Observable<IMcpPromptResult>>;
     /**
      * Отправить сообщение в MCP "сервер"
      */
     executeTool(msg: {
         type: string;
         payload: any;
-    }, context: ExecutionContext): Promise<import("rxjs").Observable<any>>;
-    executeResource(name: string, uri: URL, vars: Record<string, any>, context: ExecutionContext): Promise<import("rxjs").Observable<any>>;
+    }, context: ExecutionContext): Promise<Observable<IMcpToolResult<Record<string, unknown>>>>;
+    executeResource(name: string, uri: URL, vars: Record<string, any>, context: ExecutionContext): Promise<Observable<IMcpResourceResult[]>>;
 }

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

@@ -46,6 +46,9 @@ let McpService = class McpService {
             title: t.title,
             description: t.description,
             inputSchema: t.inputSchema ? (0, zod_1.zodToJsonSchema)(t.inputSchema) : undefined,
+            outputSchema: t.outputSchema
+                ? (0, zod_1.zodToJsonSchema)(t.outputSchema)
+                : undefined,
         }));
     }
     listPrompts() {
@@ -86,7 +89,7 @@ let McpService = class McpService {
                 const validate = this.ajv.compile(zodSchema);
                 const valid = validate(payload);
                 if (!valid) {
-                    throw new exceptions_1.McpBadRequestException("Invalid prompt arguments");
+                    throw new exceptions_1.McpBadRequestException("Invalid prompt arguments", validate.errors || []);
                 }
             }
             // const result = await prompt.execute(payload);
@@ -120,7 +123,7 @@ let McpService = class McpService {
                 const validate = this.ajv.compile(zodSchema);
                 const valid = validate(msg.payload);
                 if (!valid) {
-                    throw new exceptions_1.McpBadRequestException(this.ajv.errorsText(validate.errors));
+                    throw new exceptions_1.McpBadRequestException("Invalid tool arguments", validate.errors || []);
                 }
             }
             // const result = await tool.execute(msg.payload);

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

@@ -22,4 +22,7 @@ export declare class McpSseService implements OnModuleInit {
     handleSse(_: IRequest, res: IResponse, context: ExecutionContext): Promise<void>;
     handleSseMessage(req: IRequest, res: IResponse): Promise<void>;
     private createServer;
+    private registerTools;
+    private registerPrompts;
+    private registerResources;
 }

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

@@ -64,11 +64,20 @@ let McpSseService = class McpSseService {
             version: this.config.version || "1",
             name: this.config.name || "MCP server",
         }, {});
+        this.registerTools(server, context);
+        this.registerPrompts(server, context);
+        this.registerResources(server, context);
+        return server;
+    }
+    registerTools(server, context) {
         for (const [toolName, { instance: tool }] of this.service.tools.entries()) {
             server.registerTool(tool.name, {
                 title: tool.title,
                 description: tool.description,
                 inputSchema: tool.inputSchema,
+                outputSchema: tool.outputSchema,
+                annotations: tool.annotations,
+                _meta: tool._meta,
             }, async (payload) => {
                 try {
                     // const result = await tool.execute(
@@ -77,9 +86,9 @@ let McpSseService = class McpSseService {
                     const observable = await this.service.executeTool({ type: tool.name, payload }, context);
                     const result = await (0, rxjs_1.firstValueFrom)(observable);
                     return {
-                        content: [
-                            { text: JSON.stringify(result), type: "text" },
-                        ],
+                        content: result.messages,
+                        structuredContent: result.structuredContent,
+                        isError: result.isError,
                     };
                 }
                 catch (e) {
@@ -89,6 +98,8 @@ let McpSseService = class McpSseService {
                 }
             });
         }
+    }
+    registerPrompts(server, context) {
         for (const [promptName, { instance: prompt },] of this.service.prompts.entries()) {
             server.registerPrompt(prompt.name, {
                 title: prompt.title,
@@ -99,7 +110,7 @@ let McpSseService = class McpSseService {
                     // const result = await prompt.execute({ ...params });
                     const observable = await this.service.executePrompt(prompt.name, payload, context);
                     const result = await (0, rxjs_1.firstValueFrom)(observable);
-                    const messages = result.map((el) => ({
+                    const messages = result.messages.map((el) => ({
                         role: (el.role === "system" ? "assistant" : el.role),
                         content: el.tool_call
                             ? {
@@ -108,7 +119,7 @@ let McpSseService = class McpSseService {
                             }
                             : { type: "text", text: el.content },
                     }));
-                    return { messages: messages };
+                    return { messages: messages, description: result.description };
                 }
                 catch (e) {
                     throw new exceptions_1.McpInternalServerErrorException(`Faild to execute tool ${prompt.name}`, {
@@ -117,6 +128,8 @@ let McpSseService = class McpSseService {
                 }
             });
         }
+    }
+    registerResources(server, context) {
         for (const [_, { instance: resource },] of this.service.resources.entries()) {
             const resourceList = resource.list;
             server.registerResource(resource.name, new mcp_js_1.ResourceTemplate(resource.uri, {
@@ -130,6 +143,8 @@ let McpSseService = class McpSseService {
             }), {
                 title: resource.title,
                 description: resource.description,
+                annotations: resource.annotations,
+                _meta: resource._meta,
             }, async (url, variables) => {
                 try {
                     // const resources = await resource.execute(url, variables);
@@ -144,7 +159,6 @@ let McpSseService = class McpSseService {
                 }
             });
         }
-        return server;
     }
 };
 exports.McpSseService = McpSseService;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@muzikanto/nestjs-mcp",
-  "version": "1.6.0",
+  "version": "1.7.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",