nest-graphql-mcp 0.0.0-stage → 0.1.0

package/LICENSE.md

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2026 Chase McManning
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -1,3 +1,214 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+# Nest GraphQL MCP Module
+
+This module provides integration between NestJS, GraphQL, and the Model Context Protocol (MCP).
+
+If you have a mature GraphQL environment, this module allows you to expose specific queries and mutations to AI agents as MCP tools by using your existing schema types and documentation directly.
+
+## Installation
+
+```sh
+npm install nest-graphql-mcp @modelcontextprotocol/sdk zod
+```
+
+## Module Registration
+
+Import `NestGraphqlMcpModule.forRoot()` in your root `AppModule`:
+
+```ts
+import { Module } from '@nestjs/common';
+import { NestGraphqlMcpModule } from 'nest-graphql-mcp';
+
+@Module({
+  imports: [
+    NestGraphqlMcpModule.forRoot({
+      path: '/mcp/stateless', // Endpoint for AI agents
+    }),
+    // ... GraphQLModule import (see Code-First or Schema-First setup below)
+  ],
+})
+export class AppModule {}
+```
+
+## Code-First Approach
+
+Use TypeScript decorators to generate the GraphQL schema and register the MCP directive.
+
+Pass `MCP_DIRECTIVE_DEFINITION` to buildSchemaOptions.directives:
+
+```ts
+import { Module } from '@nestjs/common';
+import { GraphQLModule } from '@nestjs/graphql';
+import { ApolloDriver, ApolloDriverConfig } from '@nestjs/apollo';
+import { NestGraphqlMcpModule, MCP_DIRECTIVE_DEFINITION } from 'nest-graphql-mcp';
+
+@Module({
+  imports: [
+    GraphQLModule.forRoot<ApolloDriverConfig>({
+      driver: ApolloDriver,
+      autoSchemaFile: true,
+      buildSchemaOptions: {
+        directives: [MCP_DIRECTIVE_DEFINITION],
+      },
+    }),
+    NestGraphqlMcpModule.forRoot(),
+  ],
+})
+export class AppModule {}
+```
+
+Attach the `@ExposeMcp()` decorator to any GraphQL Query or Mutation you want to expose to AI agents. You can optionally pass agent-specific prompt instructions.
+
+```ts
+import { Resolver, Query, Args } from '@nestjs/graphql';
+import { UseGuards } from '@nestjs/common';
+import { ExposeMcp } from 'nest-graphql-mcp';
+import { AuthGuard } from './auth.guard';
+import { User } from './user.model';
+
+@Resolver(() => User)
+export class UserResolver {
+  @Query(() => User, {
+    description: 'Fetches user details by ID.',
+  })
+  @ExposeMcp('Prefer looking up users by UUID. Do not call in a loop for bulk queries.')
+  @UseGuards(AuthGuard)
+  async userById(@Args('id') id: string) {
+    return this.userService.findById(id);
+  }
+
+  @Query(() => [User])
+  // Standard GQL query hidden from MCP tools because @ExposeMcp() is omitted
+  async internalAdminSearch() {
+    return this.userService.findAll();
+  }
+}
+```
+
+## Schema-First Approach
+
+In the Schema-First approach, you define your GraphQL types and directives inside .graphql SDL files. This module automatically reads the compiled GraphQL AST at startup to discover fields annotated with `@mcp`.
+
+```ts
+import { Module } from '@nestjs/common';
+import { GraphQLModule } from '@nestjs/graphql';
+import { ApolloDriver, ApolloDriverConfig } from '@nestjs/apollo';
+import { NestGraphqlMcpModule, MCP_DIRECTIVE_DEFINITION } from 'nest-graphql-mcp';
+
+@Module({
+  imports: [
+    GraphQLModule.forRoot<ApolloDriverConfig>({
+      driver: ApolloDriver,
+      typePaths: ['./**/*.graphql'],
+      definitions: {
+        path: join(process.cwd(), 'src/graphql.ts'),
+      },
+    }),
+    NestGraphqlMcpModule.forRoot(),
+  ],
+})
+export class AppModule {}
+```
+
+Add the `@mcp` directive definition to your .graphql schema file and annotate fields directly:
+
+```graphql
+" Directive to expose operations as MCP Tools to AI agents. "
+directive @mcp(instructions: String) on FIELD_DEFINITION
+
+type User {
+  id: ID!
+  name: String!
+  email: String!
+}
+
+type Query {
+  me: User @mcp
+
+  # Exposing to MCP with custom agent instructions
+  userById(id: ID!): User @mcp(instructions: "Prefer looking up users by UUID. Do not call in a loop for bulk queries.")
+
+  # Hidden from MCP tools
+  internalAdminSearch: [User!]!
+}
+```
+
+Import your `.graphql` files as usual. No special directive configuration is needed in Typescript.
+
+## Authentication & Context Forwarding
+
+When an AI agent calls an MCP tool over HTTP, `nest-graphql-mcp` forwards the incoming `Authorization` header directly into GraphQL's execution context:
+
+```
+[AI Agent]
+    │
+    │  HTTP POST /mcp/stateless
+    │  Header: Authorization: Bearer <SERVICE_ACCOUNT_JWT>
+    ▼
+[nest-graphql-mcp]
+    │
+    │  Executes query with contextValue: { req: { headers: { authorization } } }
+    ▼
+[NestJS Resolvers / @UseGuards()]
+```
+
+This ensures your existing NestJS Guards, Role Checks, and Field-level permissions continue to execute for AI service accounts.
+
+## Agent Setup & Testing
+
+### Cursor / Claude / Standard MCP Setup
+
+Add the endpoint and service account JWT to your mcp.json config:
+
+```ts
+{
+  "mcpServers": {
+    "nestjs-api": {
+      "url": "http://localhost:3000/mcp/stateless",
+      "transport": "http",
+      "headers": {
+        "Authorization": "Bearer YOUR_SERVICE_ACCOUNT_JWT"
+      }
+    }
+  }
+}
+```
+
+### Inspectiing Tools via Curl
+
+You can verify that exposed tools and JSON Schemas are generated correctly by sending a JSON-RPC request:
+
+```sh
+# List Tools
+curl -X POST http://localhost:3000/api/mcp/stateless \
+  -H "Content-Type: application/json" \
+  -H "Accept: application/json, text/event-stream" \
+  -H "Authorization: Bearer YOUR_SERVICE_ACCOUNT_JWT" \
+  -d '{
+    "jsonrpc": "2.0",
+    "id": 1,
+    "method": "tools/list"
+  }'
+```
+
+```sh
+# Execute Tool
+curl -s -X POST http://localhost:3000/api/mcp/stateless \
+  -H "Content-Type: application/json" \
+  -H "Accept: application/json, text/event-stream" \
+  -H "Authorization: Bearer YOUR_SERVICE_ACCOUNT_JWT" \
+  -d '{
+    "jsonrpc": "2.0",
+    "id": 2,
+    "method": "tools/call",
+    "params": {
+      "name": "query_getUser",
+      "arguments": {
+        "id": "usr_123"
+      }
+    }
+  }'
+```
+
+## License
+
+MIT, see the included [LICENSE](LICENSE.md) file.

