@vritti/api-sdk 0.4.7 → 0.4.9

package/dist/mcp.cjs

@@ -0,0 +1,814 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/mcp/index.ts
+var mcp_exports = {};
+__export(mcp_exports, {
+  MCP_PRINCIPAL_FACTORY: () => MCP_PRINCIPAL_FACTORY,
+  MCP_SERVER_OPTIONS: () => MCP_SERVER_OPTIONS,
+  MCP_TOOL_PROVIDER_KEY: () => MCP_TOOL_PROVIDER_KEY,
+  McpModule: () => McpModule,
+  McpPrincipal: () => McpPrincipal,
+  McpRequestHandler: () => McpRequestHandler,
+  McpSchemaRegistry: () => McpSchemaRegistry,
+  McpServerFactory: () => McpServerFactory,
+  McpTools: () => McpTools,
+  McpTransportFactory: () => McpTransportFactory,
+  McpValidationError: () => McpValidationError,
+  ToolRegistry: () => ToolRegistry,
+  collectOperationIds: () => collectOperationIds,
+  defineTool: () => defineTool,
+  principalFromOAuth: () => principalFromOAuth,
+  problemFromError: () => problemFromError,
+  toolError: () => toolError,
+  toolOk: () => toolOk,
+  validateDto: () => validateDto
+});
+module.exports = __toCommonJS(mcp_exports);
+
+// src/mcp/coverage.ts
+var import_constants = require("@nestjs/common/constants");
+function collectOperationIds(modules) {
+  const ids = [];
+  for (const module2 of modules) {
+    const controllers = Reflect.getMetadata(import_constants.MODULE_METADATA.CONTROLLERS, module2) ?? [];
+    for (const controller of controllers) {
+      const prototype = controller.prototype;
+      for (const method of Object.getOwnPropertyNames(prototype)) {
+        if (method === "constructor") continue;
+        const handler = prototype[method];
+        if (typeof handler !== "function") continue;
+        if (Reflect.getMetadata(import_constants.METHOD_METADATA, handler) === void 0) continue;
+        ids.push(`${controller.name}_${method}`);
+      }
+    }
+  }
+  return ids;
+}
+__name(collectOperationIds, "collectOperationIds");
+
+// src/mcp/mcp.module.ts
+var import_common27 = require("@nestjs/common");
+var import_core2 = require("@nestjs/core");
+
+// src/mcp/mcp.options.ts
+var MCP_SERVER_OPTIONS = /* @__PURE__ */ Symbol("MCP_SERVER_OPTIONS");
+
+// src/exceptions/bad-gateway.exception.ts
+var import_common2 = require("@nestjs/common");
+
+// src/exceptions/base-field.exception.ts
+var import_common = require("@nestjs/common");
+var HttpProblemException = class extends import_common.HttpException {
+  static {
+    __name(this, "HttpProblemException");
+  }
+  constructor(detailOrOptions, httpStatus) {
+    const options = typeof detailOrOptions === "string" ? {
+      detail: detailOrOptions
+    } : detailOrOptions;
+    super({
+      type: options.type ?? "about:blank",
+      label: options.label,
+      detail: options.detail,
+      errors: options.errors ?? []
+    }, httpStatus);
+  }
+};
+
+// src/exceptions/bad-request.exception.ts
+var import_common3 = require("@nestjs/common");
+var BadRequestException = class extends HttpProblemException {
+  static {
+    __name(this, "BadRequestException");
+  }
+  constructor(detailOrOptions) {
+    super(detailOrOptions ?? "Bad Request", import_common3.HttpStatus.BAD_REQUEST);
+  }
+};
+
+// src/exceptions/conflict.exception.ts
+var import_common4 = require("@nestjs/common");
+
+// src/exceptions/forbidden.exception.ts
+var import_common5 = require("@nestjs/common");
+
+// src/exceptions/gone.exception.ts
+var import_common6 = require("@nestjs/common");
+
+// src/exceptions/internal-server-error.exception.ts
+var import_common7 = require("@nestjs/common");
+
+// src/exceptions/method-not-allowed.exception.ts
+var import_common8 = require("@nestjs/common");
+
+// src/exceptions/not-acceptable.exception.ts
+var import_common9 = require("@nestjs/common");
+
+// src/exceptions/not-found.exception.ts
+var import_common10 = require("@nestjs/common");
+
+// src/exceptions/not-implemented.exception.ts
+var import_common11 = require("@nestjs/common");
+
+// src/exceptions/payload-too-large.exception.ts
+var import_common12 = require("@nestjs/common");
+
+// src/exceptions/request-timeout.exception.ts
+var import_common13 = require("@nestjs/common");
+
+// src/exceptions/service-unavailable.exception.ts
+var import_common14 = require("@nestjs/common");
+
+// src/exceptions/too-many-requests.exception.ts
+var import_common15 = require("@nestjs/common");
+
+// src/exceptions/unauthorized.exception.ts
+var import_common16 = require("@nestjs/common");
+var UnauthorizedException = class extends HttpProblemException {
+  static {
+    __name(this, "UnauthorizedException");
+  }
+  constructor(detailOrOptions) {
+    super(detailOrOptions ?? "Unauthorized", import_common16.HttpStatus.UNAUTHORIZED);
+  }
+};
+
+// src/exceptions/unprocessable-entity.exception.ts
+var import_common17 = require("@nestjs/common");
+
+// src/exceptions/unsupported-media-type.exception.ts
+var import_common18 = require("@nestjs/common");
+
+// src/exceptions/validation.exception.ts
+var import_common19 = require("@nestjs/common");
+
+// src/mcp/mcp-principal.ts
+var McpPrincipal = class {
+  static {
+    __name(this, "McpPrincipal");
+  }
+  userId;
+  scopes;
+  clientId;
+  grantId;
+  organizationId;
+  constructor(userId, scopes, clientId, grantId, organizationId) {
+    this.userId = userId;
+    this.scopes = scopes;
+    this.clientId = clientId;
+    this.grantId = grantId;
+    this.organizationId = organizationId;
+  }
+  hasScope(scope) {
+    return this.scopes.includes(scope);
+  }
+};
+var MCP_PRINCIPAL_FACTORY = /* @__PURE__ */ Symbol("MCP_PRINCIPAL_FACTORY");
+function principalFromOAuth(request) {
+  const auth = request.auth;
+  if (!auth || auth.kind !== "oauth" || !auth.userId || !auth.grantId) {
+    throw new UnauthorizedException("MCP request is not authenticated.");
+  }
+  return new McpPrincipal(auth.userId, auth.scopes ?? [], auth.clientId, auth.grantId, auth.organizationId);
+}
+__name(principalFromOAuth, "principalFromOAuth");
+
+// src/mcp/mcp-request.handler.ts
+var import_common25 = require("@nestjs/common");
+
+// src/mcp/mcp-server.factory.ts
+var import_server = require("@modelcontextprotocol/sdk/server/index.js");
+var import_types = require("@modelcontextprotocol/sdk/types.js");
+var import_common23 = require("@nestjs/common");
+
+// src/mcp/tool-registry.ts
+var import_common22 = require("@nestjs/common");
+var import_core = require("@nestjs/core");
+var import_zod2 = require("zod");
+
+// src/mcp/tool-definition.ts
+var import_common20 = require("@nestjs/common");
+var MCP_TOOL_PROVIDER_KEY = "mcp:tool-provider";
+var McpTools = /* @__PURE__ */ __name(() => (0, import_common20.SetMetadata)(MCP_TOOL_PROVIDER_KEY, true), "McpTools");
+function defineTool(definition) {
+  return definition;
+}
+__name(defineTool, "defineTool");
+
+// src/mcp/tool-result.ts
+var import_common21 = require("@nestjs/common");
+var import_zod = require("zod");
+var PG_UNIQUE_VIOLATION = "23505";
+var logger = new import_common21.Logger("McpTool");
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+__name(isRecord, "isRecord");
+function isHttpExceptionLike(value) {
+  return isRecord(value) && typeof value.getStatus === "function" && typeof value.getResponse === "function";
+}
+__name(isHttpExceptionLike, "isHttpExceptionLike");
+function findPgUniqueViolation(error, depth = 0) {
+  if (!isRecord(error) || depth > 5) return void 0;
+  if (error.code === PG_UNIQUE_VIOLATION) return {
+    detail: typeof error.detail === "string" ? error.detail : void 0
+  };
+  return findPgUniqueViolation(error.cause, depth + 1);
+}
+__name(findPgUniqueViolation, "findPgUniqueViolation");
+function normalizeFieldErrors(value) {
+  if (!Array.isArray(value)) return [];
+  return value.filter(isRecord).map((entry) => ({
+    field: typeof entry.field === "string" ? entry.field : void 0,
+    message: typeof entry.message === "string" ? entry.message : "Invalid value"
+  }));
+}
+__name(normalizeFieldErrors, "normalizeFieldErrors");
+function toolOk(payload) {
+  const structuredContent = isRecord(payload) ? payload : {
+    result: payload
+  };
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(payload)
+      }
+    ],
+    structuredContent
+  };
+}
+__name(toolOk, "toolOk");
+function toolError(problem) {
+  return {
+    isError: true,
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(problem)
+      }
+    ],
+    structuredContent: {
+      ...problem
+    }
+  };
+}
+__name(toolError, "toolError");
+function problemFromError(error) {
+  if (error instanceof import_zod.ZodError) {
+    return {
+      status: 400,
+      label: "Invalid Arguments",
+      detail: "The tool arguments did not match the schema.",
+      errors: error.issues.map((issue) => ({
+        field: issue.path.join("."),
+        message: issue.message
+      }))
+    };
+  }
+  if (isHttpExceptionLike(error)) {
+    const status = error.getStatus();
+    const body = error.getResponse();
+    if (isRecord(body)) {
+      const detail = typeof body.detail === "string" ? body.detail : typeof body.message === "string" ? body.message : "Request failed.";
+      return {
+        status,
+        label: typeof body.label === "string" ? body.label : void 0,
+        detail,
+        errors: normalizeFieldErrors(body.errors)
+      };
+    }
+    return {
+      status,
+      detail: typeof body === "string" ? body : "Request failed.",
+      errors: []
+    };
+  }
+  const duplicate = findPgUniqueViolation(error);
+  if (duplicate) {
+    return {
+      status: 409,
+      label: "Duplicate Entry",
+      detail: duplicate.detail ?? "A record with these values already exists.",
+      errors: []
+    };
+  }
+  logger.error(`Unhandled tool error: ${error instanceof Error ? error.stack : String(error)}`);
+  return {
+    status: 500,
+    detail: "An unexpected error occurred.",
+    errors: []
+  };
+}
+__name(problemFromError, "problemFromError");
+
+// src/mcp/tool-registry.ts
+function _ts_decorate(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;
+}
+__name(_ts_decorate, "_ts_decorate");
+function _ts_metadata(metadataKey, metadataValue) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+    return Reflect.metadata(metadataKey, metadataValue);
+  }
+}
+__name(_ts_metadata, "_ts_metadata");
+var TOOL_NAME_PATTERN = /^[a-zA-Z0-9_-]{1,64}$/;
+var ToolRegistry = class _ToolRegistry {
+  static {
+    __name(this, "ToolRegistry");
+  }
+  discovery;
+  reflector;
+  logger = new import_common22.Logger(_ToolRegistry.name);
+  definitions = /* @__PURE__ */ new Map();
+  catalog = [];
+  constructor(discovery, reflector) {
+    this.discovery = discovery;
+    this.reflector = reflector;
+  }
+  // After every module has initialised, so providers from any module are instantiated and discoverable
+  onApplicationBootstrap() {
+    for (const provider of this.findProviders()) {
+      for (const definition of provider.tools()) this.register(definition);
+    }
+    this.catalog = [
+      ...this.definitions.values()
+    ].map((definition) => this.toCatalogEntry(definition));
+    this.logger.log(`Registered ${this.catalog.length} MCP tools`);
+  }
+  listTools() {
+    return this.catalog;
+  }
+  // Every REST operation the tools stand in for — a coverage test compares this with the live route set
+  coveredOperationIds() {
+    return [
+      ...this.definitions.values()
+    ].flatMap((definition) => [
+      ...definition.covers
+    ]);
+  }
+  async execute(name, rawArgs, principal) {
+    const started = Date.now();
+    const definition = this.definitions.get(name);
+    if (!definition) {
+      return toolError({
+        status: 404,
+        label: "Unknown Tool",
+        detail: `No tool named "${name}".`,
+        errors: []
+      });
+    }
+    let status = 200;
+    let result;
+    if (!principal.hasScope(definition.requiredScope)) {
+      status = 403;
+      result = toolError({
+        status,
+        label: "Insufficient Scope",
+        detail: `Tool "${name}" requires the ${definition.requiredScope} scope. Reconnect the client and grant it.`,
+        errors: []
+      });
+    } else {
+      try {
+        const args = definition.inputSchema.parse(rawArgs ?? {});
+        result = toolOk(await definition.handler(principal, args));
+      } catch (error) {
+        const problem = problemFromError(error);
+        status = problem.status;
+        result = toolError(problem);
+      }
+    }
+    this.logger.log(`mcp tool=${name} user=${principal.userId} grant=${principal.grantId ?? "-"} client=${principal.clientId ?? "-"} scope=${definition.requiredScope} ok=${status < 400} status=${status} ms=${Date.now() - started}`);
+    return result;
+  }
+  findProviders() {
+    return this.discovery.getProviders().filter((wrapper) => typeof wrapper.metatype === "function" && wrapper.instance).filter((wrapper) => this.reflector.get(MCP_TOOL_PROVIDER_KEY, wrapper.metatype) === true).map((wrapper) => wrapper.instance);
+  }
+  register(definition) {
+    if (!TOOL_NAME_PATTERN.test(definition.name)) {
+      throw new Error(`MCP tool name "${definition.name}" is invalid (letters, digits, _ and -, max 64 chars).`);
+    }
+    if (this.definitions.has(definition.name)) {
+      throw new Error(`MCP tool "${definition.name}" is registered twice.`);
+    }
+    this.definitions.set(definition.name, definition);
+  }
+  toCatalogEntry(definition) {
+    return {
+      name: definition.name,
+      title: definition.title,
+      description: definition.description,
+      inputSchema: this.toInputSchema(definition),
+      annotations: {
+        title: definition.title,
+        readOnlyHint: definition.annotations.readOnlyHint,
+        destructiveHint: definition.annotations.destructiveHint,
+        idempotentHint: definition.annotations.idempotentHint,
+        openWorldHint: false
+      }
+    };
+  }
+  // MCP wants a bare JSON Schema object at the root; zod adds a $schema marker the catalog does not need
+  toInputSchema(definition) {
+    const schema = import_zod2.z.toJSONSchema(definition.inputSchema, {
+      io: "input"
+    });
+    delete schema.$schema;
+    if (schema.type !== "object") {
+      throw new Error(`MCP tool "${definition.name}" must declare an object input schema.`);
+    }
+    return schema;
+  }
+};
+ToolRegistry = _ts_decorate([
+  (0, import_common22.Injectable)(),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof import_core.DiscoveryService === "undefined" ? Object : import_core.DiscoveryService,
+    typeof import_core.Reflector === "undefined" ? Object : import_core.Reflector
+  ])
+], ToolRegistry);
+
+// src/mcp/mcp-server.factory.ts
+function _ts_decorate2(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;
+}
+__name(_ts_decorate2, "_ts_decorate");
+function _ts_metadata2(metadataKey, metadataValue) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+    return Reflect.metadata(metadataKey, metadataValue);
+  }
+}
+__name(_ts_metadata2, "_ts_metadata");
+function _ts_param(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param, "_ts_param");
+var McpServerFactory = class {
+  static {
+    __name(this, "McpServerFactory");
+  }
+  options;
+  toolRegistry;
+  constructor(options, toolRegistry) {
+    this.options = options;
+    this.toolRegistry = toolRegistry;
+  }
+  create(principal) {
+    const server = new import_server.Server({
+      name: this.options.name,
+      version: this.options.version
+    }, {
+      capabilities: {
+        tools: {}
+      },
+      instructions: this.options.instructions
+    });
+    server.setRequestHandler(import_types.ListToolsRequestSchema, async () => ({
+      tools: this.toolRegistry.listTools()
+    }));
+    server.setRequestHandler(import_types.CallToolRequestSchema, async (request) => this.toolRegistry.execute(request.params.name, request.params.arguments, principal));
+    return server;
+  }
+};
+McpServerFactory = _ts_decorate2([
+  (0, import_common23.Injectable)(),
+  _ts_param(0, (0, import_common23.Inject)(MCP_SERVER_OPTIONS)),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    typeof McpServerOptions === "undefined" ? Object : McpServerOptions,
+    typeof ToolRegistry === "undefined" ? Object : ToolRegistry
+  ])
+], McpServerFactory);
+
+// src/mcp/mcp-transport.factory.ts
+var import_streamableHttp = require("@modelcontextprotocol/sdk/server/streamableHttp.js");
+var import_common24 = require("@nestjs/common");
+function _ts_decorate3(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;
+}
+__name(_ts_decorate3, "_ts_decorate");
+var McpTransportFactory = class {
+  static {
+    __name(this, "McpTransportFactory");
+  }
+  create() {
+    return new import_streamableHttp.StreamableHTTPServerTransport({
+      sessionIdGenerator: void 0,
+      enableJsonResponse: true
+    });
+  }
+};
+McpTransportFactory = _ts_decorate3([
+  (0, import_common24.Injectable)()
+], McpTransportFactory);
+
+// src/mcp/mcp-request.handler.ts
+function _ts_decorate4(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;
+}
+__name(_ts_decorate4, "_ts_decorate");
+function _ts_metadata3(metadataKey, metadataValue) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+    return Reflect.metadata(metadataKey, metadataValue);
+  }
+}
+__name(_ts_metadata3, "_ts_metadata");
+function _ts_param2(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param2, "_ts_param");
+var McpRequestHandler = class {
+  static {
+    __name(this, "McpRequestHandler");
+  }
+  serverFactory;
+  transportFactory;
+  principalFactory;
+  constructor(serverFactory, transportFactory, principalFactory) {
+    this.serverFactory = serverFactory;
+    this.transportFactory = transportFactory;
+    this.principalFactory = principalFactory;
+  }
+  async handle(request, reply, body) {
+    const principal = this.principalFactory(request);
+    reply.hijack();
+    const transport = this.transportFactory.create();
+    const server = this.serverFactory.create(principal);
+    reply.raw.on("close", () => {
+      void transport.close();
+      void server.close();
+    });
+    await server.connect(transport);
+    await transport.handleRequest(request.raw, reply.raw, body);
+  }
+  // The JSON-RPC answer for verbs a stateless server does not serve (GET streams, DELETE session teardown)
+  methodNotAllowed(reply) {
+    reply.status(405).header("Allow", "POST").send({
+      jsonrpc: "2.0",
+      error: {
+        code: -32e3,
+        message: "Method not allowed."
+      },
+      id: null
+    });
+  }
+};
+McpRequestHandler = _ts_decorate4([
+  (0, import_common25.Injectable)(),
+  _ts_param2(2, (0, import_common25.Inject)(MCP_PRINCIPAL_FACTORY)),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof McpServerFactory === "undefined" ? Object : McpServerFactory,
+    typeof McpTransportFactory === "undefined" ? Object : McpTransportFactory,
+    typeof McpPrincipalFactory === "undefined" ? Object : McpPrincipalFactory
+  ])
+], McpRequestHandler);
+
+// src/mcp/mcp-schema-registry.ts
+var import_common26 = require("@nestjs/common");
+function _ts_decorate5(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;
+}
+__name(_ts_decorate5, "_ts_decorate");
+var COMPONENT_REF = "#/components/schemas/";
+var McpSchemaRegistry = class {
+  static {
+    __name(this, "McpSchemaRegistry");
+  }
+  schemas = {};
+  setDocument(document) {
+    this.schemas = document.components?.schemas ?? {};
+  }
+  // The schema for a DTO class, with its component references inlined as local $defs
+  schemaFor(dto) {
+    const root = this.schemas[dto.name];
+    if (!root) return {
+      type: "object",
+      description: `The schema for ${dto.name} is unavailable.`
+    };
+    const defs = {};
+    const rewritten = this.rewrite(root, defs);
+    return Object.keys(defs).length > 0 ? {
+      ...rewritten,
+      $defs: defs
+    } : rewritten;
+  }
+  rewrite(node, defs) {
+    if (Array.isArray(node)) return node.map((item) => this.rewrite(item, defs));
+    if (typeof node !== "object" || node === null) return node;
+    const record = node;
+    if (typeof record.$ref === "string" && record.$ref.startsWith(COMPONENT_REF)) {
+      const name = record.$ref.slice(COMPONENT_REF.length);
+      if (!(name in defs)) {
+        defs[name] = {};
+        defs[name] = this.rewrite(this.schemas[name] ?? {}, defs);
+      }
+      return {
+        $ref: `#/$defs/${name}`
+      };
+    }
+    const out = {};
+    for (const [key, value] of Object.entries(record)) out[key] = this.rewrite(value, defs);
+    return out;
+  }
+};
+McpSchemaRegistry = _ts_decorate5([
+  (0, import_common26.Injectable)()
+], McpSchemaRegistry);
+
+// src/mcp/mcp.module.ts
+function _ts_decorate6(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;
+}
+__name(_ts_decorate6, "_ts_decorate");
+var McpModule = class _McpModule {
+  static {
+    __name(this, "McpModule");
+  }
+  static forRoot(options) {
+    const serverOptions = {
+      name: options.name,
+      version: options.version,
+      instructions: options.instructions
+    };
+    return {
+      module: _McpModule,
+      imports: [
+        import_core2.DiscoveryModule
+      ],
+      providers: [
+        {
+          provide: MCP_SERVER_OPTIONS,
+          useValue: serverOptions
+        },
+        {
+          provide: MCP_PRINCIPAL_FACTORY,
+          useValue: options.principal ?? principalFromOAuth
+        },
+        McpTransportFactory,
+        McpServerFactory,
+        McpRequestHandler,
+        McpSchemaRegistry,
+        ToolRegistry
+      ],
+      exports: [
+        McpRequestHandler,
+        McpSchemaRegistry,
+        ToolRegistry
+      ]
+    };
+  }
+};
+McpModule = _ts_decorate6([
+  (0, import_common27.Module)({})
+], McpModule);
+
+// src/mcp/validate-dto.ts
+var import_class_transformer = require("class-transformer");
+var import_class_validator = require("class-validator");
+var McpValidationError = class extends BadRequestException {
+  static {
+    __name(this, "McpValidationError");
+  }
+  constructor(errors) {
+    super({
+      label: "Validation Failed",
+      detail: "Please check your input and try again.",
+      errors
+    });
+  }
+};
+function flattenValidationErrors(errors, parent = "") {
+  return errors.flatMap((error) => {
+    const field = parent ? `${parent}.${error.property}` : error.property;
+    const own = Object.values(error.constraints ?? {}).map((message) => ({
+      field,
+      message
+    }));
+    const nested = error.children?.length ? flattenValidationErrors(error.children, field) : [];
+    return [
+      ...own,
+      ...nested
+    ];
+  });
+}
+__name(flattenValidationErrors, "flattenValidationErrors");
+async function validateDto(cls, input) {
+  const instance = (0, import_class_transformer.plainToInstance)(cls, input ?? {}, {
+    enableImplicitConversion: true
+  });
+  const errors = await (0, import_class_validator.validate)(instance, {
+    whitelist: true,
+    forbidNonWhitelisted: true
+  });
+  if (errors.length > 0) throw new McpValidationError(flattenValidationErrors(errors));
+  return instance;
+}
+__name(validateDto, "validateDto");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MCP_PRINCIPAL_FACTORY,
+  MCP_SERVER_OPTIONS,
+  MCP_TOOL_PROVIDER_KEY,
+  McpModule,
+  McpPrincipal,
+  McpRequestHandler,
+  McpSchemaRegistry,
+  McpServerFactory,
+  McpTools,
+  McpTransportFactory,
+  McpValidationError,
+  ToolRegistry,
+  collectOperationIds,
+  defineTool,
+  principalFromOAuth,
+  problemFromError,
+  toolError,
+  toolOk,
+  validateDto
+});
+//# sourceMappingURL=mcp.cjs.map