@riktajs/mcp 0.1.0

package/README.md

@@ -0,0 +1,399 @@
+# @riktajs/mcp
+
+Model Context Protocol (MCP) integration for Rikta Framework. Connect AI assistants like Claude and GPT to your Rikta backend with decorator-based APIs.
+
+## Features
+
+- 🤖 **Decorator-based API** - Define MCP tools, resources, and prompts with `@MCPTool`, `@MCPResource`, `@MCPPrompt`
+- 🔍 **Auto-discovery** - Automatically discovers MCP handlers from `@Injectable` classes
+- 📝 **Zod Integration** - Full Zod support for input schema validation (consistent with Rikta ecosystem)
+- 📡 **SSE Support** - Server-Sent Events for real-time notifications
+- 🔄 **Horizontal Scaling** - Redis support for multi-instance deployments
+- 🔒 **Type Safe** - Complete TypeScript definitions
+
+## Installation
+
+```bash
+npm install @riktajs/mcp zod
+```
+
+> **Note**: `@platformatic/mcp` is included as a dependency and will be installed automatically.
+
+## Quick Start
+
+```typescript
+import { Rikta, Injectable } from '@riktajs/core';
+import { registerMCPServer, MCPTool, MCPResource, z } from '@riktajs/mcp';
+import { promises as fs } from 'fs';
+
+@Injectable()
+class FileService {
+  @MCPTool({
+    name: 'list_files',
+    description: 'List files in a directory',
+    inputSchema: z.object({
+      path: z.string().describe('Directory path to list'),
+      showHidden: z.boolean().optional().default(false),
+    }),
+  })
+  async listFiles(params: { path: string; showHidden?: boolean }) {
+    const files = await fs.readdir(params.path);
+    const filtered = params.showHidden 
+      ? files 
+      : files.filter(f => !f.startsWith('.'));
+    
+    return {
+      content: [{
+        type: 'text',
+        text: filtered.join('\n'),
+      }],
+    };
+  }
+
+  @MCPResource({
+    uriPattern: 'file://read',
+    name: 'Read File',
+    description: 'Read file contents by path',
+    mimeType: 'text/plain',
+  })
+  async readFile(uri: string) {
+    const url = new URL(uri);
+    const filePath = url.searchParams.get('path')!;
+    const content = await fs.readFile(filePath, 'utf-8');
+    
+    return {
+      contents: [{
+        uri,
+        text: content,
+        mimeType: 'text/plain',
+      }],
+    };
+  }
+}
+
+// Bootstrap application
+const app = await Rikta.create({ port: 3000 });
+
+// Register MCP server
+await registerMCPServer(app, {
+  serverInfo: { name: 'file-server', version: '1.0.0' },
+  instructions: 'A file system server for reading and listing files',
+  enableSSE: true,
+});
+
+await app.listen();
+// MCP available at http://localhost:3000/mcp
+```
+
+## Decorators
+
+### @MCPTool
+
+Marks a method as an MCP tool that AI assistants can invoke.
+
+```typescript
+@Injectable()
+class CalculatorService {
+  @MCPTool({
+    name: 'calculate',
+    description: 'Perform a calculation',
+    inputSchema: z.object({
+      operation: z.enum(['add', 'subtract', 'multiply', 'divide']),
+      a: z.number(),
+      b: z.number(),
+    }),
+  })
+  async calculate(params: { operation: string; a: number; b: number }) {
+    let result: number;
+    switch (params.operation) {
+      case 'add': result = params.a + params.b; break;
+      case 'subtract': result = params.a - params.b; break;
+      case 'multiply': result = params.a * params.b; break;
+      case 'divide': result = params.a / params.b; break;
+      default: throw new Error('Unknown operation');
+    }
+    
+    return {
+      content: [{ type: 'text', text: `Result: ${result}` }],
+    };
+  }
+}
+```
+
+### @MCPResource
+
+Marks a method as an MCP resource provider.
+
+```typescript
+@Injectable()
+class DatabaseService {
+  @MCPResource({
+    uriPattern: 'db://users',
+    name: 'Users Database',
+    description: 'Query users from the database',
+    mimeType: 'application/json',
+  })
+  async getUsers(uri: string) {
+    const url = new URL(uri);
+    const limit = parseInt(url.searchParams.get('limit') || '10');
+    
+    const users = await this.userRepository.find({ take: limit });
+    
+    return {
+      contents: [{
+        uri,
+        text: JSON.stringify(users, null, 2),
+        mimeType: 'application/json',
+      }],
+    };
+  }
+}
+```
+
+### @MCPPrompt
+
+Marks a method as an MCP prompt template.
+
+```typescript
+@Injectable()
+class PromptService {
+  @MCPPrompt({
+    name: 'code_review',
+    description: 'Generate a code review prompt',
+    arguments: [
+      { name: 'language', description: 'Programming language', required: true },
+      { name: 'code', description: 'Code to review', required: true },
+      { name: 'focus', description: 'Specific areas to focus on' },
+    ],
+  })
+  async codeReview(args: { language: string; code: string; focus?: string }) {
+    const focusArea = args.focus ? `\nFocus on: ${args.focus}` : '';
+    
+    return {
+      messages: [
+        {
+          role: 'user',
+          content: {
+            type: 'text',
+            text: `Please review this ${args.language} code:${focusArea}\n\n\`\`\`${args.language}\n${args.code}\n\`\`\``,
+          },
+        },
+      ],
+    };
+  }
+}
+```
+
+## Zod Schema Examples
+
+The package uses Zod for schema validation, consistent with the rest of the Rikta ecosystem:
+
+```typescript
+import { z } from '@riktajs/mcp'; // Re-exported for convenience
+
+// Simple string with description
+const pathSchema = z.string().describe('File path to read');
+
+// Object with optional fields
+const optionsSchema = z.object({
+  path: z.string().describe('Directory path'),
+  recursive: z.boolean().optional().default(false),
+  maxDepth: z.number().min(1).max(10).optional(),
+});
+
+// Enum for fixed values
+const operationSchema = z.enum(['read', 'write', 'delete']);
+
+// Array of objects
+const filesSchema = z.array(z.object({
+  name: z.string(),
+  size: z.number(),
+}));
+```
+
+## Configuration
+
+### Basic Configuration
+
+```typescript
+await registerMCPServer(app, {
+  serverInfo: {
+    name: 'my-mcp-server',
+    version: '1.0.0',
+  },
+  instructions: 'Instructions for AI assistants on how to use this server',
+  enableSSE: true,
+  path: '/mcp', // Custom endpoint path
+});
+```
+
+### Redis Configuration (Horizontal Scaling)
+
+```typescript
+await registerMCPServer(app, {
+  serverInfo: { name: 'scaled-server', version: '1.0.0' },
+  redis: {
+    host: 'localhost',
+    port: 6379,
+    password: 'your-password', // optional
+    db: 0, // optional
+  },
+  sessionTTL: 3600, // Session TTL in seconds
+});
+```
+
+### Full Configuration Options
+
+```typescript
+interface MCPServerOptions {
+  // Server identification
+  serverInfo?: { name: string; version: string };
+  
+  // Instructions for AI assistants
+  instructions?: string;
+  
+  // Enable SSE (Server-Sent Events)
+  enableSSE?: boolean; // default: true
+  
+  // Custom endpoint path
+  path?: string; // default: '/mcp'
+  
+  // Redis for horizontal scaling
+  redis?: {
+    host: string;
+    port?: number; // default: 6379
+    password?: string;
+    db?: number; // default: 0
+  };
+  
+  // Session configuration
+  sessionTTL?: number; // default: 3600
+  
+  // Heartbeat configuration
+  heartbeat?: boolean; // default: true
+  heartbeatInterval?: number; // default: 30000ms
+}
+```
+
+## Endpoints
+
+After registering the MCP server, the following endpoints are available:
+
+| Method | Path | Description |
+|--------|------|-------------|
+| POST | `/mcp` | JSON-RPC endpoint for MCP requests |
+| GET | `/mcp` | SSE endpoint for real-time notifications |
+
+## Testing with MCP Inspector
+
+You can test your MCP server using the official MCP Inspector:
+
+```bash
+# Start your server
+npm run dev
+
+# In another terminal, run the inspector
+npx @modelcontextprotocol/inspector http://localhost:3000/mcp
+```
+
+## Testing with curl
+
+```bash
+# Initialize connection
+curl -X POST http://localhost:3000/mcp \
+  -H "Content-Type: application/json" \
+  -d '{
+    "jsonrpc": "2.0",
+    "id": 1,
+    "method": "initialize",
+    "params": {
+      "protocolVersion": "2024-11-05",
+      "clientInfo": { "name": "test", "version": "1.0.0" },
+      "capabilities": {}
+    }
+  }'
+
+# Call a tool
+curl -X POST http://localhost:3000/mcp \
+  -H "Content-Type: application/json" \
+  -d '{
+    "jsonrpc": "2.0",
+    "id": 2,
+    "method": "tools/call",
+    "params": {
+      "name": "list_files",
+      "arguments": { "path": "." }
+    }
+  }'
+
+# Read a resource
+curl -X POST http://localhost:3000/mcp \
+  -H "Content-Type: application/json" \
+  -d '{
+    "jsonrpc": "2.0",
+    "id": 3,
+    "method": "resources/read",
+    "params": {
+      "uri": "file://read?path=package.json"
+    }
+  }'
+```
+
+## API Reference
+
+### registerMCPServer
+
+Main function to register MCP server with a Rikta application.
+
+```typescript
+async function registerMCPServer(
+  app: RiktaApplication,
+  options?: MCPServerOptions
+): Promise<void>
+```
+
+### mcpRegistry
+
+Access the MCP registry for advanced use cases.
+
+```typescript
+import { mcpRegistry } from '@riktajs/mcp';
+
+// Get all registered handlers
+const tools = mcpRegistry.getTools();
+const resources = mcpRegistry.getResources();
+const prompts = mcpRegistry.getPrompts();
+
+// Get stats
+const stats = mcpRegistry.getStats();
+// { tools: 5, resources: 2, prompts: 3 }
+```
+
+### Zod Re-exports
+
+For convenience, `z` from Zod is re-exported from this package:
+
+```typescript
+import { z } from '@riktajs/mcp';
+
+const schema = z.object({
+  name: z.string(),
+  age: z.number(),
+});
+```
+
+### Utility Functions
+
+```typescript
+import { zodToMCPSchema, isZodSchema } from '@riktajs/mcp';
+
+// Check if a value is a Zod schema
+if (isZodSchema(schema)) {
+  // Convert to JSON Schema for MCP
+  const jsonSchema = zodToMCPSchema(schema);
+}
+```
+
+## License
+
+MIT

package/dist/constants.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @riktajs/mcp - Constants
+ *
+ * Metadata keys for MCP decorators using Symbol.for() for cross-package sharing.
+ */
+/** Metadata key for @MCPTool decorator */
+export declare const MCP_TOOL_METADATA: unique symbol;
+/** Metadata key for @MCPResource decorator */
+export declare const MCP_RESOURCE_METADATA: unique symbol;
+/** Metadata key for @MCPPrompt decorator */
+export declare const MCP_PROMPT_METADATA: unique symbol;
+/** Metadata key for storing all MCP handler methods on a class */
+export declare const MCP_HANDLERS_METADATA: unique symbol;
+/** Metadata key to mark a class as an MCP service */
+export declare const MCP_SERVICE_METADATA: unique symbol;
+/** Default MCP endpoint path */
+export declare const DEFAULT_MCP_PATH = "/mcp";
+/** Default server info */
+export declare const DEFAULT_SERVER_INFO: {
+    readonly name: "rikta-mcp-server";
+    readonly version: "1.0.0";
+};
+//# sourceMappingURL=constants.d.ts.map

package/dist/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,0CAA0C;AAC1C,eAAO,MAAM,iBAAiB,eAA+B,CAAC;AAE9D,8CAA8C;AAC9C,eAAO,MAAM,qBAAqB,eAAmC,CAAC;AAEtE,4CAA4C;AAC5C,eAAO,MAAM,mBAAmB,eAAiC,CAAC;AAElE,kEAAkE;AAClE,eAAO,MAAM,qBAAqB,eAAmC,CAAC;AAEtE,qDAAqD;AACrD,eAAO,MAAM,oBAAoB,eAAkC,CAAC;AAEpE,gCAAgC;AAChC,eAAO,MAAM,gBAAgB,SAAS,CAAC;AAEvC,0BAA0B;AAC1B,eAAO,MAAM,mBAAmB;;;CAGtB,CAAC"}

package/dist/constants.js

@@ -0,0 +1,23 @@
+/**
+ * @riktajs/mcp - Constants
+ *
+ * Metadata keys for MCP decorators using Symbol.for() for cross-package sharing.
+ */
+/** Metadata key for @MCPTool decorator */
+export const MCP_TOOL_METADATA = Symbol.for('rikta:mcp:tool');
+/** Metadata key for @MCPResource decorator */
+export const MCP_RESOURCE_METADATA = Symbol.for('rikta:mcp:resource');
+/** Metadata key for @MCPPrompt decorator */
+export const MCP_PROMPT_METADATA = Symbol.for('rikta:mcp:prompt');
+/** Metadata key for storing all MCP handler methods on a class */
+export const MCP_HANDLERS_METADATA = Symbol.for('rikta:mcp:handlers');
+/** Metadata key to mark a class as an MCP service */
+export const MCP_SERVICE_METADATA = Symbol.for('rikta:mcp:service');
+/** Default MCP endpoint path */
+export const DEFAULT_MCP_PATH = '/mcp';
+/** Default server info */
+export const DEFAULT_SERVER_INFO = {
+    name: 'rikta-mcp-server',
+    version: '1.0.0',
+};
+//# sourceMappingURL=constants.js.map

package/dist/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,0CAA0C;AAC1C,MAAM,CAAC,MAAM,iBAAiB,GAAG,MAAM,CAAC,GAAG,CAAC,gBAAgB,CAAC,CAAC;AAE9D,8CAA8C;AAC9C,MAAM,CAAC,MAAM,qBAAqB,GAAG,MAAM,CAAC,GAAG,CAAC,oBAAoB,CAAC,CAAC;AAEtE,4CAA4C;AAC5C,MAAM,CAAC,MAAM,mBAAmB,GAAG,MAAM,CAAC,GAAG,CAAC,kBAAkB,CAAC,CAAC;AAElE,kEAAkE;AAClE,MAAM,CAAC,MAAM,qBAAqB,GAAG,MAAM,CAAC,GAAG,CAAC,oBAAoB,CAAC,CAAC;AAEtE,qDAAqD;AACrD,MAAM,CAAC,MAAM,oBAAoB,GAAG,MAAM,CAAC,GAAG,CAAC,mBAAmB,CAAC,CAAC;AAEpE,gCAAgC;AAChC,MAAM,CAAC,MAAM,gBAAgB,GAAG,MAAM,CAAC;AAEvC,0BAA0B;AAC1B,MAAM,CAAC,MAAM,mBAAmB,GAAG;IACjC,IAAI,EAAE,kBAAkB;IACxB,OAAO,EAAE,OAAO;CACR,CAAC"}

package/dist/decorators/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @riktajs/mcp - Decorators
+ *
+ * Export all MCP decorators from a single entry point.
+ */
+export { MCPTool, getMCPToolMetadata } from './mcp-tool.decorator.js';
+export { MCPResource, getMCPResourceMetadata } from './mcp-resource.decorator.js';
+export { MCPPrompt, getMCPPromptMetadata } from './mcp-prompt.decorator.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/decorators/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/decorators/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAE,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAGtE,OAAO,EAAE,WAAW,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAC;AAGlF,OAAO,EAAE,SAAS,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC"}

package/dist/decorators/index.js

@@ -0,0 +1,12 @@
+/**
+ * @riktajs/mcp - Decorators
+ *
+ * Export all MCP decorators from a single entry point.
+ */
+// Tool decorator
+export { MCPTool, getMCPToolMetadata } from './mcp-tool.decorator.js';
+// Resource decorator
+export { MCPResource, getMCPResourceMetadata } from './mcp-resource.decorator.js';
+// Prompt decorator
+export { MCPPrompt, getMCPPromptMetadata } from './mcp-prompt.decorator.js';
+//# sourceMappingURL=index.js.map

package/dist/decorators/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/decorators/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,iBAAiB;AACjB,OAAO,EAAE,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAEtE,qBAAqB;AACrB,OAAO,EAAE,WAAW,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAC;AAElF,mBAAmB;AACnB,OAAO,EAAE,SAAS,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC"}

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

@@ -0,0 +1,52 @@
+/**
+ * @MCPPrompt Decorator
+ *
+ * Marks a method as an MCP prompt template.
+ *
+ * @example
+ * ```typescript
+ * import { Injectable } from '@riktajs/core';
+ * import { MCPPrompt } from '@riktajs/mcp';
+ *
+ * @Injectable()
+ * class PromptService {
+ *   @MCPPrompt({
+ *     name: 'code_review',
+ *     description: 'Generate a code review prompt',
+ *     arguments: [
+ *       { name: 'language', description: 'Programming language', required: true },
+ *       { name: 'code', description: 'Code to review', required: true }
+ *     ]
+ *   })
+ *   async codeReview(args: { language: string; code: string }) {
+ *     return {
+ *       messages: [
+ *         {
+ *           role: 'user',
+ *           content: {
+ *             type: 'text',
+ *             text: `Please review this ${args.language} code:\n\n${args.code}`
+ *           }
+ *         }
+ *       ]
+ *     };
+ *   }
+ * }
+ * ```
+ */
+import 'reflect-metadata';
+import type { MCPPromptOptions } from '../types.js';
+/**
+ * @MCPPrompt() decorator
+ *
+ * Registers a method as an MCP prompt template.
+ *
+ * @param options - Prompt configuration options
+ */
+export declare function MCPPrompt(options: MCPPromptOptions): MethodDecorator;
+/**
+ * Get prompt metadata from a method
+ * @internal
+ */
+export declare function getMCPPromptMetadata(target: Function, propertyKey: string | symbol): MCPPromptOptions | undefined;
+//# sourceMappingURL=mcp-prompt.decorator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-prompt.decorator.d.ts","sourceRoot":"","sources":["../../src/decorators/mcp-prompt.decorator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,OAAO,kBAAkB,CAAC;AAE1B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAEpD;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,gBAAgB,GAAG,eAAe,CAkBpE;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,QAAQ,EAChB,WAAW,EAAE,MAAM,GAAG,MAAM,GAC3B,gBAAgB,GAAG,SAAS,CAE9B"}

package/dist/decorators/mcp-prompt.decorator.js

@@ -0,0 +1,64 @@
+/**
+ * @MCPPrompt Decorator
+ *
+ * Marks a method as an MCP prompt template.
+ *
+ * @example
+ * ```typescript
+ * import { Injectable } from '@riktajs/core';
+ * import { MCPPrompt } from '@riktajs/mcp';
+ *
+ * @Injectable()
+ * class PromptService {
+ *   @MCPPrompt({
+ *     name: 'code_review',
+ *     description: 'Generate a code review prompt',
+ *     arguments: [
+ *       { name: 'language', description: 'Programming language', required: true },
+ *       { name: 'code', description: 'Code to review', required: true }
+ *     ]
+ *   })
+ *   async codeReview(args: { language: string; code: string }) {
+ *     return {
+ *       messages: [
+ *         {
+ *           role: 'user',
+ *           content: {
+ *             type: 'text',
+ *             text: `Please review this ${args.language} code:\n\n${args.code}`
+ *           }
+ *         }
+ *       ]
+ *     };
+ *   }
+ * }
+ * ```
+ */
+import 'reflect-metadata';
+import { MCP_PROMPT_METADATA, MCP_HANDLERS_METADATA } from '../constants.js';
+/**
+ * @MCPPrompt() decorator
+ *
+ * Registers a method as an MCP prompt template.
+ *
+ * @param options - Prompt configuration options
+ */
+export function MCPPrompt(options) {
+    return (target, propertyKey, descriptor) => {
+        // Store prompt metadata on the method
+        Reflect.defineMetadata(MCP_PROMPT_METADATA, options, target, propertyKey);
+        // Add to the class's list of MCP handlers
+        const handlers = Reflect.getMetadata(MCP_HANDLERS_METADATA, target.constructor) || [];
+        handlers.push({ type: 'prompt', methodName: propertyKey });
+        Reflect.defineMetadata(MCP_HANDLERS_METADATA, handlers, target.constructor);
+        return descriptor;
+    };
+}
+/**
+ * Get prompt metadata from a method
+ * @internal
+ */
+export function getMCPPromptMetadata(target, propertyKey) {
+    return Reflect.getMetadata(MCP_PROMPT_METADATA, target.prototype, propertyKey);
+}
+//# sourceMappingURL=mcp-prompt.decorator.js.map

package/dist/decorators/mcp-prompt.decorator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-prompt.decorator.js","sourceRoot":"","sources":["../../src/decorators/mcp-prompt.decorator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,OAAO,kBAAkB,CAAC;AAC1B,OAAO,EAAE,mBAAmB,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AAG7E;;;;;;GAMG;AACH,MAAM,UAAU,SAAS,CAAC,OAAyB;IACjD,OAAO,CACL,MAAc,EACd,WAA4B,EAC5B,UAA8B,EACV,EAAE;QACtB,sCAAsC;QACtC,OAAO,CAAC,cAAc,CAAC,mBAAmB,EAAE,OAAO,EAAE,MAAM,EAAE,WAAW,CAAC,CAAC;QAE1E,0CAA0C;QAC1C,MAAM,QAAQ,GACZ,OAAO,CAAC,WAAW,CAAC,qBAAqB,EAAE,MAAM,CAAC,WAAW,CAAC,IAAI,EAAE,CAAC;QAEvE,QAAQ,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,UAAU,EAAE,WAAW,EAAE,CAAC,CAAC;QAC3D,OAAO,CAAC,cAAc,CAAC,qBAAqB,EAAE,QAAQ,EAAE,MAAM,CAAC,WAAW,CAAC,CAAC;QAE5E,OAAO,UAAU,CAAC;IACpB,CAAC,CAAC;AACJ,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,oBAAoB,CAClC,MAAgB,EAChB,WAA4B;IAE5B,OAAO,OAAO,CAAC,WAAW,CAAC,mBAAmB,EAAE,MAAM,CAAC,SAAS,EAAE,WAAW,CAAC,CAAC;AACjF,CAAC"}

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

@@ -0,0 +1,49 @@
+/**
+ * @MCPResource Decorator
+ *
+ * Marks a method as an MCP resource provider.
+ *
+ * @example
+ * ```typescript
+ * import { Injectable } from '@riktajs/core';
+ * import { MCPResource } from '@riktajs/mcp';
+ *
+ * @Injectable()
+ * class FileService {
+ *   @MCPResource({
+ *     uriPattern: 'file://read',
+ *     name: 'Read File',
+ *     description: 'Read file contents by path',
+ *     mimeType: 'text/plain'
+ *   })
+ *   async readFile(uri: string) {
+ *     const url = new URL(uri);
+ *     const filePath = url.searchParams.get('path');
+ *     const content = await fs.readFile(filePath!, 'utf-8');
+ *     return {
+ *       contents: [{
+ *         uri,
+ *         text: content,
+ *         mimeType: 'text/plain'
+ *       }]
+ *     };
+ *   }
+ * }
+ * ```
+ */
+import 'reflect-metadata';
+import type { MCPResourceOptions } from '../types.js';
+/**
+ * @MCPResource() decorator
+ *
+ * Registers a method as an MCP resource provider.
+ *
+ * @param options - Resource configuration options
+ */
+export declare function MCPResource(options: MCPResourceOptions): MethodDecorator;
+/**
+ * Get resource metadata from a method
+ * @internal
+ */
+export declare function getMCPResourceMetadata(target: Function, propertyKey: string | symbol): MCPResourceOptions | undefined;
+//# sourceMappingURL=mcp-resource.decorator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-resource.decorator.d.ts","sourceRoot":"","sources":["../../src/decorators/mcp-resource.decorator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,OAAO,kBAAkB,CAAC;AAE1B,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAEtD;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,kBAAkB,GAAG,eAAe,CAwBxE;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,QAAQ,EAChB,WAAW,EAAE,MAAM,GAAG,MAAM,GAC3B,kBAAkB,GAAG,SAAS,CAEhC"}