package/dist/constants.d.ts

@@ -0,0 +1,6 @@
+import { GraphQLDirective } from 'graphql';
+export declare const MCP_OPTIONS: unique symbol;
+/**
+ * GraphQL directive definition for exposing fields as MCP.
+ */
+export declare const MCP_DIRECTIVE_DEFINITION: GraphQLDirective;

package/dist/constants.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MCP_DIRECTIVE_DEFINITION = exports.MCP_OPTIONS = void 0;
+const graphql_1 = require("graphql");
+exports.MCP_OPTIONS = Symbol('MCP_OPTIONS');
+/**
+ * GraphQL directive definition for exposing fields as MCP.
+ */
+exports.MCP_DIRECTIVE_DEFINITION = new graphql_1.GraphQLDirective({
+    name: 'mcp',
+    locations: [graphql_1.DirectiveLocation.FIELD_DEFINITION],
+    args: {
+        instructions: { type: graphql_1.GraphQLString },
+    },
+});

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from './constants';
+export * from './mcp.decorator';
+export * from './mcp.service';
+export * from './nest-graphql-mcp.module';
+export * from './types';

package/dist/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./constants"), exports);
+__exportStar(require("./mcp.decorator"), exports);
+__exportStar(require("./mcp.service"), exports);
+__exportStar(require("./nest-graphql-mcp.module"), exports);
+__exportStar(require("./types"), exports);

package/dist/mcp.controller.d.ts

