@rekog/mcp-nest 1.9.10 → 2.0.0-alpha.0

package/dist/mcp/transport/mcp-transport.constants.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MCP_SERVER_NAME_METADATA_KEY = exports.mcpTransportFor = exports.MCP_TRANSPORT = void 0;
+exports.buildMcpPattern = buildMcpPattern;
+exports.buildMcpHandlerExtras = buildMcpHandlerExtras;
+exports.MCP_TRANSPORT = Symbol.for('@rekog/mcp-nest:transport');
+const mcpTransportFor = (server) => server ? Symbol.for(`@rekog/mcp-nest:transport:${server}`) : exports.MCP_TRANSPORT;
+exports.mcpTransportFor = mcpTransportFor;
+exports.MCP_SERVER_NAME_METADATA_KEY = 'mcp:server-name';
+function buildMcpPattern(type, name) {
+    return { mcp: type, name };
+}
+function buildMcpHandlerExtras(type, name, methodKey, methodRef) {
+    return {
+        mcpType: type,
+        mcpName: name,
+        mcpMethodKey: methodKey,
+        mcpMethodRef: methodRef,
+    };
+}
+//# sourceMappingURL=mcp-transport.constants.js.map

package/dist/mcp/transport/mcp-transport.constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-transport.constants.js","sourceRoot":"","sources":["../../../src/mcp/transport/mcp-transport.constants.ts"],"names":[],"mappings":";;;AA+EA,0CAKC;AAED,sDAYC;AAlFY,QAAA,aAAa,GAAG,MAAM,CAAC,GAAG,CAAC,2BAA2B,CAAC,CAAC;AAe9D,MAAM,eAAe,GAAG,CAAC,MAAe,EAAU,EAAE,CACzD,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,6BAA6B,MAAM,EAAE,CAAC,CAAC,CAAC,CAAC,qBAAa,CAAC;AADhE,QAAA,eAAe,mBACiD;AAOhE,QAAA,4BAA4B,GAAG,iBAAiB,CAAC;AAwC9D,SAAgB,eAAe,CAC7B,IAAuB,EACvB,IAAY;IAEZ,OAAO,EAAE,GAAG,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC;AAC7B,CAAC;AAED,SAAgB,qBAAqB,CACnC,IAAuB,EACvB,IAAY,EACZ,SAAiB,EACjB,SAAuB;IAEvB,OAAO;QACL,OAAO,EAAE,IAAI;QACb,OAAO,EAAE,IAAI;QACb,YAAY,EAAE,SAAS;QACvB,YAAY,EAAE,SAAS;KACxB,CAAC;AACJ,CAAC","sourcesContent":["/**\n * Shared transport identifier for the MCP microservice strategy.\n *\n * Both the MCP capability decorators (`@Tool`, `@Resource`, `@ResourceTemplate`,\n * `@Prompt`) and the {@link McpStrategy} reference this exact symbol. NestJS\n * binds a `@MessagePattern` handler to a strategy only when the handler's\n * declared transport is undefined OR equals the strategy's `transportId`\n * (see `@nestjs/microservices` ListenersController). By tagging MCP handlers\n * with this symbol and setting it as the strategy's `transportId` we get mutual\n * exclusion: other microservice transports never bind MCP handlers, and the MCP\n * strategy prunes any stray non-MCP handler that matched via the undefined-transport\n * clause.\n *\n * Uses the global symbol registry (`Symbol.for`) so it stays stable even if the\n * package is duplicated across `node_modules`.\n */\nexport const MCP_TRANSPORT = Symbol.for('@rekog/mcp-nest:transport');\n\n/**\n * Transport id for a *named* MCP server, falling back to the default shared id\n * ({@link MCP_TRANSPORT}) when no name is given.\n *\n * Naming a server gives it its own transport id, so NestJS's existing\n * `transport === transportId` routing isolates each server's handlers natively:\n * only `@McpController({ server: <name> })` classes bind to the matching\n * `McpStrategy({ server: <name> })`. An unnamed controller + unnamed strategy\n * keep using {@link MCP_TRANSPORT} — i.e. the original single-server behavior.\n *\n * Uses the global symbol registry (`Symbol.for`) so the id stays stable even if\n * the package is duplicated across `node_modules`.\n */\nexport const mcpTransportFor = (server?: string): symbol =>\n  server ? Symbol.for(`@rekog/mcp-nest:transport:${server}`) : MCP_TRANSPORT;\n\n/**\n * Class-metadata key recording the logical server name an `@McpController` was\n * assigned to (via `@McpController({ server })`). Kept for diagnostics; the\n * actual routing is driven by the per-method transport id, not this key.\n */\nexport const MCP_SERVER_NAME_METADATA_KEY = 'mcp:server-name';\n\nexport type McpCapabilityType =\n  | 'tool'\n  | 'resource'\n  | 'resource-template'\n  | 'prompt';\n\n/**\n * Structured message pattern stored for every MCP capability handler. NestJS\n * normalizes object patterns by sorting keys and JSON-stringifying them, so the\n * strategy can deterministically rebuild a route from a discovered capability\n * name and look the handler up via `getHandlerByPattern`.\n */\nexport interface McpPattern {\n  mcp: McpCapabilityType;\n  name: string;\n  // Index signature keeps the pattern assignable to NestJS's MsObjectPattern.\n  [key: string]: string;\n}\n\n/**\n * Routing + metadata identity carried in the bound handler's `extras`.\n *\n * `mcpMethodRef` is the original decorated method (`descriptor.value`). NestJS\n * stores `extras` by reference on the handler, so at `listen()` time — after ALL\n * decorators on that method have run — the strategy reads every metadata key off\n * `mcpMethodRef` directly (`@Tool` options + `@ToolScopes`/`@ToolRoles`/etc.),\n * with no DI discovery service.\n */\n/** A decorated capability method reference (used to read its metadata at bind time). */\nexport type McpMethodRef = (...args: any[]) => any;\n\nexport interface McpHandlerExtras {\n  mcpType: McpCapabilityType;\n  mcpName: string;\n  mcpMethodKey: string;\n  mcpMethodRef: McpMethodRef;\n}\n\nexport function buildMcpPattern(\n  type: McpCapabilityType,\n  name: string,\n): McpPattern {\n  return { mcp: type, name };\n}\n\nexport function buildMcpHandlerExtras(\n  type: McpCapabilityType,\n  name: string,\n  methodKey: string,\n  methodRef: McpMethodRef,\n): McpHandlerExtras {\n  return {\n    mcpType: type,\n    mcpName: name,\n    mcpMethodKey: methodKey,\n    mcpMethodRef: methodRef,\n  };\n}\n"]}

package/dist/mcp/transport/mcp-transport.interface.d.ts

@@ -0,0 +1,17 @@
+import { HttpServer, Logger } from '@nestjs/common';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { McpServerOptions } from './mcp-server-options.interface';
+import { McpSessionInfo, McpTransportKind } from './mcp-context';
+export interface McpTransportContext {
+    createServer(): McpServer;
+    bindRequestHandlers(server: McpServer, session: Pick<McpSessionInfo, 'transport' | 'stateless' | 'sessionId'>, rawRequest?: unknown): void;
+    httpAdapter?: HttpServer;
+    options: McpServerOptions;
+    logger: Logger;
+}
+export interface McpTransport {
+    readonly kind: McpTransportKind;
+    start(ctx: McpTransportContext): Promise<void> | void;
+    close(): Promise<void> | void;
+}
+//# sourceMappingURL=mcp-transport.interface.d.ts.map

package/dist/mcp/transport/mcp-transport.interface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-transport.interface.d.ts","sourceRoot":"","sources":["../../../src/mcp/transport/mcp-transport.interface.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AACpD,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AACpE,OAAO,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAC;AAClE,OAAO,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAOjE,MAAM,WAAW,mBAAmB;IAMlC,YAAY,IAAI,SAAS,CAAC;IAO1B,mBAAmB,CACjB,MAAM,EAAE,SAAS,EACjB,OAAO,EAAE,IAAI,CAAC,cAAc,EAAE,WAAW,GAAG,WAAW,GAAG,WAAW,CAAC,EACtE,UAAU,CAAC,EAAE,OAAO,GACnB,IAAI,CAAC;IAGR,WAAW,CAAC,EAAE,UAAU,CAAC;IAGzB,OAAO,EAAE,gBAAgB,CAAC;IAG1B,MAAM,EAAE,MAAM,CAAC;CAChB;AAMD,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAC;IAEhC,KAAK,CAAC,GAAG,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IAEtD,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;CAC/B"}

package/dist/{authz/interfaces/oauth-common.interface.js → mcp/transport/mcp-transport.interface.js}

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=oauth-common.interface.js.map
+//# sourceMappingURL=mcp-transport.interface.js.map

package/dist/mcp/transport/mcp-transport.interface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-transport.interface.js","sourceRoot":"","sources":["../../../src/mcp/transport/mcp-transport.interface.ts"],"names":[],"mappings":"","sourcesContent":["import { HttpServer, Logger } from '@nestjs/common';\nimport { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';\nimport { McpServerOptions } from './mcp-server-options.interface';\nimport { McpSessionInfo, McpTransportKind } from './mcp-context';\n\n/**\n * The surface a transport receives from the {@link McpStrategy} when it starts.\n * Transports own the wire protocol; the strategy owns capability discovery,\n * the MCP request handlers, and routing into the NestJS RPC pipeline.\n */\nexport interface McpTransportContext {\n  /**\n   * Create a bare SDK `McpServer` (capabilities derived from discovery + any\n   * `serverMutator` applied). The caller is responsible for connecting it to an\n   * SDK transport and for calling {@link bindRequestHandlers}.\n   */\n  createServer(): McpServer;\n\n  /**\n   * (Re)register the MCP request handlers (tools/resources/prompts) on a server,\n   * bound to a specific incoming request. Call this per request for session-aware\n   * transports so the per-request `rawRequest` (auth context) is current.\n   */\n  bindRequestHandlers(\n    server: McpServer,\n    session: Pick<McpSessionInfo, 'transport' | 'stateless' | 'sessionId'>,\n    rawRequest?: unknown,\n  ): void;\n\n  /** The Nest HTTP adapter. Present whenever an HTTP-based transport is used. */\n  httpAdapter?: HttpServer;\n\n  /** The resolved strategy options. */\n  options: McpServerOptions;\n\n  /** A logger scoped to the MCP server. */\n  logger: Logger;\n}\n\n/**\n * A single MCP integration (stdio or streamable-HTTP). Implementations\n * are plain objects the user constructs and passes via {@link McpServerOptions.transports}.\n */\nexport interface McpTransport {\n  readonly kind: McpTransportKind;\n  /** Called once from {@link McpStrategy.listen}. */\n  start(ctx: McpTransportContext): Promise<void> | void;\n  /** Called from {@link McpStrategy.close}. */\n  close(): Promise<void> | void;\n}\n"]}

package/dist/mcp/transport/mcp.strategy.d.ts

@@ -0,0 +1,56 @@
+import { HttpServer, Logger } from '@nestjs/common';
+import { CustomTransportStrategy, Server } from '@nestjs/microservices';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { DynamicPromptDefinition, DynamicResourceDefinition, DynamicToolDefinition } from '../interfaces';
+import { McpSessionInfo } from './mcp-context';
+import { McpServerOptions } from './mcp-server-options.interface';
+export declare const MCP_STRATEGY = "MCP_STRATEGY";
+export declare class McpStrategy extends Server implements CustomTransportStrategy {
+    readonly options: McpServerOptions;
+    transportId: symbol;
+    readonly moduleId: string;
+    protected readonly logger: Logger;
+    private readonly authService;
+    private httpAdapter?;
+    private built;
+    private readonly tools;
+    private readonly resources;
+    private readonly templates;
+    private readonly prompts;
+    private readonly dynamicTools;
+    private readonly dynamicResources;
+    private readonly dynamicPrompts;
+    private readonly eventListeners;
+    constructor(options: McpServerOptions);
+    setHttpAdapter(adapter: HttpServer): void;
+    listen(callback: (err?: unknown, ...args: unknown[]) => void): Promise<void>;
+    close(): Promise<void>;
+    on<EventKey extends string = string, EventCallback extends Function = Function>(event: EventKey, callback: EventCallback): void;
+    unwrap<T>(): T;
+    private warnIfNamedServerHasNoDecoratorCapabilities;
+    private buildCapabilities;
+    private readToolMetadata;
+    private readMetadata;
+    private getTools;
+    private getResources;
+    private getTemplates;
+    private getPrompts;
+    private createTransportContext;
+    private createServer;
+    bindRequestHandlers(server: McpServer, session: Pick<McpSessionInfo, 'transport' | 'stateless' | 'sessionId'>, rawRequest?: unknown): void;
+    private buildContext;
+    private getUser;
+    private bindToolHandlers;
+    private bindResourceHandlers;
+    private bindPromptHandlers;
+    private invokeViaPipeline;
+    private formatToolResult;
+    private toErrorResult;
+    registerTool(definition: DynamicToolDefinition): void;
+    registerResource(definition: DynamicResourceDefinition): void;
+    registerPrompt(definition: DynamicPromptDefinition): void;
+    removeTool(name: string): void;
+    removeResource(uri: string): void;
+    removePrompt(name: string): void;
+}
+//# sourceMappingURL=mcp.strategy.d.ts.map

package/dist/mcp/transport/mcp.strategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp.strategy.d.ts","sourceRoot":"","sources":["../../../src/mcp/transport/mcp.strategy.ts"],"names":[],"mappings":"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"}

package/dist/mcp/transport/mcp.strategy.js

@@ -0,0 +1,446 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.McpStrategy = exports.MCP_STRATEGY = void 0;
+const microservices_1 = require("@nestjs/microservices");
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+const zod_json_schema_compat_js_1 = require("@modelcontextprotocol/sdk/server/zod-json-schema-compat.js");
+const zod_compat_js_1 = require("@modelcontextprotocol/sdk/server/zod-compat.js");
+const rxjs_1 = require("rxjs");
+const zod_1 = require("zod");
+const decorators_1 = require("../decorators");
+const tool_authorization_service_1 = require("../services/tool-authorization.service");
+const mcp_logger_factory_1 = require("../utils/mcp-logger.factory");
+const mcp_transport_constants_1 = require("./mcp-transport.constants");
+const mcp_context_1 = require("./mcp-context");
+const resource_matcher_1 = require("./resource-matcher");
+exports.MCP_STRATEGY = 'MCP_STRATEGY';
+let strategyIdCounter = 0;
+class McpStrategy extends microservices_1.Server {
+    constructor(options) {
+        super();
+        this.options = options;
+        this.authService = new tool_authorization_service_1.ToolAuthorizationService();
+        this.built = false;
+        this.tools = [];
+        this.resources = [];
+        this.templates = [];
+        this.prompts = [];
+        this.dynamicTools = new Map();
+        this.dynamicResources = new Map();
+        this.dynamicPrompts = new Map();
+        this.eventListeners = new Map();
+        this.transportId = (0, mcp_transport_constants_1.mcpTransportFor)(options.server);
+        this.moduleId = `mcp-strategy-${strategyIdCounter++}`;
+        this.httpAdapter = options.httpAdapter;
+        this.logger = (0, mcp_logger_factory_1.createMcpLogger)(McpStrategy.name, this.options);
+    }
+    setHttpAdapter(adapter) {
+        this.httpAdapter = adapter;
+    }
+    async listen(callback) {
+        try {
+            this.buildCapabilities();
+            this.warnIfNamedServerHasNoDecoratorCapabilities();
+            const ctx = this.createTransportContext();
+            for (const transport of this.options.transports) {
+                await transport.start(ctx);
+            }
+            callback();
+        }
+        catch (err) {
+            this.logger.error('Failed to start MCP strategy', err);
+            callback(err);
+        }
+    }
+    async close() {
+        for (const transport of this.options.transports) {
+            try {
+                await transport.close();
+            }
+            catch (err) {
+                this.logger.error('Error closing MCP transport', err);
+            }
+        }
+        this.eventListeners.clear();
+    }
+    on(event, callback) {
+        const list = this.eventListeners.get(event) ?? [];
+        list.push(callback);
+        this.eventListeners.set(event, list);
+    }
+    unwrap() {
+        return {
+            transports: this.options.transports,
+            httpAdapter: this.httpAdapter,
+        };
+    }
+    warnIfNamedServerHasNoDecoratorCapabilities() {
+        if (!this.options.server)
+            return;
+        const decoratorCount = this.tools.length +
+            this.resources.length +
+            this.templates.length +
+            this.prompts.length;
+        if (decoratorCount > 0)
+            return;
+        this.logger.warn(`MCP server '${this.options.server}' started with no @McpController ` +
+            `capabilities bound to it. Check that a @McpController({ server: ` +
+            `'${this.options.server}' }) exists and is listed in a module's ` +
+            `controllers. (Safe to ignore if this server is populated at runtime ` +
+            `via strategy.registerTool()/registerResource()/registerPrompt().)`);
+    }
+    buildCapabilities() {
+        if (this.built)
+            return;
+        this.built = true;
+        for (const [route, handler] of this.messageHandlers) {
+            const extras = handler
+                .extras;
+            if (!extras?.mcpType) {
+                this.messageHandlers.delete(route);
+                continue;
+            }
+            const { mcpType, mcpMethodKey, mcpMethodRef } = extras;
+            const invoke = (payload, ctx) => this.invokeViaPipeline(handler, payload, ctx);
+            switch (mcpType) {
+                case 'tool':
+                    this.tools.push({
+                        metadata: this.readToolMetadata(mcpMethodRef, mcpMethodKey),
+                        invoke,
+                    });
+                    break;
+                case 'resource':
+                    this.resources.push({
+                        metadata: this.readMetadata(decorators_1.MCP_RESOURCE_METADATA_KEY, mcpMethodRef, mcpMethodKey),
+                        invoke,
+                    });
+                    break;
+                case 'resource-template':
+                    this.templates.push({
+                        metadata: this.readMetadata(decorators_1.MCP_RESOURCE_TEMPLATE_METADATA_KEY, mcpMethodRef, mcpMethodKey),
+                        invoke,
+                    });
+                    break;
+                case 'prompt':
+                    this.prompts.push({
+                        metadata: this.readMetadata(decorators_1.MCP_PROMPT_METADATA_KEY, mcpMethodRef, mcpMethodKey),
+                        invoke,
+                    });
+                    break;
+            }
+        }
+    }
+    readToolMetadata(methodRef, methodKey) {
+        const base = {
+            ...Reflect.getMetadata(decorators_1.MCP_TOOL_METADATA_KEY, methodRef),
+        };
+        if (!base.name)
+            base.name = methodKey;
+        if (!base.parameters)
+            base.parameters = zod_1.z.object({});
+        const isPublic = Reflect.getMetadata(decorators_1.MCP_PUBLIC_METADATA_KEY, methodRef);
+        const requiredScopes = Reflect.getMetadata(decorators_1.MCP_SCOPES_METADATA_KEY, methodRef);
+        const requiredRoles = Reflect.getMetadata(decorators_1.MCP_ROLES_METADATA_KEY, methodRef);
+        if (isPublic !== undefined)
+            base.isPublic = isPublic;
+        if (requiredScopes)
+            base.requiredScopes = requiredScopes;
+        if (requiredRoles)
+            base.requiredRoles = requiredRoles;
+        return base;
+    }
+    readMetadata(key, methodRef, methodKey) {
+        const metadata = { ...Reflect.getMetadata(key, methodRef) };
+        if (!metadata.name)
+            metadata.name = methodKey;
+        return metadata;
+    }
+    getTools() {
+        return [...this.tools, ...this.dynamicTools.values()];
+    }
+    getResources() {
+        return [...this.resources, ...this.dynamicResources.values()];
+    }
+    getTemplates() {
+        return [...this.templates];
+    }
+    getPrompts() {
+        return [...this.prompts, ...this.dynamicPrompts.values()];
+    }
+    createTransportContext() {
+        return {
+            createServer: () => this.createServer(),
+            bindRequestHandlers: (server, session, rawRequest) => this.bindRequestHandlers(server, session, rawRequest),
+            httpAdapter: this.httpAdapter,
+            options: this.options,
+            logger: this.logger,
+        };
+    }
+    createServer() {
+        const capabilities = {
+            ...(this.options.capabilities ?? {}),
+        };
+        if (this.getTools().length > 0) {
+            capabilities.tools = capabilities.tools ?? { listChanged: true };
+        }
+        if (this.getResources().length + this.getTemplates().length > 0) {
+            capabilities.resources = capabilities.resources ?? { listChanged: true };
+        }
+        if (this.getPrompts().length > 0) {
+            capabilities.prompts = capabilities.prompts ?? { listChanged: true };
+        }
+        const server = new mcp_js_1.McpServer({
+            name: this.options.name,
+            version: this.options.version,
+            ...(this.options.title && { title: this.options.title }),
+            ...(this.options.description && {
+                description: this.options.description,
+            }),
+            ...(this.options.websiteUrl && { websiteUrl: this.options.websiteUrl }),
+            ...(this.options.icons && { icons: this.options.icons }),
+        }, { capabilities, instructions: this.options.instructions ?? '' });
+        return this.options.serverMutator
+            ? this.options.serverMutator(server)
+            : server;
+    }
+    bindRequestHandlers(server, session, rawRequest) {
+        this.bindToolHandlers(server, session, rawRequest);
+        this.bindResourceHandlers(server, session, rawRequest);
+        this.bindPromptHandlers(server, session, rawRequest);
+    }
+    buildContext(server, request, session, rawRequest) {
+        const sessionId = session.sessionId ??
+            server.server.transport
+                ?.sessionId;
+        return new mcp_context_1.McpContext([server, request, { ...session, sessionId }, rawRequest], this.logger);
+    }
+    getUser(rawRequest) {
+        return rawRequest ? rawRequest.user : undefined;
+    }
+    bindToolHandlers(server, session, rawRequest) {
+        if (this.getTools().length === 0)
+            return;
+        const allowUnauthenticatedAccess = this.options.allowUnauthenticatedAccess ?? false;
+        server.server.setRequestHandler(types_js_1.ListToolsRequestSchema, () => {
+            const user = this.getUser(rawRequest);
+            const tools = this.getTools()
+                .filter((tool) => this.authService.canAccessTool(user, tool, allowUnauthenticatedAccess))
+                .map((tool) => {
+                const schema = {
+                    name: tool.metadata.name,
+                    description: tool.metadata.description,
+                    annotations: tool.metadata.annotations,
+                    _meta: tool.metadata._meta,
+                };
+                const securitySchemes = this.authService.generateSecuritySchemes(tool, allowUnauthenticatedAccess);
+                if (securitySchemes.length > 0) {
+                    schema._meta = { ...schema._meta, securitySchemes };
+                }
+                const input = (0, zod_compat_js_1.normalizeObjectSchema)(tool.metadata.parameters);
+                if (input)
+                    schema.inputSchema = (0, zod_json_schema_compat_js_1.toJsonSchemaCompat)(input);
+                const output = (0, zod_compat_js_1.normalizeObjectSchema)(tool.metadata.outputSchema);
+                if (output) {
+                    schema.outputSchema = {
+                        ...(0, zod_json_schema_compat_js_1.toJsonSchemaCompat)(output),
+                        type: 'object',
+                    };
+                }
+                return schema;
+            });
+            return { tools };
+        });
+        server.server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
+            const tool = this.getTools().find((t) => t.metadata.name === request.params.name);
+            if (!tool) {
+                throw new types_js_1.McpError(types_js_1.ErrorCode.MethodNotFound, `Unknown tool: ${request.params.name}`);
+            }
+            this.authService.validateToolAccess(this.getUser(rawRequest), tool, allowUnauthenticatedAccess);
+            if (tool.metadata.parameters) {
+                const validation = tool.metadata.parameters.safeParse(request.params.arguments ?? {});
+                if (!validation.success) {
+                    const issues = validation.error.issues
+                        .map((issue) => {
+                        const path = issue.path.length > 0 ? issue.path.join('.') : '';
+                        return `${path ? `[${path}]: ` : ''}${issue.message}`;
+                    })
+                        .join('; ');
+                    return {
+                        content: [{ type: 'text', text: `Invalid parameters: ${issues}` }],
+                        isError: true,
+                    };
+                }
+                request.params.arguments = validation.data;
+            }
+            const ctx = this.buildContext(server, request, session, rawRequest);
+            try {
+                const result = await tool.invoke(request.params.arguments ?? {}, ctx);
+                return this.formatToolResult(result, tool.metadata.outputSchema);
+            }
+            catch (error) {
+                return this.toErrorResult(error);
+            }
+        });
+    }
+    bindResourceHandlers(server, session, rawRequest) {
+        if (this.getResources().length + this.getTemplates().length === 0)
+            return;
+        server.server.setRequestHandler(types_js_1.ListResourcesRequestSchema, () => ({
+            resources: this.getResources().map((r) => r.metadata),
+        }));
+        server.server.setRequestHandler(types_js_1.ListResourceTemplatesRequestSchema, () => ({
+            resourceTemplates: this.getTemplates().map((r) => r.metadata),
+        }));
+        server.server.setRequestHandler(types_js_1.ReadResourceRequestSchema, async (request) => {
+            const uri = request.params.uri;
+            const templateMatch = (0, resource_matcher_1.matchResourceTemplateByUri)(this.getTemplates().map((cap) => ({
+                uriTemplate: cap.metadata.uriTemplate,
+                cap,
+            })), uri);
+            const resourceMatch = (0, resource_matcher_1.matchResourceByUri)(this.getResources().map((cap) => ({ uri: cap.metadata.uri, cap })), uri);
+            let invoke;
+            let params;
+            if (templateMatch) {
+                invoke = templateMatch.template.cap.invoke;
+                params = { ...templateMatch.params, ...request.params };
+            }
+            else if (resourceMatch) {
+                invoke = resourceMatch.resource.cap.invoke;
+                params = { ...resourceMatch.params, ...request.params };
+            }
+            else {
+                throw new types_js_1.McpError(types_js_1.ErrorCode.MethodNotFound, `Unknown resource: ${uri}`);
+            }
+            const ctx = this.buildContext(server, request, session, rawRequest);
+            return (await invoke(params, ctx));
+        });
+    }
+    bindPromptHandlers(server, session, rawRequest) {
+        if (this.getPrompts().length === 0)
+            return;
+        server.server.setRequestHandler(types_js_1.ListPromptsRequestSchema, () => ({
+            prompts: this.getPrompts().map((prompt) => ({
+                name: prompt.metadata.name,
+                description: prompt.metadata.description,
+                arguments: prompt.metadata.parameters
+                    ? Object.entries(prompt.metadata.parameters.shape).map(([name, field]) => ({
+                        name,
+                        description: field.description,
+                        required: !field.isOptional(),
+                    }))
+                    : [],
+            })),
+        }));
+        server.server.setRequestHandler(types_js_1.GetPromptRequestSchema, async (request) => {
+            const prompt = this.getPrompts().find((p) => p.metadata.name === request.params.name);
+            if (!prompt) {
+                throw new types_js_1.McpError(types_js_1.ErrorCode.MethodNotFound, `Unknown prompt: ${request.params.name}`);
+            }
+            const ctx = this.buildContext(server, request, session, rawRequest);
+            return (await prompt.invoke(request.params.arguments, ctx));
+        });
+    }
+    async invokeViaPipeline(handler, payload, ctx) {
+        let resultPromise;
+        const done = () => {
+            resultPromise = (async () => {
+                const resultOrStream = await handler(payload, ctx);
+                return (0, rxjs_1.firstValueFrom)(this.transformToObservable(resultOrStream));
+            })();
+            return resultPromise;
+        };
+        await Promise.resolve(this.onProcessingStartHook(this.transportId, ctx, done));
+        try {
+            return await resultPromise;
+        }
+        finally {
+            this.onProcessingEndHook?.(this.transportId, ctx);
+        }
+    }
+    formatToolResult(result, outputSchema) {
+        if (result && typeof result === 'object' && Array.isArray(result.content)) {
+            return result;
+        }
+        const defaultContent = [{ type: 'text', text: JSON.stringify(result) }];
+        if (outputSchema) {
+            const validation = outputSchema.safeParse(result);
+            if (!validation.success) {
+                throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Tool result does not match outputSchema: ${validation.error.message}`);
+            }
+            return { structuredContent: validation.data, content: defaultContent };
+        }
+        return { content: defaultContent };
+    }
+    toErrorResult(error) {
+        if (error instanceof types_js_1.McpError) {
+            throw error;
+        }
+        let message = 'Internal server error';
+        if (error instanceof Error) {
+            message = error.message;
+        }
+        else if (typeof error === 'string') {
+            message = error;
+        }
+        else if (error &&
+            typeof error === 'object' &&
+            typeof error.message === 'string') {
+            message = error.message;
+        }
+        this.logger.error(message);
+        return { content: [{ type: 'text', text: message }], isError: true };
+    }
+    registerTool(definition) {
+        const handler = definition.handler;
+        this.dynamicTools.set(definition.name, {
+            metadata: {
+                name: definition.name,
+                description: definition.description,
+                parameters: definition.parameters ?? zod_1.z.object({}),
+                outputSchema: definition.outputSchema,
+                annotations: definition.annotations,
+                _meta: definition._meta,
+                isPublic: definition.isPublic,
+                requiredScopes: definition.requiredScopes,
+                requiredRoles: definition.requiredRoles,
+            },
+            invoke: (payload, ctx) => Promise.resolve(handler(payload, ctx, ctx.getRawRequest())),
+        });
+    }
+    registerResource(definition) {
+        const handler = definition.handler;
+        this.dynamicResources.set(definition.uri, {
+            metadata: {
+                uri: definition.uri,
+                name: definition.name ?? definition.uri,
+                description: definition.description,
+                mimeType: definition.mimeType,
+                _meta: definition._meta,
+            },
+            invoke: (payload, ctx) => Promise.resolve(handler(payload, ctx, ctx.getRawRequest())),
+        });
+    }
+    registerPrompt(definition) {
+        const handler = definition.handler;
+        this.dynamicPrompts.set(definition.name, {
+            metadata: {
+                name: definition.name,
+                description: definition.description,
+                parameters: definition.parameters,
+            },
+            invoke: (payload, ctx) => Promise.resolve(handler(payload, ctx, ctx.getRawRequest())),
+        });
+    }
+    removeTool(name) {
+        this.dynamicTools.delete(name);
+    }
+    removeResource(uri) {
+        this.dynamicResources.delete(uri);
+    }
+    removePrompt(name) {
+        this.dynamicPrompts.delete(name);
+    }
+}
+exports.McpStrategy = McpStrategy;
+//# sourceMappingURL=mcp.strategy.js.map