mcp-expose 1.0.0

package/dist/nestjs/index.cjs

@@ -0,0 +1,1117 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/nestjs/index.ts
+var nestjs_exports = {};
+__export(nestjs_exports, {
+  MCP_MODULE_OPTIONS: () => MCP_MODULE_OPTIONS,
+  MCP_TOOL_METADATA: () => MCP_TOOL_METADATA,
+  McpModule: () => McpModule,
+  McpService: () => McpService,
+  McpTool: () => McpTool,
+  dtoToJsonSchema: () => dtoToJsonSchema
+});
+module.exports = __toCommonJS(nestjs_exports);
+var import_common = require("@nestjs/common");
+var import_core = require("@nestjs/core");
+
+// src/core/dispatch.ts
+function buildUrl(base, req) {
+  const url = new URL(base.replace(/\/+$/, "") + req.path);
+  for (const [k, v] of Object.entries(req.query)) {
+    for (const item of Array.isArray(v) ? v : [
+      v
+    ]) url.searchParams.append(k, item);
+  }
+  return url.toString();
+}
+__name(buildUrl, "buildUrl");
+function createFetchDispatcher(opts) {
+  const doFetch = opts.fetch ?? fetch;
+  return async (req, ctx) => {
+    const base = typeof opts.baseUrl === "function" ? opts.baseUrl(ctx) : opts.baseUrl;
+    const res = await doFetch(buildUrl(base, req), {
+      method: req.method,
+      headers: req.headers,
+      body: req.body === void 0 || req.method === "GET" || req.method === "HEAD" ? void 0 : JSON.stringify(req.body),
+      signal: AbortSignal.timeout(opts.timeoutMs ?? 3e4)
+    });
+    const headers = {};
+    res.headers.forEach((v, k) => headers[k] = v);
+    return {
+      status: res.status,
+      headers,
+      body: await res.text()
+    };
+  };
+}
+__name(createFetchDispatcher, "createFetchDispatcher");
+
+// src/core/node.ts
+function normalizeHeaders(headers) {
+  const out = {};
+  for (const [k, v] of Object.entries(headers)) {
+    if (v === void 0) continue;
+    out[k.toLowerCase()] = Array.isArray(v) ? v.join(", ") : String(v);
+  }
+  return out;
+}
+__name(normalizeHeaders, "normalizeHeaders");
+function loopbackBaseUrl(req) {
+  const socket = req.socket;
+  const port = socket.localPort;
+  const encrypted = socket.encrypted;
+  const bound = socket.server?.address();
+  let host = typeof bound === "object" && bound?.address || socket.localAddress || "127.0.0.1";
+  if (host.startsWith("::ffff:")) host = host.slice(7);
+  if (host === "::" || host === "0.0.0.0") host = "127.0.0.1";
+  if (host.includes(":")) host = `[${host}]`;
+  return `${encrypted ? "https" : "http"}://${host}:${port}`;
+}
+__name(loopbackBaseUrl, "loopbackBaseUrl");
+
+// src/core/schema.ts
+function isStandard(s) {
+  return typeof s === "object" && s !== null && "~standard" in s;
+}
+__name(isStandard, "isStandard");
+function toJsonSchema(schema) {
+  if (schema === void 0 || schema === null) return void 0;
+  let out;
+  if (isStandard(schema) && typeof schema["~standard"].jsonSchema?.input === "function") {
+    out = schema["~standard"].jsonSchema.input({
+      target: "draft-2020-12"
+    });
+  } else if (typeof schema.toJSONSchema === "function") {
+    out = schema.toJSONSchema();
+  } else if (isStandard(schema)) {
+    throw new Error("mcp-expose: this schema library does not support JSON Schema export. Pass a plain JSON Schema instead.");
+  } else {
+    out = schema;
+  }
+  const { $schema: _ignored, ...rest } = out;
+  return rest;
+}
+__name(toJsonSchema, "toJsonSchema");
+function toValidator(schema) {
+  if (!isStandard(schema) || typeof schema["~standard"].validate !== "function") return void 0;
+  const validate = schema["~standard"].validate;
+  return async (value) => {
+    const result = await validate(value);
+    if (!result.issues) return {
+      ok: true,
+      value: result.value
+    };
+    const message = result.issues.map((i) => {
+      const path = (i.path ?? []).map((p) => typeof p === "object" ? String(p.key) : String(p)).join(".");
+      return path ? `${path}: ${i.message}` : i.message;
+    }).join("; ");
+    return {
+      ok: false,
+      message
+    };
+  };
+}
+__name(toValidator, "toValidator");
+function checkRequired(schema, args) {
+  const missing = (schema.required ?? []).filter((k) => args[k] === void 0);
+  return missing.length ? `Missing required argument(s): ${missing.join(", ")}` : void 0;
+}
+__name(checkRequired, "checkRequired");
+
+// src/core/route-tool.ts
+var DEFAULT_FORWARD_HEADERS = [
+  "authorization",
+  "cookie",
+  "x-api-key",
+  "accept-language"
+];
+var BODY_METHODS = /* @__PURE__ */ new Set([
+  "POST",
+  "PUT",
+  "PATCH"
+]);
+var PARAM_RE = /:([A-Za-z0-9_]+)\??|\{([A-Za-z0-9_]+)\}/g;
+function pathParams(path) {
+  return [
+    ...path.matchAll(PARAM_RE)
+  ].map((m) => m[1] ?? m[2]);
+}
+__name(pathParams, "pathParams");
+function encodeSegment(name, value) {
+  const raw = String(value);
+  if (raw === "" || raw === "." || raw === "..") {
+    throw new Error(`Invalid value for path parameter "${name}": ${JSON.stringify(raw)}`);
+  }
+  return encodeURIComponent(raw);
+}
+__name(encodeSegment, "encodeSegment");
+function interpolatePath(path, values) {
+  return path.replace(/\/:([A-Za-z0-9_]+)\?/g, (_, k) => values[k] === void 0 ? "" : `/${encodeSegment(k, values[k])}`).replace(PARAM_RE, (_, a, b) => {
+    const k = a ?? b;
+    return encodeSegment(k, values[k]);
+  });
+}
+__name(interpolatePath, "interpolatePath");
+function joinPaths(...parts) {
+  const joined = parts.filter((p) => !!p && p !== "/").map((p) => p.replace(/^\/+|\/+$/g, "")).filter(Boolean).join("/");
+  return `/${joined}`;
+}
+__name(joinPaths, "joinPaths");
+function toolNameFromRoute(method, path) {
+  const segments = path.split("/").filter(Boolean).map((s) => {
+    const m = /^(?::([A-Za-z0-9_]+)\??|\{([A-Za-z0-9_]+)\})$/.exec(s);
+    return m ? `by_${m[1] ?? m[2]}` : s;
+  });
+  return sanitizeToolName([
+    method.toLowerCase(),
+    ...segments
+  ].join("_"));
+}
+__name(toolNameFromRoute, "toolNameFromRoute");
+function sanitizeToolName(name) {
+  return name.replace(/[^A-Za-z0-9_-]+/g, "_").replace(/_+/g, "_").replace(/^_|_$/g, "").slice(0, 64);
+}
+__name(sanitizeToolName, "sanitizeToolName");
+function defaultAnnotations(method) {
+  switch (method) {
+    case "GET":
+    case "HEAD":
+      return {
+        readOnlyHint: true,
+        openWorldHint: false
+      };
+    case "DELETE":
+      return {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: true,
+        openWorldHint: false
+      };
+    case "PUT":
+      return {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false
+      };
+    default:
+      return {
+        readOnlyHint: false,
+        destructiveHint: false,
+        openWorldHint: false
+      };
+  }
+}
+__name(defaultAnnotations, "defaultAnnotations");
+function buildInputSchema(route, opts) {
+  const method = route.method.toUpperCase();
+  const params = pathParams(route.path);
+  const mapping = {
+    params,
+    query: /* @__PURE__ */ new Set(),
+    body: /* @__PURE__ */ new Set(),
+    wholeBody: false,
+    bodyMethod: BODY_METHODS.has(method)
+  };
+  if (opts.input) {
+    const schema2 = toJsonSchema(opts.input);
+    return {
+      schema: {
+        type: "object",
+        ...schema2
+      },
+      mapping
+    };
+  }
+  const properties = {};
+  const required = /* @__PURE__ */ new Set();
+  const paramSchema = toJsonSchema(opts.params);
+  for (const p of params) {
+    properties[p] = paramSchema?.properties?.[p] ?? {
+      type: "string",
+      description: `Path parameter "${p}"`
+    };
+    if (!route.path.includes(`:${p}?`)) required.add(p);
+  }
+  const querySchema = toJsonSchema(opts.query);
+  for (const [k, v] of Object.entries(querySchema?.properties ?? {})) {
+    properties[k] = v;
+    mapping.query.add(k);
+  }
+  for (const k of querySchema?.required ?? []) required.add(k);
+  const bodySchema = toJsonSchema(opts.body);
+  if (bodySchema) {
+    if (bodySchema.properties && (bodySchema.type === void 0 || bodySchema.type === "object")) {
+      for (const [k, v] of Object.entries(bodySchema.properties)) {
+        properties[k] = v;
+        mapping.body.add(k);
+      }
+      for (const k of bodySchema.required ?? []) required.add(k);
+    } else {
+      properties.body = bodySchema;
+      required.add("body");
+      mapping.wholeBody = true;
+    }
+  }
+  const schema = {
+    type: "object",
+    properties
+  };
+  if (required.size) schema.required = [
+    ...required
+  ];
+  return {
+    schema,
+    mapping
+  };
+}
+__name(buildInputSchema, "buildInputSchema");
+function splitArgs(args, mapping) {
+  const pathValues = {};
+  const query = {};
+  let body;
+  for (const [k, v] of Object.entries(args)) {
+    if (v === void 0) continue;
+    if (mapping.params.includes(k)) {
+      pathValues[k] = v;
+    } else if (mapping.wholeBody && k === "body") {
+      body = v;
+    } else if (mapping.query.has(k) || !mapping.body.has(k) && !mapping.bodyMethod) {
+      query[k] = Array.isArray(v) ? v.map(String) : typeof v === "object" && v !== null ? JSON.stringify(v) : String(v);
+    } else {
+      body = {
+        ...body ?? {},
+        [k]: v
+      };
+    }
+  }
+  if (body === void 0 && mapping.bodyMethod) body = {};
+  return {
+    pathValues,
+    query,
+    body
+  };
+}
+__name(splitArgs, "splitArgs");
+function responseToResult(res, maxChars) {
+  let text = res.body;
+  if (text.length > maxChars) text = `${text.slice(0, maxChars)}
+\u2026[truncated ${text.length - maxChars} chars]`;
+  const isError = res.status >= 400;
+  const result = {
+    content: [
+      {
+        type: "text",
+        text: isError ? `HTTP ${res.status}
+${text}` : text || `HTTP ${res.status}`
+      }
+    ]
+  };
+  if (isError) {
+    result.isError = true;
+    return result;
+  }
+  if ((res.headers["content-type"] ?? "").includes("json") && text === res.body) {
+    try {
+      const parsed = JSON.parse(res.body);
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) result.structuredContent = parsed;
+    } catch {
+    }
+  }
+  return result;
+}
+__name(responseToResult, "responseToResult");
+function pickForwardHeaders(ctx, names) {
+  const out = {};
+  for (const name of names) {
+    const v = ctx.headers[name.toLowerCase()];
+    if (v !== void 0) out[name.toLowerCase()] = v;
+  }
+  return out;
+}
+__name(pickForwardHeaders, "pickForwardHeaders");
+function createRouteTool(route, opts, dispatch, serverOpts = {}) {
+  const method = route.method.toUpperCase();
+  const name = sanitizeToolName(opts.name ?? toolNameFromRoute(method, route.path));
+  const { schema, mapping } = buildInputSchema(route, opts);
+  const forward = serverOpts.forwardHeaders ?? DEFAULT_FORWARD_HEADERS;
+  const maxChars = serverOpts.maxResponseChars ?? 1e5;
+  return {
+    name,
+    title: opts.title,
+    description: opts.description ?? `${method} ${route.path}`,
+    inputSchema: schema,
+    annotations: {
+      ...defaultAnnotations(method),
+      ...opts.annotations
+    },
+    validate: toValidator(opts.input),
+    async handler(args, ctx) {
+      const missing = opts.input ? void 0 : checkRequired(schema, args);
+      if (missing) return {
+        isError: true,
+        content: [
+          {
+            type: "text",
+            text: missing
+          }
+        ]
+      };
+      const { pathValues, query, body } = splitArgs(args, mapping);
+      const headers = {
+        accept: "application/json",
+        ...pickForwardHeaders(ctx, forward),
+        ...opts.headers,
+        "x-mcp-tool": name
+      };
+      if (ctx.clientIp) headers["x-forwarded-for"] = ctx.clientIp;
+      if (body !== void 0) headers["content-type"] = "application/json";
+      let path;
+      try {
+        path = interpolatePath(route.path, pathValues);
+      } catch (err) {
+        return {
+          isError: true,
+          content: [
+            {
+              type: "text",
+              text: err.message
+            }
+          ]
+        };
+      }
+      const res = await dispatch({
+        method,
+        path,
+        query,
+        body,
+        headers
+      }, ctx);
+      return responseToResult(res, maxChars);
+    }
+  };
+}
+__name(createRouteTool, "createRouteTool");
+
+// src/core/server.ts
+var SUPPORTED_PROTOCOL_VERSIONS = [
+  "2025-11-25",
+  "2025-06-18",
+  "2025-03-26",
+  "2024-11-05"
+];
+var LATEST_PROTOCOL_VERSION = SUPPORTED_PROTOCOL_VERSIONS[0];
+var PARSE_ERROR = -32700;
+var INVALID_REQUEST = -32600;
+var METHOD_NOT_FOUND = -32601;
+var INVALID_PARAMS = -32602;
+var ok = /* @__PURE__ */ __name((id, result) => ({
+  jsonrpc: "2.0",
+  id,
+  result
+}), "ok");
+var fail = /* @__PURE__ */ __name((id, code, message) => ({
+  jsonrpc: "2.0",
+  id,
+  error: {
+    code,
+    message
+  }
+}), "fail");
+var McpServer = class {
+  static {
+    __name(this, "McpServer");
+  }
+  options;
+  tools = /* @__PURE__ */ new Map();
+  loaders = [];
+  constructor(options) {
+    this.options = options;
+  }
+  /** Register a tool. Throws on duplicate names. */
+  addTool(tool) {
+    if (this.tools.has(tool.name)) {
+      throw new Error(`mcp-expose: duplicate tool name "${tool.name}". Set an explicit \`name\`.`);
+    }
+    this.tools.set(tool.name, tool);
+    return this;
+  }
+  /** Register a function that adds tools lazily, right before the first MCP request is served. */
+  onLoad(loader) {
+    this.loaders.push(loader);
+    return this;
+  }
+  async listTools() {
+    await this.load();
+    return [
+      ...this.tools.values()
+    ];
+  }
+  async load() {
+    if (!this.loaders.length) return;
+    const loaders = this.loaders;
+    this.loaders = [];
+    for (const l of loaders) await l();
+  }
+  /** Handle one JSON-RPC message (or a batch). Returns null when no response is due. */
+  async handleMessage(message, ctx) {
+    if (Array.isArray(message)) {
+      const results = (await Promise.all(message.map((m) => this.handleOne(m, ctx)))).filter((r) => r !== null);
+      return results.length ? results : null;
+    }
+    return this.handleOne(message, ctx);
+  }
+  async handleOne(message, ctx) {
+    const msg = message;
+    if (!msg || typeof msg !== "object" || msg.jsonrpc !== "2.0") {
+      return fail(null, INVALID_REQUEST, "Invalid JSON-RPC message");
+    }
+    if (typeof msg.method !== "string" || msg.id === void 0) return null;
+    const id = msg.id;
+    const params = msg.params ?? {};
+    await this.load();
+    switch (msg.method) {
+      case "initialize": {
+        const requested = params.protocolVersion;
+        const protocolVersion = requested && SUPPORTED_PROTOCOL_VERSIONS.includes(requested) ? requested : LATEST_PROTOCOL_VERSION;
+        return ok(id, {
+          protocolVersion,
+          capabilities: {
+            tools: {
+              listChanged: false
+            }
+          },
+          serverInfo: {
+            name: this.options.name,
+            version: this.options.version ?? "1.0.0"
+          },
+          ...this.options.instructions ? {
+            instructions: this.options.instructions
+          } : {}
+        });
+      }
+      case "ping":
+        return ok(id, {});
+      case "tools/list":
+        return ok(id, {
+          tools: [
+            ...this.tools.values()
+          ].map((t) => ({
+            name: t.name,
+            ...t.title ? {
+              title: t.title
+            } : {},
+            description: t.description,
+            inputSchema: t.inputSchema,
+            ...t.annotations ? {
+              annotations: t.annotations
+            } : {}
+          }))
+        });
+      case "tools/call": {
+        const tool = this.tools.get(params.name);
+        if (!tool) return fail(id, INVALID_PARAMS, `Unknown tool: ${String(params.name)}`);
+        return ok(id, await this.callTool(tool, params.arguments ?? {}, ctx));
+      }
+      case "resources/list":
+        return ok(id, {
+          resources: []
+        });
+      case "prompts/list":
+        return ok(id, {
+          prompts: []
+        });
+      default:
+        return fail(id, METHOD_NOT_FOUND, `Method not found: ${msg.method}`);
+    }
+  }
+  async callTool(tool, args, ctx) {
+    try {
+      if (tool.validate) {
+        const v = await tool.validate(args);
+        if (!v.ok) return {
+          isError: true,
+          content: [
+            {
+              type: "text",
+              text: `Invalid arguments: ${v.message}`
+            }
+          ]
+        };
+        args = v.value;
+      }
+      return await tool.handler(args, ctx);
+    } catch (err) {
+      return {
+        isError: true,
+        content: [
+          {
+            type: "text",
+            text: `Tool error: ${err.message}`
+          }
+        ]
+      };
+    }
+  }
+  /** Check the Origin header (DNS rebinding protection). */
+  isOriginAllowed(origin) {
+    if (!origin) return true;
+    const allowed = this.options.allowedOrigins;
+    if (allowed === "*") return true;
+    return (allowed ?? []).includes(origin);
+  }
+  /**
+  * Framework-neutral Streamable HTTP handler. Adapters convert their request
+  * into McpHttpRequest, call this, and write the McpHttpResponse back.
+  */
+  async handleHttp(req, ctx) {
+    const json = {
+      "content-type": "application/json"
+    };
+    if (!this.isOriginAllowed(req.headers.origin)) {
+      return {
+        status: 403,
+        headers: json,
+        body: JSON.stringify(fail(null, INVALID_REQUEST, "Origin not allowed"))
+      };
+    }
+    if (req.method.toUpperCase() !== "POST") {
+      return {
+        status: 405,
+        headers: {
+          allow: "POST"
+        }
+      };
+    }
+    let body = req.body;
+    if (typeof body === "string" || body instanceof Uint8Array) {
+      try {
+        body = JSON.parse(typeof body === "string" ? body : new TextDecoder().decode(body));
+      } catch {
+        return {
+          status: 400,
+          headers: json,
+          body: JSON.stringify(fail(null, PARSE_ERROR, "Parse error"))
+        };
+      }
+    }
+    const response = await this.handleMessage(body, ctx);
+    if (response === null) return {
+      status: 202,
+      headers: {}
+    };
+    return {
+      status: 200,
+      headers: json,
+      body: JSON.stringify(response)
+    };
+  }
+};
+
+// src/nestjs/dto-schema.ts
+var PRIMITIVES = /* @__PURE__ */ new Map([
+  [
+    String,
+    {
+      type: "string"
+    }
+  ],
+  [
+    Number,
+    {
+      type: "number"
+    }
+  ],
+  [
+    Boolean,
+    {
+      type: "boolean"
+    }
+  ],
+  [
+    Date,
+    {
+      type: "string",
+      format: "date-time"
+    }
+  ],
+  [
+    Array,
+    {
+      type: "array"
+    }
+  ],
+  [
+    Object,
+    {
+      type: "object"
+    }
+  ]
+]);
+function primitiveSchema(type) {
+  const s = PRIMITIVES.get(type);
+  return s ? {
+    ...s
+  } : void 0;
+}
+__name(primitiveSchema, "primitiveSchema");
+function applyRule(s, name, c = []) {
+  switch (name) {
+    case "isString":
+      s.type = "string";
+      break;
+    case "isNumber":
+    case "isNumberString":
+      s.type = name === "isNumber" ? "number" : "string";
+      break;
+    case "isInt":
+      s.type = "integer";
+      break;
+    case "isBoolean":
+      s.type = "boolean";
+      break;
+    case "isDate":
+    case "isDateString":
+    case "isISO8601":
+      s.type = "string";
+      s.format = "date-time";
+      break;
+    case "isEmail":
+      s.type = "string";
+      s.format = "email";
+      break;
+    case "isUrl":
+      s.type = "string";
+      s.format = "uri";
+      break;
+    case "isUUID":
+      s.type = "string";
+      s.format = "uuid";
+      break;
+    case "isPositive":
+      s.exclusiveMinimum = 0;
+      break;
+    case "isNegative":
+      s.exclusiveMaximum = 0;
+      break;
+    case "min":
+      s.minimum = c[0];
+      break;
+    case "max":
+      s.maximum = c[0];
+      break;
+    case "minLength":
+      s.minLength = c[0];
+      break;
+    case "maxLength":
+      s.maxLength = c[0];
+      break;
+    case "length":
+      s.minLength = c[0];
+      if (c[1] !== void 0) s.maxLength = c[1];
+      break;
+    case "matches":
+      if (c[0] instanceof RegExp) s.pattern = c[0].source;
+      break;
+    case "isIn":
+      s.enum = c[0];
+      break;
+    case "isEnum":
+      s.enum = c[1] ?? Object.values(c[0]);
+      break;
+    case "isNotEmpty":
+      if (s.type === "string") s.minLength = Math.max(1, Number(s.minLength ?? 0));
+      break;
+    case "isArray":
+      s.type = "array";
+      break;
+    case "arrayMinSize":
+      s.minItems = c[0];
+      break;
+    case "arrayMaxSize":
+      s.maxItems = c[0];
+      break;
+    case "isObject":
+      s.type = "object";
+      break;
+  }
+}
+__name(applyRule, "applyRule");
+function dtoToJsonSchema(dto, storage, depth = 0) {
+  const schema = {
+    type: "object",
+    properties: {}
+  };
+  if (!storage || depth > 5) return schema;
+  const metas = storage.getTargetValidationMetadatas(dto, "", true, false);
+  const properties = {};
+  const optional = /* @__PURE__ */ new Set();
+  for (const m of metas) {
+    const prop = properties[m.propertyName] ??= initial(dto, m.propertyName);
+    if (m.type === "conditionalValidation" && m.name === "isOptional") {
+      optional.add(m.propertyName);
+    } else if (m.type === "nestedValidation") {
+      const nestedType = Reflect.getMetadata?.("design:type", dto.prototype, m.propertyName);
+      if (typeof nestedType === "function" && !PRIMITIVES.has(nestedType)) {
+        Object.assign(prop, dtoToJsonSchema(nestedType, storage, depth + 1));
+      }
+    } else if (m.type === "customValidation" && m.name) {
+      if (m.each) {
+        prop.type = "array";
+        const items = prop.items ??= {};
+        applyRule(items, m.name, m.constraints);
+      } else {
+        applyRule(prop, m.name, m.constraints);
+      }
+    }
+  }
+  schema.properties = properties;
+  const required = Object.keys(properties).filter((p) => !optional.has(p));
+  if (required.length) schema.required = required;
+  return schema;
+}
+__name(dtoToJsonSchema, "dtoToJsonSchema");
+function initial(dto, prop) {
+  const designType = Reflect.getMetadata?.("design:type", dto.prototype, prop);
+  const s = primitiveSchema(designType) ?? {};
+  const api = Reflect.getMetadata?.("swagger/apiModelProperties", dto.prototype, prop);
+  if (api?.description) s.description = api.description;
+  if (api?.example !== void 0) s.examples = [
+    api.example
+  ];
+  if (Array.isArray(api?.enum)) s.enum = api.enum;
+  return s;
+}
+__name(initial, "initial");
+
+// src/nestjs/index.ts
+var PATH_METADATA = "path";
+var METHOD_METADATA = "method";
+var ROUTE_ARGS_METADATA = "__routeArguments__";
+var VERSION_METADATA = "__version__";
+var REQUEST_METHODS = [
+  "GET",
+  "POST",
+  "PUT",
+  "DELETE",
+  "PATCH",
+  "ALL",
+  "OPTIONS",
+  "HEAD"
+];
+var PARAMTYPE_BODY = 3;
+var PARAMTYPE_QUERY = 4;
+var PARAMTYPE_PARAM = 5;
+var MCP_TOOL_METADATA = "mcp-expose:tool";
+var MCP_MODULE_OPTIONS = /* @__PURE__ */ Symbol("MCP_MODULE_OPTIONS");
+function McpTool(options = {}) {
+  return (0, import_common.SetMetadata)(MCP_TOOL_METADATA, options);
+}
+__name(McpTool, "McpTool");
+var McpService = class {
+  static {
+    __name(this, "McpService");
+  }
+  discovery;
+  appConfig;
+  options;
+  server;
+  constructor(discovery, appConfig, options) {
+    this.discovery = discovery;
+    this.appConfig = appConfig;
+    this.options = options;
+    this.server = new McpServer(options);
+    for (const t of options.tools ?? []) this.server.addTool(t);
+    const dispatch = createFetchDispatcher({
+      baseUrl: options.baseUrl ?? ((ctx) => loopbackBaseUrl(ctx.raw))
+    });
+    this.server.onLoad(async () => {
+      const storage = options.classValidatorStorage ?? await loadClassValidator();
+      for (const t of this.discover(storage)) {
+        this.server.addTool(createRouteTool(t.route, t.options, dispatch, options));
+      }
+    });
+  }
+  globalPrefix() {
+    return this.appConfig.getGlobalPrefix?.() ?? "";
+  }
+  versionSegment(controller, handler) {
+    const versioning = this.appConfig.getVersioning?.();
+    if (!versioning || versioning.type !== 0) return void 0;
+    let version = Reflect.getMetadata(VERSION_METADATA, handler) ?? Reflect.getMetadata(VERSION_METADATA, controller) ?? versioning.defaultVersion;
+    if (Array.isArray(version)) version = version[0];
+    if (version === void 0 || typeof version === "symbol") return void 0;
+    const prefix = versioning.prefix === false ? "" : versioning.prefix ?? "v";
+    return `${prefix}${String(version)}`;
+  }
+  discover(storage) {
+    const found = [];
+    for (const wrapper of this.discovery.getControllers()) {
+      const controller = wrapper.metatype;
+      if (!controller?.prototype) continue;
+      const proto = controller.prototype;
+      const ctrlPaths = toArray(Reflect.getMetadata(PATH_METADATA, controller) ?? "/");
+      const ctrlName = controller.name.replace(/Controller$/, "");
+      for (const key of Object.getOwnPropertyNames(proto)) {
+        if (key === "constructor") continue;
+        const handler = Object.getOwnPropertyDescriptor(proto, key)?.value;
+        if (typeof handler !== "function") continue;
+        const meta = Reflect.getMetadata(MCP_TOOL_METADATA, handler);
+        if (!meta) continue;
+        const method = REQUEST_METHODS[Reflect.getMetadata(METHOD_METADATA, handler)] ?? "GET";
+        const methodPath = toArray(Reflect.getMetadata(PATH_METADATA, handler) ?? "/")[0];
+        const path = joinPaths(this.globalPrefix(), this.versionSegment(controller, handler), this.options.pathPrefix, ctrlPaths[0], methodPath);
+        found.push({
+          route: {
+            method: method === "ALL" ? "POST" : method,
+            path
+          },
+          options: {
+            name: sanitizeToolName(`${toSnake(ctrlName)}_${toSnake(key)}`),
+            ...describeArgs(controller, key, storage),
+            ...meta
+          }
+        });
+      }
+    }
+    return found;
+  }
+};
+function describeArgs(controller, key, storage) {
+  const args = Reflect.getMetadata(ROUTE_ARGS_METADATA, controller, key) ?? {};
+  const types = Reflect.getMetadata("design:paramtypes", controller.prototype, key) ?? [];
+  const params = {
+    type: "object",
+    properties: {}
+  };
+  const query = {
+    type: "object",
+    properties: {},
+    required: []
+  };
+  let body;
+  const schemaFor = /* @__PURE__ */ __name((t) => primitiveSchema(t) ?? (typeof t === "function" ? dtoToJsonSchema(t, storage) : {}), "schemaFor");
+  for (const [k, arg] of Object.entries(args)) {
+    const paramtype = Number(k.split(":")[0]);
+    const t = types[arg.index];
+    const field = typeof arg.data === "string" ? arg.data : void 0;
+    if (paramtype === PARAMTYPE_PARAM && field) {
+      params.properties[field] = primitiveSchema(t) ?? {
+        type: "string"
+      };
+    } else if (paramtype === PARAMTYPE_QUERY) {
+      if (field) query.properties[field] = primitiveSchema(t) ?? {
+        type: "string"
+      };
+      else Object.assign(query, mergeObject(query, schemaFor(t)));
+    } else if (paramtype === PARAMTYPE_BODY) {
+      if (field) {
+        body ??= {
+          type: "object",
+          properties: {},
+          required: []
+        };
+        body.properties[field] = schemaFor(t);
+        body.required.push(field);
+      } else {
+        body = mergeObject(body, schemaFor(t));
+      }
+    }
+  }
+  const out = {
+    params
+  };
+  if (Object.keys(query.properties).length) out.query = query;
+  if (body) out.body = body;
+  return out;
+}
+__name(describeArgs, "describeArgs");
+function mergeObject(a, b) {
+  if (!a) return b;
+  return {
+    type: "object",
+    properties: {
+      ...a.properties,
+      ...b.properties
+    },
+    required: [
+      ...a.required ?? [],
+      ...b.required ?? []
+    ]
+  };
+}
+__name(mergeObject, "mergeObject");
+async function loadClassValidator() {
+  try {
+    const cv = await import("class-validator");
+    return cv.getMetadataStorage?.();
+  } catch {
+    return void 0;
+  }
+}
+__name(loadClassValidator, "loadClassValidator");
+function toArray(v) {
+  return Array.isArray(v) ? v : [
+    v
+  ];
+}
+__name(toArray, "toArray");
+function toSnake(s) {
+  return s.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/[-\s]+/g, "_").toLowerCase();
+}
+__name(toSnake, "toSnake");
+(0, import_common.Injectable)()(McpService);
+(0, import_common.Inject)(import_core.DiscoveryService)(McpService, void 0, 0);
+(0, import_common.Inject)(import_core.ApplicationConfig)(McpService, void 0, 1);
+(0, import_common.Inject)(MCP_MODULE_OPTIONS)(McpService, void 0, 2);
+function createMcpController(options) {
+  let McpController = class McpController {
+    static {
+      __name(this, "McpController");
+    }
+    mcp;
+    constructor(mcp) {
+      this.mcp = mcp;
+    }
+    async handle(req, res) {
+      const nodeReq = req.raw ?? req;
+      const headers = normalizeHeaders(req.headers);
+      const ctx = {
+        headers,
+        clientIp: req.ip,
+        raw: nodeReq
+      };
+      const out = await this.mcp.server.handleHttp({
+        method: req.method,
+        headers,
+        body: req.body
+      }, ctx);
+      if (typeof res.code === "function") {
+        res.code(out.status).headers(out.headers).send(out.body);
+      } else {
+        res.status(out.status).set(out.headers);
+        if (out.body === void 0) res.end();
+        else res.send(out.body);
+      }
+    }
+  };
+  const proto = McpController.prototype;
+  const descriptor = Object.getOwnPropertyDescriptor(proto, "handle");
+  (0, import_common.Controller)({
+    path: options.path ?? "mcp",
+    version: import_common.VERSION_NEUTRAL
+  })(McpController);
+  (0, import_common.Inject)(McpService)(McpController, void 0, 0);
+  (0, import_common.All)()(proto, "handle", descriptor);
+  (0, import_common.Req)()(proto, "handle", 0);
+  (0, import_common.Res)()(proto, "handle", 1);
+  if (options.guards?.length) (0, import_common.UseGuards)(...options.guards)(McpController);
+  return McpController;
+}
+__name(createMcpController, "createMcpController");
+var McpModule = class _McpModule {
+  static {
+    __name(this, "McpModule");
+  }
+  static forRoot(options) {
+    return {
+      module: _McpModule,
+      global: true,
+      imports: [
+        import_core.DiscoveryModule
+      ],
+      controllers: [
+        createMcpController(options)
+      ],
+      providers: [
+        {
+          provide: MCP_MODULE_OPTIONS,
+          useValue: options
+        },
+        McpService
+      ],
+      exports: [
+        McpService
+      ]
+    };
+  }
+  /**
+  * Resolve the options from other providers, e.g. `ConfigService`:
+  *
+  *   McpModule.forRootAsync({
+  *     imports: [ConfigModule],
+  *     inject: [ConfigService],
+  *     useFactory: (config: ConfigService) => ({ name: config.get('APP_NAME') }),
+  *   })
+  *
+  * `path` and `guards` define the MCP controller, so they are passed directly.
+  */
+  static forRootAsync(options) {
+    return {
+      module: _McpModule,
+      global: true,
+      imports: [
+        import_core.DiscoveryModule,
+        ...options.imports ?? []
+      ],
+      controllers: [
+        createMcpController(options)
+      ],
+      providers: [
+        {
+          provide: MCP_MODULE_OPTIONS,
+          inject: options.inject ?? [],
+          useFactory: /* @__PURE__ */ __name(async (...args) => ({
+            ...await options.useFactory(...args),
+            ...options.path ? {
+              path: options.path
+            } : {}
+          }), "useFactory")
+        },
+        McpService
+      ],
+      exports: [
+        McpService
+      ]
+    };
+  }
+};
+(0, import_common.Module)({})(McpModule);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MCP_MODULE_OPTIONS,
+  MCP_TOOL_METADATA,
+  McpModule,
+  McpService,
+  McpTool,
+  dtoToJsonSchema
+});
+//# sourceMappingURL=index.cjs.map