@@ -0,0 +1,8 @@
+import { type Request, type Response } from 'express';
+import { McpService } from './mcp.service';
+export declare class McpController {
+    private readonly mcpService;
+    constructor(mcpService: McpService);
+    private transport;
+    handleStatelessMcp(req: Request, res: Response): Promise<void>;
+}

package/dist/mcp.controller.js

@@ -0,0 +1,89 @@
+"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);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.McpController = void 0;
+const streamableHttp_js_1 = require("@modelcontextprotocol/sdk/server/streamableHttp.js");
+const common_1 = require("@nestjs/common");
+const mcp_service_1 = require("./mcp.service");
+let McpController = class McpController {
+    mcpService;
+    // Store active sessions mapped by their session ID
+    // private readonly sessions = new Map<string, StreamableHTTPServerTransport>();
+    constructor(mcpService) {
+        this.mcpService = mcpService;
+    }
+    // The single McpServer instance supports one transport at a time, so track the
+    // active transport and close it before reconnecting on the next request.
+    // ponytail: one in-flight request at a time per endpoint; per-request McpServer
+    // instances (or sessions) when concurrent stateless connections are needed.
+    transport;
+    // @All()
+    // async handleMcp(@Req() req: Request, @Res() res: Response) {
+    //   const authHeader = req.headers.authorization;
+    //   if (!authHeader) {
+    //     throw new UnauthorizedException('Missing Authorization header');
+    //   }
+    //   const sessionId = req.headers['mcp-session-id'] as string | undefined;
+    //   //  Resume existing session if mcp-session-id header is provided
+    //   if (sessionId && this.sessions.has(sessionId)) {
+    //     const transport = this.sessions.get(sessionId)!;
+    //     await transport.handleRequest(req, res, req.body);
+    //     return;
+    //   }
+    //   const transport = new StreamableHTTPServerTransport({
+    //     sessionIdGenerator: () => randomUUID(),
+    //     onsessioninitialized: (id) => this.sessions.set(id, transport),
+    //   });
+    //   transport.onclose = () => {
+    //     if (transport.sessionId) {
+    //       this.sessions.delete(transport.sessionId);
+    //     }
+    //   };
+    //   // Connect transport to the underlying McpServer and handle request
+    //   await this.mcpService.getMcpServer().connect(transport);
+    //   await transport.handleRequest(req, res, req.body);
+    // }
+    async handleStatelessMcp(req, res) {
+        // TODO: This is if we don't need in-memory session tracking acrosst urns
+        // (e.g. token is validated on every request). Probably the preferred route.
+        const transport = new streamableHttp_js_1.StreamableHTTPServerTransport({
+            // We don't need to persist state between requests.
+            sessionIdGenerator: undefined,
+        });
+        res.on('close', () => {
+            transport.close();
+        });
+        // Close the previous transport (no-op if already closed) so the shared
+        // server can attach to this request's transport.
+        if (this.transport) {
+            await this.transport.close();
+        }
+        this.transport = transport;
+        await this.mcpService.getMcpServer().connect(transport);
+        await transport.handleRequest(req, res, req.body);
+    }
+};
+exports.McpController = McpController;
+__decorate([
+    (0, common_1.All)('stateless'),
+    __param(0, (0, common_1.Req)()),
+    __param(1, (0, common_1.Res)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], McpController.prototype, "handleStatelessMcp", null);
+exports.McpController = McpController = __decorate([
+    (0, common_1.Controller)('mcp'),
+    __metadata("design:paramtypes", [mcp_service_1.McpService])
+], McpController);

package/dist/mcp.decorator.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Whitelists a GraphQL Query or Mutation for MCP and optionally adds custom
+ * instructions specifically for AI agents.
+ */
+export declare const ExposeMcp: (agentInstructions?: string) => MethodDecorator & PropertyDecorator & ClassDecorator;

package/dist/mcp.decorator.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExposeMcp = void 0;
+const graphql_1 = require("@nestjs/graphql");
+/**
+ * Whitelists a GraphQL Query or Mutation for MCP and optionally adds custom
+ * instructions specifically for AI agents.
+ */
+const ExposeMcp = (agentInstructions) => {
+    if (agentInstructions) {
+        // Escape quotes to prevent directive string syntax errors
+        const sanitized = agentInstructions.replace(/"/g, '\\"');
+        return (0, graphql_1.Directive)(`@mcp(instructions: "${sanitized}")`);
+    }
+    return (0, graphql_1.Directive)('@mcp');
+};
+exports.ExposeMcp = ExposeMcp;

package/dist/mcp.service.d.ts

@@ -0,0 +1,20 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { OnModuleInit } from '@nestjs/common';
+import { ModuleRef } from '@nestjs/core';
+import { type GraphqlMcpModuleOptions } from './types';
+export declare class McpService implements OnModuleInit {
+    private readonly moduleRef;
+    private readonly options;
+    private readonly mcpServer;
+    private schemaHost;
+    constructor(moduleRef: ModuleRef, options: GraphqlMcpModuleOptions);
+    onModuleInit(): void;
+    /**
+     * Helper to parse the `@mcp` directive and its `instructions` argument from field AST.
+     */
+    private getMcpDirectiveConfig;
+    private mapGraphQLTypeToZod;
+    private buildSelectionSet;
+    getMcpServer(): McpServer;
+    private registerObjectTypeFields;
+}

package/dist/mcp.service.js

@@ -0,0 +1,189 @@
+"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);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.McpService = void 0;
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+const graphql_1 = require("@nestjs/graphql");
+const graphql_2 = require("graphql");
+const zod_1 = require("zod");
+const constants_1 = require("./constants");
+let McpService = class McpService {
+    moduleRef;
+    options;
+    mcpServer;
+    schemaHost;
+    constructor(moduleRef, options) {
+        this.moduleRef = moduleRef;
+        this.options = options;
+        this.mcpServer = new mcp_js_1.McpServer({
+            name: this.options.serverName || 'nestjs-mcp-server',
+            version: this.options.serverVersion || '1.0.0',
+        });
+    }
+    onModuleInit() {
+        this.schemaHost = this.moduleRef.get(graphql_1.GraphQLSchemaHost, { strict: false });
+        const { schema } = this.schemaHost;
+        if (!schema) {
+            return;
+        }
+        const queryType = schema.getQueryType();
+        if (queryType) {
+            this.registerObjectTypeFields(queryType, 'query');
+        }
+        const mutationType = schema.getMutationType();
+        if (mutationType) {
+            this.registerObjectTypeFields(mutationType, 'mutation');
+        }
+    }
+    /**
+     * Helper to parse the `@mcp` directive and its `instructions` argument from field AST.
+     */
+    getMcpDirectiveConfig(field) {
+        const directives = field.astNode?.directives;
+        if (!directives) {
+            return { isExposed: false };
+        }
+        const mcpDirective = directives.find((d) => d.name.value === 'mcp');
+        if (!mcpDirective) {
+            return { isExposed: false };
+        }
+        let instructions;
+        const arg = mcpDirective.arguments?.find((a) => a.name.value === 'instructions');
+        if (arg && arg.value.kind === 'StringValue') {
+            instructions = arg.value.value;
+        }
+        return { isExposed: true, instructions };
+    }
+    mapGraphQLTypeToZod(type) {
+        const isNonNull = (0, graphql_2.isNonNullType)(type);
+        const unwrappedType = isNonNull
+            ? type.ofType
+            : type;
+        let schema;
+        if ((0, graphql_2.isScalarType)(unwrappedType)) {
+            switch (unwrappedType.name) {
+                case 'Int':
+                case 'Float':
+                    schema = zod_1.z.number();
+                    break;
+                case 'Boolean':
+                    schema = zod_1.z.boolean();
+                    break;
+                default:
+                    schema = zod_1.z.string();
+            }
+        }
+        else {
+            schema = zod_1.z.any();
+        }
+        return isNonNull ? schema : schema.optional();
+    }
+    buildSelectionSet(returnType) {
+        let namedType = returnType;
+        while ('ofType' in namedType) {
+            namedType = namedType.ofType;
+        }
+        if ((0, graphql_2.isObjectType)(namedType)) {
+            const fields = namedType.getFields();
+            const scalarFields = Object.keys(fields).filter((key) => {
+                let fType = fields[key].type;
+                while ('ofType' in fType) {
+                    fType = fType.ofType;
+                }
+                return (0, graphql_2.isScalarType)(fType);
+            });
+            return scalarFields.join('\n');
+        }
+        return '';
+    }
+    getMcpServer() {
+        return this.mcpServer;
+    }
+    registerObjectTypeFields(objectType, operationType) {
+        const fields = objectType.getFields();
+        for (const [fieldName, field] of Object.entries(fields)) {
+            // Check for @mcp/@ExposeMcp directives and parse instructions
+            const mcpConfig = this.getMcpDirectiveConfig(field);
+            if (!mcpConfig.isExposed) {
+                continue;
+            }
+            const toolName = `${operationType}_${fieldName}`;
+            // Build an additive description (Base GraphQL + Agent Context)
+            const baseDescription = field.description || `Executes the ${fieldName} ${operationType}.`;
+            const finalDescription = mcpConfig.instructions
+                ? `${baseDescription}\n\n[Agent Context]: ${mcpConfig.instructions}`
+                : baseDescription;
+            // Build input schema
+            const zodShape = {};
+            for (const arg of field.args) {
+                zodShape[arg.name] = this.mapGraphQLTypeToZod(arg.type);
+            }
+            this.mcpServer.registerTool(toolName, {
+                title: fieldName,
+                description: finalDescription,
+                inputSchema: zodShape,
+            }, async (args, extra) => {
+                const selectionSet = this.buildSelectionSet(field.type);
+                const selectionBlock = selectionSet ? `{ ${selectionSet} }` : '';
+                const varDefs = field.args
+                    .map((a) => `$${a.name}: ${a.type.toString()}`)
+                    .join(', ');
+                const varArgs = field.args
+                    .map((a) => `${a.name}: $${a.name}`)
+                    .join(', ');
+                const queryString = `
+            ${operationType} ${fieldName}McpWrapper${varDefs ? `(${varDefs})` : ''} {
+              ${fieldName}${varArgs ? `(${varArgs})` : ''} ${selectionBlock}
+            }
+          `;
+                const req = extra?.request;
+                const authHeader = req?.headers?.['authorization'];
+                const result = await (0, graphql_2.graphql)({
+                    schema: this.schemaHost.schema,
+                    source: queryString,
+                    variableValues: args,
+                    contextValue: {
+                        req: {
+                            headers: { authorization: authHeader },
+                        },
+                    },
+                });
+                if (result.errors) {
+                    return {
+                        isError: true,
+                        content: [
+                            { type: 'text', text: JSON.stringify(result.errors, null, 2) },
+                        ],
+                    };
+                }
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify(result.data?.[fieldName], null, 2),
+                        },
+                    ],
+                };
+            });
+        }
+    }
+};
+exports.McpService = McpService;
+exports.McpService = McpService = __decorate([
+    (0, common_1.Injectable)(),
+    __param(1, (0, common_1.Inject)(constants_1.MCP_OPTIONS)),
+    __metadata("design:paramtypes", [core_1.ModuleRef, Object])
+], McpService);

package/dist/nest-graphql-mcp.module.d.ts

@@ -0,0 +1,5 @@
+import { DynamicModule } from '@nestjs/common';
+import { GraphqlMcpModuleOptions } from './types';
+export declare class NestGraphqlMcpModule {
+    static forRoot(options?: GraphqlMcpModuleOptions): DynamicModule;
+}

package/dist/nest-graphql-mcp.module.js

@@ -0,0 +1,34 @@
+"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 NestGraphqlMcpModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NestGraphqlMcpModule = void 0;
+const common_1 = require("@nestjs/common");
+const constants_1 = require("./constants");
+const mcp_controller_1 = require("./mcp.controller");
+const mcp_service_1 = require("./mcp.service");
+let NestGraphqlMcpModule = NestGraphqlMcpModule_1 = class NestGraphqlMcpModule {
+    static forRoot(options = {}) {
+        return {
+            module: NestGraphqlMcpModule_1,
+            controllers: [mcp_controller_1.McpController],
+            providers: [
+                {
+                    provide: constants_1.MCP_OPTIONS,
+                    useValue: options,
+                },
+                mcp_service_1.McpService,
+            ],
+            exports: [mcp_service_1.McpService, constants_1.MCP_OPTIONS],
+        };
+    }
+};
+exports.NestGraphqlMcpModule = NestGraphqlMcpModule;
+exports.NestGraphqlMcpModule = NestGraphqlMcpModule = NestGraphqlMcpModule_1 = __decorate([
+    (0, common_1.Module)({})
+], NestGraphqlMcpModule);

package/dist/src/constants.d.ts

@@ -0,0 +1,6 @@
+import { GraphQLDirective } from 'graphql';
+export declare const MCP_OPTIONS: unique symbol;
+/**
+ * GraphQL directive definition for exposing fields as MCP.
+ */
+export declare const MCP_DIRECTIVE_DEFINITION: GraphQLDirective;