@lark-apaas/nestjs-mcp 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1753 @@
+"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/index.ts
+var src_exports = {};
+__export(src_exports, {
+  MCP_CONTROLLER_PATH: () => MCP_CONTROLLER_PATH,
+  MCP_DEFAULT_SERVER_NAME: () => MCP_DEFAULT_SERVER_NAME,
+  MCP_DEFAULT_SERVER_VERSION: () => MCP_DEFAULT_SERVER_VERSION,
+  MCP_ENDPOINT_PATH: () => MCP_ENDPOINT_PATH,
+  MCP_MANIFEST_PATH: () => MCP_MANIFEST_PATH,
+  MCP_MANIFEST_VERSION: () => MCP_MANIFEST_VERSION,
+  MCP_MODULE_OPTIONS: () => MCP_MODULE_OPTIONS,
+  MCP_SKILL_PATH: () => MCP_SKILL_PATH,
+  MCP_SKILL_URI: () => MCP_SKILL_URI,
+  MCP_TOOLS_METADATA_KEY: () => MCP_TOOLS_METADATA_KEY,
+  MCP_TOOL_METADATA_KEY: () => MCP_TOOL_METADATA_KEY,
+  MCP_TOOL_NAME_PATTERN: () => MCP_TOOL_NAME_PATTERN,
+  MCP_UI_DIST_DIR: () => MCP_UI_DIST_DIR,
+  MCP_UI_RESOURCE_METADATA_KEY: () => MCP_UI_RESOURCE_METADATA_KEY,
+  MCP_UI_RESOURCE_SCHEME: () => MCP_UI_RESOURCE_SCHEME,
+  McpModule: () => McpModule,
+  McpTool: () => McpTool,
+  McpToolError: () => McpToolError,
+  McpTools: () => McpTools,
+  McpUiResource: () => McpUiResource,
+  readMcpUiTemplate: () => readMcpUiTemplate
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/constants.ts
+var MCP_ENDPOINT_PATH = "/__innerapi__/mcp";
+var MCP_CONTROLLER_PATH = "__innerapi__/mcp";
+var MCP_MANIFEST_PATH = ".spark/mcp/manifest.json";
+var MCP_UI_DIST_DIR = "dist/mcp-ui";
+var MCP_UI_RESOURCE_SCHEME = "ui://";
+var MCP_TOOLS_METADATA_KEY = "mcp:tools";
+var MCP_TOOL_METADATA_KEY = "mcp:tool";
+var MCP_UI_RESOURCE_METADATA_KEY = "mcp:ui-resource";
+var MCP_MODULE_OPTIONS = /* @__PURE__ */ Symbol("MCP_MODULE_OPTIONS");
+var MCP_DEFAULT_SERVER_NAME = "miaoda-app";
+var MCP_DEFAULT_SERVER_VERSION = "1.0.0";
+var MCP_MANIFEST_VERSION = 1;
+var MCP_TOOL_NAME_PATTERN = /^[A-Za-z0-9_.-]{1,128}$/;
+var MCP_SKILL_PATH = "server/mcp/SKILL.md";
+var MCP_SKILL_URI = "skill://app/SKILL.md";
+
+// src/errors.ts
+var McpToolError = class extends Error {
+  static {
+    __name(this, "McpToolError");
+  }
+  /** 可选的机器可读错误码，会一并放入返回内容 */
+  code;
+  /** 附加数据，会以 JSON 形式放入返回内容 */
+  data;
+  constructor(message, options = {}) {
+    super(message);
+    this.name = "McpToolError";
+    this.code = options.code;
+    this.data = options.data;
+  }
+};
+
+// src/decorators/mcp-tools.decorator.ts
+var import_common = require("@nestjs/common");
+var McpTools = /* @__PURE__ */ __name((options = {}) => {
+  return (target) => {
+    (0, import_common.Injectable)()(target);
+    (0, import_common.SetMetadata)(MCP_TOOLS_METADATA_KEY, options)(target);
+    return target;
+  };
+}, "McpTools");
+
+// src/decorators/mcp-tool.decorator.ts
+var import_common2 = require("@nestjs/common");
+function McpTool(options) {
+  return (target, propertyKey, descriptor) => {
+    if (typeof propertyKey !== "string") {
+      throw new TypeError("@McpTool() \u53EA\u80FD\u7528\u4E8E\u5177\u540D\u65B9\u6CD5");
+    }
+    if (!options || typeof options.description !== "string" || options.description.trim() === "") {
+      throw new TypeError(`@McpTool() \u4E8E ${target.constructor.name}.${propertyKey}\uFF1Adescription \u4E3A\u5FC5\u586B\u9879`);
+    }
+    (0, import_common2.SetMetadata)(MCP_TOOL_METADATA_KEY, options)(target, propertyKey, descriptor);
+  };
+}
+__name(McpTool, "McpTool");
+
+// src/decorators/mcp-ui-resource.decorator.ts
+var import_common3 = require("@nestjs/common");
+function McpUiResource(options) {
+  return (target, propertyKey, descriptor) => {
+    if (typeof propertyKey !== "string") {
+      throw new TypeError("@McpUiResource() \u53EA\u80FD\u7528\u4E8E\u5177\u540D\u65B9\u6CD5");
+    }
+    if (!options?.uri || !options.uri.startsWith(MCP_UI_RESOURCE_SCHEME)) {
+      throw new TypeError(`@McpUiResource() \u4E8E ${target.constructor.name}.${propertyKey}\uFF1Auri \u5FC5\u987B\u4EE5 ${MCP_UI_RESOURCE_SCHEME} \u5F00\u5934`);
+    }
+    (0, import_common3.SetMetadata)(MCP_UI_RESOURCE_METADATA_KEY, options)(target, propertyKey, descriptor);
+  };
+}
+__name(McpUiResource, "McpUiResource");
+
+// src/mcp.module.ts
+var import_common9 = require("@nestjs/common");
+var import_core2 = require("@nestjs/core");
+
+// src/controllers/mcp-manifest.controller.ts
+var import_common6 = require("@nestjs/common");
+var import_swagger = require("@nestjs/swagger");
+
+// src/services/mcp-manifest.service.ts
+var import_node_fs3 = require("fs");
+var import_node_path4 = __toESM(require("path"), 1);
+var import_common5 = require("@nestjs/common");
+
+// src/manifest.ts
+var import_node_path = __toESM(require("path"), 1);
+var import_node_crypto = require("crypto");
+var import_client = require("@modelcontextprotocol/sdk/client/index.js");
+var import_inMemory = require("@modelcontextprotocol/sdk/inMemory.js");
+
+// src/server-factory.ts
+var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
+
+// ../../../node_modules/@modelcontextprotocol/ext-apps/dist/src/server/index.js
+var import_protocol = require("@modelcontextprotocol/sdk/shared/protocol.js");
+var import_types = require("@modelcontextprotocol/sdk/types.js");
+var import_protocol2 = require("@modelcontextprotocol/sdk/shared/protocol.js");
+var import_types2 = require("@modelcontextprotocol/sdk/types.js");
+var import_v4 = require("zod/v4");
+var import_types3 = require("@modelcontextprotocol/sdk/types.js");
+var import_v42 = require("zod/v4");
+var r = ((Z) => typeof require < "u" ? require : typeof Proxy < "u" ? new Proxy(Z, {
+  get: /* @__PURE__ */ __name(($, J) => (typeof require < "u" ? require : $)[J], "get")
+}) : Z)(function(Z) {
+  if (typeof require < "u") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + Z + '" is not supported');
+});
+var v = import_v4.z.union([
+  import_v4.z.literal("light"),
+  import_v4.z.literal("dark")
+]).describe("Color theme preference for the host environment.");
+var K = import_v4.z.union([
+  import_v4.z.literal("inline"),
+  import_v4.z.literal("fullscreen"),
+  import_v4.z.literal("pip")
+]).describe("Display mode for UI presentation.");
+var QQ = import_v4.z.union([
+  import_v4.z.literal("--color-background-primary"),
+  import_v4.z.literal("--color-background-secondary"),
+  import_v4.z.literal("--color-background-tertiary"),
+  import_v4.z.literal("--color-background-inverse"),
+  import_v4.z.literal("--color-background-ghost"),
+  import_v4.z.literal("--color-background-info"),
+  import_v4.z.literal("--color-background-danger"),
+  import_v4.z.literal("--color-background-success"),
+  import_v4.z.literal("--color-background-warning"),
+  import_v4.z.literal("--color-background-disabled"),
+  import_v4.z.literal("--color-text-primary"),
+  import_v4.z.literal("--color-text-secondary"),
+  import_v4.z.literal("--color-text-tertiary"),
+  import_v4.z.literal("--color-text-inverse"),
+  import_v4.z.literal("--color-text-ghost"),
+  import_v4.z.literal("--color-text-info"),
+  import_v4.z.literal("--color-text-danger"),
+  import_v4.z.literal("--color-text-success"),
+  import_v4.z.literal("--color-text-warning"),
+  import_v4.z.literal("--color-text-disabled"),
+  import_v4.z.literal("--color-border-primary"),
+  import_v4.z.literal("--color-border-secondary"),
+  import_v4.z.literal("--color-border-tertiary"),
+  import_v4.z.literal("--color-border-inverse"),
+  import_v4.z.literal("--color-border-ghost"),
+  import_v4.z.literal("--color-border-info"),
+  import_v4.z.literal("--color-border-danger"),
+  import_v4.z.literal("--color-border-success"),
+  import_v4.z.literal("--color-border-warning"),
+  import_v4.z.literal("--color-border-disabled"),
+  import_v4.z.literal("--color-ring-primary"),
+  import_v4.z.literal("--color-ring-secondary"),
+  import_v4.z.literal("--color-ring-inverse"),
+  import_v4.z.literal("--color-ring-info"),
+  import_v4.z.literal("--color-ring-danger"),
+  import_v4.z.literal("--color-ring-success"),
+  import_v4.z.literal("--color-ring-warning"),
+  import_v4.z.literal("--font-sans"),
+  import_v4.z.literal("--font-mono"),
+  import_v4.z.literal("--font-weight-normal"),
+  import_v4.z.literal("--font-weight-medium"),
+  import_v4.z.literal("--font-weight-semibold"),
+  import_v4.z.literal("--font-weight-bold"),
+  import_v4.z.literal("--font-text-xs-size"),
+  import_v4.z.literal("--font-text-sm-size"),
+  import_v4.z.literal("--font-text-md-size"),
+  import_v4.z.literal("--font-text-lg-size"),
+  import_v4.z.literal("--font-heading-xs-size"),
+  import_v4.z.literal("--font-heading-sm-size"),
+  import_v4.z.literal("--font-heading-md-size"),
+  import_v4.z.literal("--font-heading-lg-size"),
+  import_v4.z.literal("--font-heading-xl-size"),
+  import_v4.z.literal("--font-heading-2xl-size"),
+  import_v4.z.literal("--font-heading-3xl-size"),
+  import_v4.z.literal("--font-text-xs-line-height"),
+  import_v4.z.literal("--font-text-sm-line-height"),
+  import_v4.z.literal("--font-text-md-line-height"),
+  import_v4.z.literal("--font-text-lg-line-height"),
+  import_v4.z.literal("--font-heading-xs-line-height"),
+  import_v4.z.literal("--font-heading-sm-line-height"),
+  import_v4.z.literal("--font-heading-md-line-height"),
+  import_v4.z.literal("--font-heading-lg-line-height"),
+  import_v4.z.literal("--font-heading-xl-line-height"),
+  import_v4.z.literal("--font-heading-2xl-line-height"),
+  import_v4.z.literal("--font-heading-3xl-line-height"),
+  import_v4.z.literal("--border-radius-xs"),
+  import_v4.z.literal("--border-radius-sm"),
+  import_v4.z.literal("--border-radius-md"),
+  import_v4.z.literal("--border-radius-lg"),
+  import_v4.z.literal("--border-radius-xl"),
+  import_v4.z.literal("--border-radius-full"),
+  import_v4.z.literal("--border-width-regular"),
+  import_v4.z.literal("--shadow-hairline"),
+  import_v4.z.literal("--shadow-sm"),
+  import_v4.z.literal("--shadow-md"),
+  import_v4.z.literal("--shadow-lg")
+]).describe("CSS variable keys available to MCP apps for theming.");
+var ZQ = import_v4.z.record(QQ.describe(`Style variables for theming MCP apps.
+
+Individual style keys are optional - hosts may provide any subset of these values.
+Values are strings containing CSS values (colors, sizes, font stacks, etc.).
+
+Note: This type uses \`Record<K, string | undefined>\` rather than \`Partial<Record<K, string>>\`
+for compatibility with Zod schema generation. Both are functionally equivalent for validation.`), import_v4.z.union([
+  import_v4.z.string(),
+  import_v4.z.undefined()
+]).describe(`Style variables for theming MCP apps.
+
+Individual style keys are optional - hosts may provide any subset of these values.
+Values are strings containing CSS values (colors, sizes, font stacks, etc.).
+
+Note: This type uses \`Record<K, string | undefined>\` rather than \`Partial<Record<K, string>>\`
+for compatibility with Zod schema generation. Both are functionally equivalent for validation.`)).describe(`Style variables for theming MCP apps.
+
+Individual style keys are optional - hosts may provide any subset of these values.
+Values are strings containing CSS values (colors, sizes, font stacks, etc.).
+
+Note: This type uses \`Record<K, string | undefined>\` rather than \`Partial<Record<K, string>>\`
+for compatibility with Zod schema generation. Both are functionally equivalent for validation.`);
+var $Q = import_v4.z.object({
+  method: import_v4.z.literal("ui/open-link"),
+  params: import_v4.z.object({
+    url: import_v4.z.string().describe("URL to open in the host's browser")
+  })
+});
+var I = import_v4.z.object({
+  isError: import_v4.z.boolean().optional().describe("True if the host failed to open the URL (e.g., due to security policy).")
+}).passthrough();
+var P = import_v4.z.object({
+  isError: import_v4.z.boolean().optional().describe("True if the download failed (e.g., user cancelled or host denied).")
+}).passthrough();
+var w = import_v4.z.object({
+  isError: import_v4.z.boolean().optional().describe("True if the host rejected or failed to deliver the message.")
+}).passthrough();
+var JQ = import_v4.z.object({
+  method: import_v4.z.literal("ui/notifications/sandbox-proxy-ready"),
+  params: import_v4.z.object({})
+});
+var Y = import_v4.z.object({
+  connectDomains: import_v4.z.array(import_v4.z.string()).optional().describe(`Origins for network requests (fetch/XHR/WebSocket).
+
+- Maps to CSP \`connect-src\` directive
+- Empty or omitted \u2192 no network connections (secure default)`),
+  resourceDomains: import_v4.z.array(import_v4.z.string()).optional().describe("Origins for static resources (images, scripts, stylesheets, fonts, media).\n\n- Maps to CSP `img-src`, `script-src`, `style-src`, `font-src`, `media-src` directives\n- Wildcard subdomains supported: `https://*.example.com`\n- Empty or omitted \u2192 no network resources (secure default)"),
+  frameDomains: import_v4.z.array(import_v4.z.string()).optional().describe("Origins for nested iframes.\n\n- Maps to CSP `frame-src` directive\n- Empty or omitted \u2192 no nested iframes allowed (`frame-src 'none'`)"),
+  baseUriDomains: import_v4.z.array(import_v4.z.string()).optional().describe("Allowed base URIs for the document.\n\n- Maps to CSP `base-uri` directive\n- Empty or omitted \u2192 only same origin allowed (`base-uri 'self'`)")
+});
+var j = import_v4.z.object({
+  camera: import_v4.z.object({}).optional().describe("Request camera access.\n\nMaps to Permission Policy `camera` feature."),
+  microphone: import_v4.z.object({}).optional().describe("Request microphone access.\n\nMaps to Permission Policy `microphone` feature."),
+  geolocation: import_v4.z.object({}).optional().describe("Request geolocation access.\n\nMaps to Permission Policy `geolocation` feature."),
+  clipboardWrite: import_v4.z.object({}).optional().describe("Request clipboard write access.\n\nMaps to Permission Policy `clipboard-write` feature.")
+});
+var XQ = import_v4.z.object({
+  method: import_v4.z.literal("ui/notifications/size-changed"),
+  params: import_v4.z.object({
+    width: import_v4.z.number().optional().describe("New width in pixels."),
+    height: import_v4.z.number().optional().describe("New height in pixels.")
+  })
+});
+var H = import_v4.z.object({
+  method: import_v4.z.literal("ui/notifications/tool-input"),
+  params: import_v4.z.object({
+    arguments: import_v4.z.record(import_v4.z.string(), import_v4.z.unknown().describe("Complete tool call arguments as key-value pairs.")).optional().describe("Complete tool call arguments as key-value pairs.")
+  })
+});
+var _ = import_v4.z.object({
+  method: import_v4.z.literal("ui/notifications/tool-input-partial"),
+  params: import_v4.z.object({
+    arguments: import_v4.z.record(import_v4.z.string(), import_v4.z.unknown().describe("Partial tool call arguments (incomplete, may change).")).optional().describe("Partial tool call arguments (incomplete, may change).")
+  })
+});
+var A = import_v4.z.object({
+  method: import_v4.z.literal("ui/notifications/tool-cancelled"),
+  params: import_v4.z.object({
+    reason: import_v4.z.string().optional().describe('Optional reason for the cancellation (e.g., "user action", "timeout").')
+  })
+});
+var f = import_v4.z.object({
+  fonts: import_v4.z.string().optional()
+});
+var u = import_v4.z.object({
+  variables: ZQ.optional().describe("CSS variables for theming the app."),
+  css: f.optional().describe("CSS blocks that apps can inject.")
+});
+var E = import_v4.z.object({
+  method: import_v4.z.literal("ui/resource-teardown"),
+  params: import_v4.z.object({})
+});
+var VQ = import_v4.z.record(import_v4.z.string(), import_v4.z.unknown());
+var O = import_v4.z.object({
+  text: import_v4.z.object({}).optional().describe("Host supports text content blocks."),
+  image: import_v4.z.object({}).optional().describe("Host supports image content blocks."),
+  audio: import_v4.z.object({}).optional().describe("Host supports audio content blocks."),
+  resource: import_v4.z.object({}).optional().describe("Host supports resource content blocks."),
+  resourceLink: import_v4.z.object({}).optional().describe("Host supports resource link content blocks."),
+  structuredContent: import_v4.z.object({}).optional().describe("Host supports structured content.")
+});
+var DQ = import_v4.z.object({
+  method: import_v4.z.literal("ui/notifications/request-teardown"),
+  params: import_v4.z.object({}).optional()
+});
+var d = import_v4.z.object({
+  experimental: import_v4.z.record(import_v4.z.string(), import_v4.z.record(import_v4.z.string(), import_v4.z.any()).describe("Experimental features keyed by identifier.")).optional().describe("Experimental features keyed by identifier."),
+  openLinks: import_v4.z.object({}).optional().describe("Host supports opening external URLs."),
+  downloadFile: import_v4.z.object({}).optional().describe("Host supports file downloads via ui/download-file."),
+  serverTools: import_v4.z.object({
+    listChanged: import_v4.z.boolean().optional().describe("Host supports tools/list_changed notifications.")
+  }).optional().describe("Host can proxy tool calls to the MCP server."),
+  serverResources: import_v4.z.object({
+    listChanged: import_v4.z.boolean().optional().describe("Host supports resources/list_changed notifications.")
+  }).optional().describe("Host can proxy resource reads to the MCP server."),
+  logging: import_v4.z.object({}).optional().describe("Host accepts log messages."),
+  sandbox: import_v4.z.object({
+    permissions: j.optional().describe("Permissions granted by the host (camera, microphone, geolocation)."),
+    csp: Y.optional().describe("CSP domains approved by the host.")
+  }).optional().describe("Sandbox configuration applied by the host."),
+  updateModelContext: O.optional().describe("Host accepts context updates (ui/update-model-context) to be included in the model's context for future turns."),
+  message: O.optional().describe("Host supports receiving content messages (ui/message) from the view."),
+  sampling: import_v4.z.object({
+    tools: import_v4.z.object({}).optional().describe("Host supports tool use via `tools` and `toolChoice` parameters.")
+  }).optional().describe("Host supports LLM sampling (sampling/createMessage) from the view.\nMirrors the MCP `ClientCapabilities.sampling` shape so hosts can pass it through.")
+});
+var h = import_v4.z.object({
+  experimental: import_v4.z.record(import_v4.z.string(), import_v4.z.record(import_v4.z.string(), import_v4.z.any()).describe("Experimental features keyed by identifier.")).optional().describe("Experimental features keyed by identifier."),
+  tools: import_v4.z.object({
+    listChanged: import_v4.z.boolean().optional().describe("App supports tools/list_changed notifications.")
+  }).optional().describe("App exposes MCP-style tools that the host can call."),
+  availableDisplayModes: import_v4.z.array(K).optional().describe("Display modes the app supports.")
+});
+var LQ = import_v4.z.object({
+  method: import_v4.z.literal("ui/notifications/initialized"),
+  params: import_v4.z.object({}).optional()
+});
+var WQ = import_v4.z.object({
+  csp: Y.optional().describe("Content Security Policy configuration for UI resources."),
+  permissions: j.optional().describe("Sandbox permissions requested by the UI resource."),
+  domain: import_v4.z.string().optional().describe(`Dedicated origin for view sandbox.
+
+Useful when views need stable, dedicated origins for OAuth callbacks, CORS policies, or API key allowlists.
+
+**Host-dependent:** The format and validation rules for this field are determined by each host. Servers MUST consult host-specific documentation for the expected domain format. Common patterns include:
+- Hash-based subdomains (e.g., \`{hash}.claudemcpcontent.com\`)
+- URL-derived subdomains (e.g., \`www-example-com.oaiusercontent.com\`)
+
+If omitted, host uses default sandbox origin (typically per-conversation).`),
+  prefersBorder: import_v4.z.boolean().optional().describe(`Visual boundary preference - true if view prefers a visible border.
+
+Boolean requesting whether a visible border and background is provided by the host. Specifying an explicit value for this is recommended because hosts' defaults may vary.
+
+- \`true\`: request visible border + background
+- \`false\`: request no visible border + background
+- omitted: host decides border`)
+});
+var BQ = import_v4.z.object({
+  method: import_v4.z.literal("ui/request-display-mode"),
+  params: import_v4.z.object({
+    mode: K.describe("The display mode being requested.")
+  })
+});
+var R = import_v4.z.object({
+  mode: K.describe("The display mode that was actually set. May differ from requested if not supported.")
+}).passthrough();
+var m = import_v4.z.union([
+  import_v4.z.literal("model"),
+  import_v4.z.literal("app")
+]).describe("Tool visibility scope - who can access the tool.");
+var GQ = import_v4.z.object({
+  resourceUri: import_v4.z.string().optional(),
+  visibility: import_v4.z.array(m).optional().describe(`Who can access this tool. Default: ["model", "app"]
+- "model": Tool visible to and callable by the agent
+- "app": Tool callable by the app from this server only`),
+  csp: import_v4.z.never().optional(),
+  permissions: import_v4.z.never().optional()
+});
+var dQ = import_v4.z.object({
+  mimeTypes: import_v4.z.array(import_v4.z.string()).optional().describe('Array of supported MIME types for UI resources.\nMust include `"text/html;profile=mcp-app"` for MCP Apps support.')
+});
+var KQ = import_v4.z.object({
+  method: import_v4.z.literal("ui/download-file"),
+  params: import_v4.z.object({
+    contents: import_v4.z.array(import_v4.z.union([
+      import_types3.EmbeddedResourceSchema,
+      import_types3.ResourceLinkSchema
+    ])).describe("Resource contents to download \u2014 embedded (inline data) or linked (host fetches). Uses standard MCP resource types.")
+  })
+});
+var NQ = import_v4.z.object({
+  method: import_v4.z.literal("ui/message"),
+  params: import_v4.z.object({
+    role: import_v4.z.literal("user").describe('Message role, currently only "user" is supported.'),
+    content: import_v4.z.array(import_types3.ContentBlockSchema).describe("Message content blocks (text, image, etc.).")
+  })
+});
+var YQ = import_v4.z.object({
+  method: import_v4.z.literal("ui/notifications/sandbox-resource-ready"),
+  params: import_v4.z.object({
+    html: import_v4.z.string().describe("HTML content to load into the inner iframe."),
+    sandbox: import_v4.z.string().optional().describe("Optional override for the inner iframe's sandbox attribute."),
+    csp: Y.optional().describe("CSP configuration from resource metadata."),
+    permissions: j.optional().describe("Sandbox permissions from resource metadata.")
+  })
+});
+var U = import_v4.z.object({
+  method: import_v4.z.literal("ui/notifications/tool-result"),
+  params: import_types3.CallToolResultSchema.describe("Standard MCP tool execution result.")
+});
+var T = import_v4.z.object({
+  toolInfo: import_v4.z.object({
+    id: import_types3.RequestIdSchema.optional().describe("JSON-RPC id of the tools/call request."),
+    tool: import_types3.ToolSchema.describe("Tool definition including name, inputSchema, etc.")
+  }).optional().describe("Metadata of the tool call that instantiated this App."),
+  theme: v.optional().describe("Current color theme preference."),
+  styles: u.optional().describe("Style configuration for theming the app."),
+  displayMode: K.optional().describe("How the UI is currently displayed."),
+  availableDisplayModes: import_v4.z.array(K).optional().describe("Display modes the host supports."),
+  containerDimensions: import_v4.z.union([
+    import_v4.z.object({
+      height: import_v4.z.number().describe("Fixed container height in pixels.")
+    }),
+    import_v4.z.object({
+      maxHeight: import_v4.z.union([
+        import_v4.z.number(),
+        import_v4.z.undefined()
+      ]).optional().describe("Maximum container height in pixels.")
+    })
+  ]).and(import_v4.z.union([
+    import_v4.z.object({
+      width: import_v4.z.number().describe("Fixed container width in pixels.")
+    }),
+    import_v4.z.object({
+      maxWidth: import_v4.z.union([
+        import_v4.z.number(),
+        import_v4.z.undefined()
+      ]).optional().describe("Maximum container width in pixels.")
+    })
+  ])).optional().describe(`Container dimensions. Represents the dimensions of the iframe or other
+container holding the app. Specify either width or maxWidth, and either height or maxHeight.`),
+  locale: import_v4.z.string().optional().describe("User's language and region preference in BCP 47 format."),
+  timeZone: import_v4.z.string().optional().describe("User's timezone in IANA format."),
+  userAgent: import_v4.z.string().optional().describe("Host application identifier."),
+  platform: import_v4.z.union([
+    import_v4.z.literal("web"),
+    import_v4.z.literal("desktop"),
+    import_v4.z.literal("mobile")
+  ]).optional().describe("Platform type for responsive design decisions."),
+  deviceCapabilities: import_v4.z.object({
+    touch: import_v4.z.boolean().optional().describe("Whether the device supports touch input."),
+    hover: import_v4.z.boolean().optional().describe("Whether the device supports hover interactions.")
+  }).optional().describe("Device input capabilities."),
+  safeAreaInsets: import_v4.z.object({
+    top: import_v4.z.number().describe("Top safe area inset in pixels."),
+    right: import_v4.z.number().describe("Right safe area inset in pixels."),
+    bottom: import_v4.z.number().describe("Bottom safe area inset in pixels."),
+    left: import_v4.z.number().describe("Left safe area inset in pixels.")
+  }).optional().describe("Mobile safe area boundaries in pixels.")
+}).passthrough();
+var k = import_v4.z.object({
+  method: import_v4.z.literal("ui/notifications/host-context-changed"),
+  params: T.describe("Partial context update containing only changed fields.")
+});
+var jQ = import_v4.z.object({
+  method: import_v4.z.literal("ui/update-model-context"),
+  params: import_v4.z.object({
+    content: import_v4.z.array(import_types3.ContentBlockSchema).optional().describe("Context content blocks (text, image, etc.)."),
+    structuredContent: import_v4.z.record(import_v4.z.string(), import_v4.z.unknown().describe("Structured content for machine-readable context data.")).optional().describe("Structured content for machine-readable context data.")
+  })
+});
+var FQ = import_v4.z.object({
+  method: import_v4.z.literal("ui/initialize"),
+  params: import_v4.z.object({
+    appInfo: import_types3.ImplementationSchema.describe("App identification (name and version)."),
+    appCapabilities: h.describe("Features and capabilities this app provides."),
+    protocolVersion: import_v4.z.string().describe("Protocol version this app supports.")
+  })
+});
+var M = import_v4.z.object({
+  protocolVersion: import_v4.z.string().describe('Negotiated protocol version string (e.g., "2025-11-21").'),
+  hostInfo: import_types3.ImplementationSchema.describe("Host application identification and version."),
+  hostCapabilities: d.describe("Features and capabilities provided by the host."),
+  hostContext: T.describe("Rich context about the host environment.")
+}).passthrough();
+var C = "ui/resourceUri";
+var p = "text/html;profile=mcp-app";
+function K3(Z, $, J, X) {
+  let V = J._meta, D = V.ui, L = V[C], W = V;
+  if (D?.resourceUri && !L) W = {
+    ...V,
+    [C]: D.resourceUri
+  };
+  else if (L && !D?.resourceUri) W = {
+    ...V,
+    ui: {
+      ...D,
+      resourceUri: L
+    }
+  };
+  return Z.registerTool($, {
+    ...J,
+    _meta: W
+  }, X);
+}
+__name(K3, "K3");
+function N3(Z, $, J, X, V) {
+  return Z.registerResource($, J, {
+    mimeType: p,
+    ...X
+  }, V);
+}
+__name(N3, "N3");
+
+// src/server-factory.ts
+function resolveServerInfo(options) {
+  return {
+    name: options.serverName ?? process.env.SUDA_APP_ID ?? MCP_DEFAULT_SERVER_NAME,
+    version: options.serverVersion ?? MCP_DEFAULT_SERVER_VERSION
+  };
+}
+__name(resolveServerInfo, "resolveServerInfo");
+function normalizeSchema(schema) {
+  return schema ?? {};
+}
+__name(normalizeSchema, "normalizeSchema");
+function buildToolMeta(def) {
+  const { ui, meta } = def.options;
+  if (!ui && !meta) return void 0;
+  const merged = {
+    ...meta ?? {}
+  };
+  if (ui) {
+    merged.ui = {
+      ...merged.ui ?? {},
+      resourceUri: ui.resourceUri,
+      ...ui.visibility ? {
+        visibility: ui.visibility
+      } : {}
+    };
+  }
+  return merged;
+}
+__name(buildToolMeta, "buildToolMeta");
+var MISSING_USER_MESSAGE = "\u8C03\u7528\u8005\u8EAB\u4EFD\u7F3A\u5931\uFF1A\u8BF7\u6C42\u672A\u643A\u5E26\u7528\u6237\u4FE1\u606F\uFF08x-larkgw-suda-webuser\uFF09\u3002\u8BF7\u901A\u8FC7 MCP Gateway \u6216\u5F00\u53D1\u670D\u52A1\u5165\u53E3\u8BBF\u95EE\uFF0C\u6216\u5728\u6A21\u5757\u914D\u7F6E\u4E2D\u8BBE\u7F6E requireUser: false\u3002";
+function assertUser(ctx, options) {
+  if (options.requireUser === false) return;
+  if (!ctx.user?.userId) {
+    throw new McpToolError(MISSING_USER_MESSAGE, {
+      code: "MCP_USER_REQUIRED"
+    });
+  }
+}
+__name(assertUser, "assertUser");
+function toErrorResult(error, location, onError) {
+  if (error instanceof McpToolError) {
+    const payload = {
+      message: error.message
+    };
+    if (error.code !== void 0) payload.code = error.code;
+    if (error.data !== void 0) payload.data = error.data;
+    return {
+      isError: true,
+      content: [
+        {
+          type: "text",
+          text: error.code ? `[${error.code}] ${error.message}` : error.message
+        }
+      ],
+      structuredContent: void 0,
+      _meta: {
+        error: payload
+      }
+    };
+  }
+  onError?.(error, location);
+  return {
+    isError: true,
+    content: [
+      {
+        type: "text",
+        text: `\u5DE5\u5177\u6267\u884C\u5931\u8D25\uFF08${location}\uFF09\uFF0C\u8BF7\u67E5\u770B\u5E94\u7528\u65E5\u5FD7`
+      }
+    ]
+  };
+}
+__name(toErrorResult, "toErrorResult");
+function createMcpServer(input) {
+  const { tools, resources, options, createContext, onError } = input;
+  const server = new import_mcp.McpServer(resolveServerInfo(options), {
+    instructions: options.instructions
+  });
+  const noContext = /* @__PURE__ */ __name(() => {
+    throw new Error("\u5F53\u524D McpServer \u5B9E\u4F8B\u672A\u7ED1\u5B9A\u8BF7\u6C42\u4E0A\u4E0B\u6587\uFF0C\u4E0D\u80FD\u6267\u884C\u5DE5\u5177");
+  }, "noContext");
+  for (const def of tools) {
+    const location = `${def.className}.${def.methodName}`;
+    const config = {
+      title: def.options.title,
+      description: def.options.description,
+      inputSchema: normalizeSchema(def.options.inputSchema),
+      outputSchema: def.options.outputSchema,
+      annotations: def.options.annotations,
+      _meta: buildToolMeta(def)
+    };
+    const callback = /* @__PURE__ */ __name(async (args, extra) => {
+      try {
+        const ctx = createContext ? createContext(extra) : noContext();
+        assertUser(ctx, options);
+        if (!def.handler) {
+          throw new Error(`\u5DE5\u5177\u300C${def.name}\u300D\u672A\u7ED1\u5B9A\u5B9E\u4F8B\uFF08${location}\uFF09`);
+        }
+        const result = await def.handler(args ?? {}, ctx);
+        if (def.options.outputSchema && result && !result.content) {
+          return {
+            ...result,
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify(result.structuredContent ?? null)
+              }
+            ]
+          };
+        }
+        return result;
+      } catch (error) {
+        return toErrorResult(error, location, onError);
+      }
+    }, "callback");
+    if (def.options.ui) {
+      K3(server, def.name, config, callback);
+    } else {
+      server.registerTool(def.name, config, callback);
+    }
+  }
+  for (const def of resources) {
+    const location = `${def.className}.${def.methodName}`;
+    const { uri, title, description, csp, permissions, meta } = def.options;
+    const uiMeta = {
+      ...meta ?? {}
+    };
+    if (csp) uiMeta.csp = csp;
+    if (permissions) uiMeta.permissions = permissions;
+    N3(server, def.name, uri, {
+      title,
+      description,
+      mimeType: p,
+      _meta: Object.keys(uiMeta).length > 0 ? {
+        ui: uiMeta
+      } : void 0
+    }, async (resourceUri, extra) => {
+      const ctx = createContext ? createContext(extra) : noContext();
+      assertUser(ctx, options);
+      if (!def.handler) {
+        throw new Error(`\u8D44\u6E90\u300C${uri}\u300D\u672A\u7ED1\u5B9A\u5B9E\u4F8B\uFF08${location}\uFF09`);
+      }
+      const html = await def.handler(ctx);
+      return {
+        contents: [
+          {
+            uri: resourceUri.href,
+            mimeType: p,
+            text: html
+          }
+        ]
+      };
+    });
+  }
+  if (input.skill) {
+    const skill = input.skill;
+    server.registerResource("app-skill", skill.uri, {
+      title: "\u5E94\u7528\u4F7F\u7528\u8BF4\u660E",
+      description: "\u5E94\u7528 MCP \u7684\u8C03\u7528\u65F6\u673A\u3001\u5DE5\u5177\u9009\u62E9\u3001\u8C03\u7528\u987A\u5E8F\u3001\u7EA6\u675F\u4E0E\u5931\u8D25\u5904\u7406",
+      mimeType: "text/markdown"
+    }, async (uri, extra) => {
+      const ctx = createContext ? createContext(extra) : noContext();
+      assertUser(ctx, options);
+      return {
+        contents: [
+          {
+            uri: uri.href,
+            mimeType: "text/markdown",
+            text: skill.content
+          }
+        ]
+      };
+    });
+  }
+  return server;
+}
+__name(createMcpServer, "createMcpServer");
+
+// src/manifest.ts
+async function buildManifest(input) {
+  const server = createMcpServer({
+    tools: input.tools,
+    resources: input.resources,
+    options: input.options,
+    skill: input.skill
+  });
+  const client = new import_client.Client({
+    name: "miaoda-mcp-manifest",
+    version: "1.0.0"
+  });
+  const [clientTransport, serverTransport] = import_inMemory.InMemoryTransport.createLinkedPair();
+  try {
+    await Promise.all([
+      server.connect(serverTransport),
+      client.connect(clientTransport)
+    ]);
+    const toolSource = new Map(input.tools.map((t2) => [
+      t2.name,
+      {
+        className: t2.className,
+        methodName: t2.methodName
+      }
+    ]));
+    const resourceSource = new Map(input.resources.map((r2) => [
+      r2.options.uri,
+      {
+        className: r2.className,
+        methodName: r2.methodName
+      }
+    ]));
+    const tools = input.tools.length > 0 ? (await client.listTools()).tools : [];
+    const resources = input.resources.length > 0 || input.skill ? (await client.listResources()).resources : [];
+    const manifest = {
+      version: MCP_MANIFEST_VERSION,
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      endpoint: MCP_ENDPOINT_PATH,
+      server: resolveServerInfo(input.options),
+      skill: input.skill ? {
+        uri: input.skill.uri,
+        path: input.skill.path
+      } : null,
+      tools: tools.map((tool) => ({
+        ...tool,
+        source: toolSource.get(tool.name) ?? {
+          className: "",
+          methodName: ""
+        }
+      })).sort((a2, b) => a2.name.localeCompare(b.name)),
+      resources: resources.map((resource) => ({
+        ...resource,
+        source: resourceSource.get(resource.uri)
+      })).sort((a2, b) => a2.uri.localeCompare(b.uri))
+    };
+    return manifest;
+  } finally {
+    await Promise.allSettled([
+      client.close(),
+      server.close()
+    ]);
+  }
+}
+__name(buildManifest, "buildManifest");
+function serializeManifest(manifest) {
+  return `${JSON.stringify(manifest, null, 2)}
+`;
+}
+__name(serializeManifest, "serializeManifest");
+function stripVolatile(json) {
+  return json.replace(/"generatedAt": "[^"]*"/, '"generatedAt": ""');
+}
+__name(stripVolatile, "stripVolatile");
+async function writeManifest(manifest, { cwd, relativePath = MCP_MANIFEST_PATH, fs: fs5 }) {
+  const file = import_node_path.default.resolve(cwd, relativePath);
+  const next = serializeManifest(manifest);
+  let previous;
+  try {
+    previous = await fs5.readFile(file, "utf8");
+  } catch {
+    previous = void 0;
+  }
+  if (previous !== void 0 && stripVolatile(previous) === stripVolatile(next)) {
+    return {
+      changed: false,
+      file,
+      manifest
+    };
+  }
+  await fs5.mkdir(import_node_path.default.dirname(file), {
+    recursive: true
+  });
+  const temporary = `${file}.${(0, import_node_crypto.randomUUID)()}.tmp`;
+  try {
+    await fs5.writeFile(temporary, next, "utf8");
+    await fs5.rename(temporary, file);
+  } finally {
+    await fs5.rm(temporary, {
+      force: true
+    });
+  }
+  return {
+    changed: true,
+    file,
+    manifest
+  };
+}
+__name(writeManifest, "writeManifest");
+
+// src/services/mcp-registry.service.ts
+var import_common4 = require("@nestjs/common");
+var import_core = require("@nestjs/core");
+
+// src/metadata.ts
+var import_reflect_metadata = require("reflect-metadata");
+function isMcpToolsClass(target) {
+  return typeof target === "function" && Reflect.getMetadata(MCP_TOOLS_METADATA_KEY, target) !== void 0;
+}
+__name(isMcpToolsClass, "isMcpToolsClass");
+function getAllMethodNames(prototype) {
+  const names = /* @__PURE__ */ new Set();
+  let current = prototype;
+  while (current && current !== Object.prototype) {
+    for (const name of Object.getOwnPropertyNames(current)) {
+      if (name === "constructor") continue;
+      const descriptor = Object.getOwnPropertyDescriptor(current, name);
+      if (descriptor && typeof descriptor.value === "function") {
+        names.add(name);
+      }
+    }
+    current = Object.getPrototypeOf(current);
+  }
+  return [
+    ...names
+  ];
+}
+__name(getAllMethodNames, "getAllMethodNames");
+function collectFromClass(target, instance) {
+  const classOptions = Reflect.getMetadata(MCP_TOOLS_METADATA_KEY, target) ?? {};
+  const prototype = target.prototype;
+  const tools = [];
+  const resources = [];
+  for (const methodName of getAllMethodNames(prototype)) {
+    const method = prototype[methodName];
+    const toolOptions = Reflect.getMetadata(MCP_TOOL_METADATA_KEY, method);
+    const resourceOptions = Reflect.getMetadata(MCP_UI_RESOURCE_METADATA_KEY, method);
+    if (toolOptions && resourceOptions) {
+      throw new Error(`${target.name}.${methodName} \u4E0D\u80FD\u540C\u65F6\u6807\u8BB0 @McpTool() \u4E0E @McpUiResource()`);
+    }
+    if (toolOptions) {
+      const name = `${classOptions.prefix ?? ""}${toolOptions.name ?? methodName}`;
+      tools.push({
+        name,
+        options: toolOptions,
+        className: target.name,
+        methodName,
+        handler: instance ? method.bind(instance) : void 0
+      });
+    } else if (resourceOptions) {
+      resources.push({
+        name: resourceOptions.name ?? methodName,
+        options: resourceOptions,
+        className: target.name,
+        methodName,
+        handler: instance ? method.bind(instance) : void 0
+      });
+    }
+  }
+  return {
+    tools,
+    resources
+  };
+}
+__name(collectFromClass, "collectFromClass");
+function mergeAndValidate(parts) {
+  const tools = [];
+  const resources = [];
+  const problems = [];
+  const toolNames = /* @__PURE__ */ new Map();
+  const resourceUris = /* @__PURE__ */ new Map();
+  for (const part of parts) {
+    for (const tool of part.tools) {
+      const location = `${tool.className}.${tool.methodName}`;
+      if (!MCP_TOOL_NAME_PATTERN.test(tool.name)) {
+        problems.push(`\u5DE5\u5177\u540D\u300C${tool.name}\u300D\u4E0D\u5408\u6CD5\uFF08${location}\uFF09\uFF0C\u9700\u5339\u914D ${MCP_TOOL_NAME_PATTERN}`);
+      }
+      const existing = toolNames.get(tool.name);
+      if (existing) {
+        problems.push(`\u5DE5\u5177\u540D\u300C${tool.name}\u300D\u91CD\u590D\uFF1A${existing} \u4E0E ${location}`);
+      } else {
+        toolNames.set(tool.name, location);
+      }
+      tools.push(tool);
+    }
+    for (const resource of part.resources) {
+      const location = `${resource.className}.${resource.methodName}`;
+      const uri = resource.options.uri;
+      if (!uri.startsWith(MCP_UI_RESOURCE_SCHEME)) {
+        problems.push(`\u8D44\u6E90 URI\u300C${uri}\u300D\u5FC5\u987B\u4EE5 ${MCP_UI_RESOURCE_SCHEME} \u5F00\u5934\uFF08${location}\uFF09`);
+      }
+      const existing = resourceUris.get(uri);
+      if (existing) {
+        problems.push(`\u8D44\u6E90 URI\u300C${uri}\u300D\u91CD\u590D\uFF1A${existing} \u4E0E ${location}`);
+      } else {
+        resourceUris.set(uri, location);
+      }
+      resources.push(resource);
+    }
+  }
+  for (const tool of tools) {
+    const resourceUri = tool.options.ui?.resourceUri;
+    if (resourceUri && !resourceUris.has(resourceUri)) {
+      problems.push(`\u5DE5\u5177\u300C${tool.name}\u300D\u5F15\u7528\u7684 ui.resourceUri\u300C${resourceUri}\u300D\u672A\u627E\u5230\u5BF9\u5E94\u7684 @McpUiResource()\uFF08${tool.className}.${tool.methodName}\uFF09`);
+    }
+  }
+  if (problems.length > 0) {
+    throw new Error(`MCP \u5B9A\u4E49\u6821\u9A8C\u5931\u8D25\uFF1A
+- ${problems.join("\n- ")}`);
+  }
+  return {
+    tools,
+    resources
+  };
+}
+__name(mergeAndValidate, "mergeAndValidate");
+
+// src/services/mcp-registry.service.ts
+function _ts_decorate(decorators, target, key, desc) {
+  var c = arguments.length, r2 = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d2;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r2 = Reflect.decorate(decorators, target, key, desc);
+  else for (var i2 = decorators.length - 1; i2 >= 0; i2--) if (d2 = decorators[i2]) r2 = (c < 3 ? d2(r2) : c > 3 ? d2(target, key, r2) : d2(target, key)) || r2;
+  return c > 3 && r2 && Object.defineProperty(target, key, r2), r2;
+}
+__name(_ts_decorate, "_ts_decorate");
+function _ts_metadata(k2, v2) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k2, v2);
+}
+__name(_ts_metadata, "_ts_metadata");
+function _ts_param(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param, "_ts_param");
+var McpRegistryService = class _McpRegistryService {
+  static {
+    __name(this, "McpRegistryService");
+  }
+  discoveryService;
+  options;
+  logger = new import_common4.Logger(_McpRegistryService.name);
+  definitions = {
+    tools: [],
+    resources: []
+  };
+  initialized = false;
+  constructor(discoveryService, options) {
+    this.discoveryService = discoveryService;
+    this.options = options;
+  }
+  onModuleInit() {
+    if (this.options.enabled === false) {
+      this.initialized = true;
+      return;
+    }
+    this.discover();
+  }
+  /** 全部工具定义（已绑定实例） */
+  getTools() {
+    return this.definitions.tools;
+  }
+  /** 全部 MCP Apps 资源定义（已绑定实例） */
+  getResources() {
+    return this.definitions.resources;
+  }
+  /** 是否至少注册了一个工具或资源 */
+  hasAny() {
+    return this.definitions.tools.length > 0 || this.definitions.resources.length > 0;
+  }
+  /** 是否已完成扫描 */
+  isInitialized() {
+    return this.initialized;
+  }
+  discover() {
+    const wrappers = [
+      ...this.discoveryService.getProviders(),
+      ...this.discoveryService.getControllers()
+    ];
+    const parts = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const wrapper of wrappers) {
+      if (isMcpToolsClass(wrapper.metatype) && (wrapper.scope === import_common4.Scope.REQUEST || wrapper.scope === import_common4.Scope.TRANSIENT || !wrapper.isDependencyTreeStatic())) {
+        throw new Error(`${wrapper.metatype.name}: MCP \u5DE5\u5177\u5FC5\u987B\u4F7F\u7528\u5355\u4F8B\u53CA\u5355\u4F8B\u4F9D\u8D56\uFF0C\u901A\u8FC7 ctx.user \u8BFB\u53D6\u8BF7\u6C42\u8EAB\u4EFD`);
+      }
+      const { instance } = wrapper;
+      if (!instance || typeof instance !== "object") {
+        if (isMcpToolsClass(wrapper.metatype)) {
+          this.logger.warn(`${wrapper.metatype.name} \u6807\u8BB0\u4E86 @McpTools() \u4F46\u6CA1\u6709\u53EF\u7528\u5B9E\u4F8B\uFF08request/transient \u4F5C\u7528\u57DF\u6216\u672A\u5B9E\u4F8B\u5316\uFF09\uFF0C\u5DF2\u8DF3\u8FC7`);
+        }
+        continue;
+      }
+      const target = instance.constructor;
+      if (!isMcpToolsClass(target) || seen.has(instance)) continue;
+      seen.add(instance);
+      parts.push(collectFromClass(target, instance));
+    }
+    this.definitions = mergeAndValidate(parts);
+    this.initialized = true;
+    const { tools, resources } = this.definitions;
+    if (tools.length === 0 && resources.length === 0) {
+      this.logger.debug("\u672A\u53D1\u73B0 MCP \u5DE5\u5177\uFF0C/__innerapi__/mcp \u5C06\u8FD4\u56DE 404");
+      return;
+    }
+    this.logger.log(`\u5DF2\u6CE8\u518C ${tools.length} \u4E2A MCP \u5DE5\u5177${resources.length ? `\u3001${resources.length} \u4E2A MCP Apps \u8D44\u6E90` : ""}\uFF1A${tools.map((t2) => t2.name).join(", ")}`);
+  }
+};
+McpRegistryService = _ts_decorate([
+  (0, import_common4.Injectable)(),
+  _ts_param(0, (0, import_common4.Inject)(import_core.DiscoveryService)),
+  _ts_param(1, (0, import_common4.Inject)(MCP_MODULE_OPTIONS)),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof import_core.DiscoveryService === "undefined" ? Object : import_core.DiscoveryService,
+    typeof McpModuleOptions === "undefined" ? Object : McpModuleOptions
+  ])
+], McpRegistryService);
+
+// src/skill.ts
+var import_node_fs = require("fs");
+var import_node_path2 = __toESM(require("path"), 1);
+async function readMcpSkill(cwd = process.cwd()) {
+  const root = await import_node_fs.promises.realpath(cwd);
+  let file;
+  try {
+    file = await import_node_fs.promises.realpath(import_node_path2.default.join(root, MCP_SKILL_PATH));
+  } catch (error) {
+    if (error.code === "ENOENT") return null;
+    throw error;
+  }
+  const relative = import_node_path2.default.relative(root, file);
+  if (relative.startsWith("..") || import_node_path2.default.isAbsolute(relative)) throw new Error("MCP Skill \u5FC5\u987B\u4F4D\u4E8E\u5E94\u7528\u5DE5\u7A0B\u5185");
+  if (!(await import_node_fs.promises.stat(file)).isFile()) throw new Error("MCP Skill \u5FC5\u987B\u4E3A\u666E\u901A\u6587\u4EF6");
+  const handle = await import_node_fs.promises.open(file, import_node_fs.constants.O_RDONLY | import_node_fs.constants.O_NONBLOCK | import_node_fs.constants.O_NOFOLLOW);
+  try {
+    const stat = await handle.stat();
+    const limit = 1024 * 1024;
+    if (!stat.isFile() || stat.size > limit) throw new Error("MCP Skill \u5FC5\u987B\u4E3A\u4E0D\u8D85\u8FC7 1 MiB \u7684\u666E\u901A\u6587\u4EF6");
+    const buffer = Buffer.alloc(limit + 1);
+    let length = 0;
+    while (length < buffer.length) {
+      const { bytesRead } = await handle.read(buffer, length, buffer.length - length, null);
+      if (bytesRead === 0) break;
+      length += bytesRead;
+    }
+    if (length > limit) throw new Error("MCP Skill \u4E0D\u80FD\u8D85\u8FC7 1 MiB");
+    const content = new TextDecoder("utf-8", {
+      fatal: true
+    }).decode(buffer.subarray(0, length));
+    return {
+      uri: MCP_SKILL_URI,
+      path: MCP_SKILL_PATH,
+      content
+    };
+  } finally {
+    await handle.close();
+  }
+}
+__name(readMcpSkill, "readMcpSkill");
+
+// src/source-locations.ts
+var import_node_fs2 = require("fs");
+var import_node_module = require("module");
+var import_node_path3 = __toESM(require("path"), 1);
+var sdkEntrypoints = /* @__PURE__ */ new Set([
+  "@lark-apaas/nestjs-mcp",
+  "@lark-apaas/fullstack-nestjs-core"
+]);
+var ignored = /* @__PURE__ */ new Set([
+  "node_modules",
+  "dist",
+  "build",
+  "coverage",
+  "__tests__",
+  "__test__",
+  "test",
+  "tests"
+]);
+function isInside(root, file) {
+  const relative = import_node_path3.default.relative(root, file);
+  return relative !== ".." && !relative.startsWith(`..${import_node_path3.default.sep}`) && !import_node_path3.default.isAbsolute(relative);
+}
+__name(isInside, "isInside");
+async function collectSourceLocations(tools, resources, cwd = process.cwd()) {
+  const empty = /* @__PURE__ */ __name(() => ({
+    tools: {},
+    resources: {}
+  }), "empty");
+  try {
+    if (!tools.length && !resources.length) return empty();
+    const root = await import_node_fs2.promises.realpath(cwd);
+    const server = import_node_path3.default.join(root, "server");
+    if ((await import_node_fs2.promises.lstat(server)).isSymbolicLink()) return empty();
+    const ts = (0, import_node_module.createRequire)(import_node_path3.default.join(root, "package.json"))("typescript");
+    const sources = /* @__PURE__ */ new Map();
+    const scan = /* @__PURE__ */ __name(async (directory) => {
+      for (const item of await import_node_fs2.promises.readdir(directory, {
+        withFileTypes: true
+      })) {
+        if (item.isSymbolicLink() || item.name.startsWith(".") || ignored.has(item.name)) continue;
+        const file = import_node_path3.default.join(directory, item.name);
+        if (item.isDirectory()) await scan(file);
+        else if (item.isFile() && /\.(?:ts|tsx|mts|cts)$/.test(item.name) && !/\.(?:d|spec|test)\.(?:ts|tsx|mts|cts)$/.test(item.name)) {
+          sources.set(file, await import_node_fs2.promises.readFile(file, "utf8"));
+        }
+      }
+    }, "scan");
+    await scan(server);
+    if (!sources.size) return empty();
+    const options = {
+      noLib: true,
+      noResolve: true,
+      experimentalDecorators: true
+    };
+    const host = ts.createCompilerHost(options);
+    host.getSourceFile = (file, languageVersion) => {
+      const text = sources.get(file);
+      return text === void 0 ? void 0 : ts.createSourceFile(file, text, languageVersion, true);
+    };
+    const program = ts.createProgram([
+      ...sources.keys()
+    ], options, host);
+    if (program.getSyntacticDiagnostics().length) return empty();
+    const checker = program.getTypeChecker();
+    const isSdkReference = /* @__PURE__ */ __name((expression, exported) => {
+      let identifier;
+      let namespace = false;
+      if (ts.isIdentifier(expression)) identifier = expression;
+      else if (ts.isPropertyAccessExpression(expression) && ts.isIdentifier(expression.expression) && expression.name.text === exported) {
+        identifier = expression.expression;
+        namespace = true;
+      } else return false;
+      const declarations = checker.getSymbolAtLocation(identifier)?.declarations;
+      if (declarations?.length !== 1) return false;
+      const declaration = declarations[0];
+      let clause;
+      if (!namespace && ts.isImportSpecifier(declaration) && !declaration.isTypeOnly && (declaration.propertyName ?? declaration.name).text === exported) {
+        clause = declaration.parent.parent;
+      } else if (namespace && ts.isNamespaceImport(declaration)) clause = declaration.parent;
+      else return false;
+      return !clause.isTypeOnly && ts.isStringLiteral(clause.parent.moduleSpecifier) && sdkEntrypoints.has(clause.parent.moduleSpecifier.text);
+    }, "isSdkReference");
+    const decorated = /* @__PURE__ */ __name((node, exported) => {
+      return ts.canHaveDecorators(node) && !!ts.getDecorators(node)?.some(({ expression }) => ts.isCallExpression(expression) && isSdkReference(expression.expression, exported));
+    }, "decorated");
+    const classes = /* @__PURE__ */ new Map();
+    for (const source of program.getSourceFiles()) {
+      const visit = /* @__PURE__ */ __name((node) => {
+        if (ts.isClassDeclaration(node) && node.name) {
+          const matches = classes.get(node.name.text) ?? [];
+          matches.push(node);
+          classes.set(node.name.text, matches);
+        }
+        ts.forEachChild(node, visit);
+      }, "visit");
+      visit(source);
+    }
+    const methodFor = /* @__PURE__ */ __name((definition, decorator) => {
+      const matches = classes.get(definition.className);
+      if (matches?.length !== 1 || !decorated(matches[0], "McpTools")) return void 0;
+      const methods = matches[0].members.filter((member) => ts.isMethodDeclaration(member) && (ts.isIdentifier(member.name) || ts.isStringLiteral(member.name)) && member.name.text === definition.methodName);
+      if (methods.length !== 1 || !methods[0].body || !decorated(methods[0], decorator)) return void 0;
+      return methods[0];
+    }, "methodFor");
+    const result = empty();
+    const unique = /* @__PURE__ */ __name((items, key) => {
+      const counts = /* @__PURE__ */ new Map();
+      for (const item of items) counts.set(key(item), (counts.get(key(item)) ?? 0) + 1);
+      return items.filter((item) => counts.get(key(item)) === 1);
+    }, "unique");
+    const put = /* @__PURE__ */ __name((map, key, value) => {
+      Object.defineProperty(map, key, {
+        value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+      });
+    }, "put");
+    for (const tool of unique(tools, (item) => item.name)) {
+      const method = methodFor(tool, "McpTool");
+      if (!method) continue;
+      const source = method.getSourceFile();
+      put(result.tools, tool.name, {
+        path: import_node_path3.default.relative(root, source.fileName).split(import_node_path3.default.sep).join("/"),
+        line: source.getLineAndCharacterOfPosition(method.name.getStart(source)).line + 1
+      });
+    }
+    for (const resource of unique(resources, (item) => item.options.uri)) {
+      const method = methodFor(resource, "McpUiResource");
+      if (!method) continue;
+      const calls = [];
+      const visit = /* @__PURE__ */ __name((node) => {
+        if (ts.isFunctionLike(node) || ts.isClassLike(node)) return;
+        if (ts.isCallExpression(node) && isSdkReference(node.expression, "readMcpUiTemplate")) calls.push(node);
+        ts.forEachChild(node, visit);
+      }, "visit");
+      visit(method.body);
+      if (calls.length !== 1 || calls[0].arguments.length !== 1) continue;
+      const entry = calls[0].arguments[0];
+      if (!(ts.isStringLiteral(entry) || ts.isNoSubstitutionTemplateLiteral(entry)) || !/^[A-Za-z0-9_-]+$/.test(entry.text)) continue;
+      const relative = `client/mcp-ui/${entry.text}/index.html`;
+      try {
+        const file = await import_node_fs2.promises.realpath(import_node_path3.default.join(root, relative));
+        if (file !== import_node_path3.default.join(root, relative) || !isInside(root, file) || !(await import_node_fs2.promises.stat(file)).isFile()) continue;
+        put(result.resources, resource.options.uri, {
+          path: relative
+        });
+      } catch {
+      }
+    }
+    return result;
+  } catch {
+    return empty();
+  }
+}
+__name(collectSourceLocations, "collectSourceLocations");
+
+// src/services/mcp-manifest.service.ts
+function _ts_decorate2(decorators, target, key, desc) {
+  var c = arguments.length, r2 = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d2;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r2 = Reflect.decorate(decorators, target, key, desc);
+  else for (var i2 = decorators.length - 1; i2 >= 0; i2--) if (d2 = decorators[i2]) r2 = (c < 3 ? d2(r2) : c > 3 ? d2(target, key, r2) : d2(target, key)) || r2;
+  return c > 3 && r2 && Object.defineProperty(target, key, r2), r2;
+}
+__name(_ts_decorate2, "_ts_decorate");
+function _ts_metadata2(k2, v2) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k2, v2);
+}
+__name(_ts_metadata2, "_ts_metadata");
+function _ts_param2(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param2, "_ts_param");
+var McpManifestService = class _McpManifestService {
+  static {
+    __name(this, "McpManifestService");
+  }
+  registry;
+  options;
+  logger = new import_common5.Logger(_McpManifestService.name);
+  sources = {
+    tools: {},
+    resources: {}
+  };
+  constructor(registry, options) {
+    this.registry = registry;
+    this.options = options;
+  }
+  async onApplicationBootstrap() {
+    if (this.options.enabled === false) return;
+    try {
+      this.sources = await collectSourceLocations(this.registry.getTools(), this.registry.getResources());
+    } catch (error) {
+      this.logger.warn(`MCP \u6E90\u7801\u5B9A\u4F4D\u4E0D\u53EF\u7528\uFF1A${error instanceof Error ? error.message : String(error)}`);
+    }
+    const writeOnBoot = this.options.manifest?.writeOnBoot ?? process.env.NODE_ENV !== "production";
+    if (!writeOnBoot) return;
+    try {
+      if (!this.registry.hasAny() && !await readMcpSkill()) {
+        await import_node_fs3.promises.rm(import_node_path4.default.resolve(process.cwd(), this.options.manifest?.path ?? MCP_MANIFEST_PATH), {
+          force: true
+        });
+        return;
+      }
+      const { changed, file } = await this.write();
+      if (changed) this.logger.log(`\u5DF2\u66F4\u65B0 MCP \u6E05\u5355\uFF1A${import_node_path4.default.relative(process.cwd(), file)}`);
+    } catch (error) {
+      this.logger.warn(`\u5199\u5165 MCP \u6E05\u5355\u5931\u8D25\uFF1A${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  /** 生成清单对象 */
+  async build(cwd = process.cwd()) {
+    const manifest = await buildManifest({
+      skill: await readMcpSkill(cwd),
+      tools: this.registry.getTools(),
+      resources: this.registry.getResources(),
+      options: this.options
+    });
+    manifest.sources = {
+      tools: {
+        ...this.sources.tools
+      },
+      resources: {
+        ...this.sources.resources
+      }
+    };
+    if (manifest.skill) manifest.sources.resources[manifest.skill.uri] = {
+      path: manifest.skill.path
+    };
+    return manifest;
+  }
+  /** 面板查询不读写派生清单；与本次 MCP 请求使用同一份 Skill 文件读取逻辑。 */
+  async catalog() {
+    const skill = await readMcpSkill();
+    const manifest = await buildManifest({
+      tools: this.registry.getTools(),
+      resources: this.registry.getResources(),
+      options: this.options,
+      skill
+    });
+    const sources = {
+      tools: {
+        ...this.sources.tools
+      },
+      resources: {
+        ...this.sources.resources
+      }
+    };
+    if (skill) sources.resources[skill.uri] = {
+      path: skill.path
+    };
+    return {
+      version: manifest.version,
+      generatedAt: manifest.generatedAt,
+      endpoint: manifest.endpoint,
+      tools: manifest.tools.map(({ source: _source, ...tool }) => tool),
+      resources: manifest.resources.map(({ source: _source, ...resource }) => resource),
+      skill,
+      sources
+    };
+  }
+  /** 生成并写入清单文件，内容未变化时不落盘 */
+  async write(cwd = process.cwd()) {
+    const manifest = await this.build(cwd);
+    return writeManifest(manifest, {
+      cwd,
+      relativePath: this.options.manifest?.path,
+      fs: import_node_fs3.promises
+    });
+  }
+};
+McpManifestService = _ts_decorate2([
+  (0, import_common5.Injectable)(),
+  _ts_param2(0, (0, import_common5.Inject)(McpRegistryService)),
+  _ts_param2(1, (0, import_common5.Inject)(MCP_MODULE_OPTIONS)),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    typeof McpRegistryService === "undefined" ? Object : McpRegistryService,
+    typeof McpModuleOptions === "undefined" ? Object : McpModuleOptions
+  ])
+], McpManifestService);
+
+// src/controllers/mcp-manifest.controller.ts
+function _ts_decorate3(decorators, target, key, desc) {
+  var c = arguments.length, r2 = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d2;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r2 = Reflect.decorate(decorators, target, key, desc);
+  else for (var i2 = decorators.length - 1; i2 >= 0; i2--) if (d2 = decorators[i2]) r2 = (c < 3 ? d2(r2) : c > 3 ? d2(target, key, r2) : d2(target, key)) || r2;
+  return c > 3 && r2 && Object.defineProperty(target, key, r2), r2;
+}
+__name(_ts_decorate3, "_ts_decorate");
+function _ts_metadata3(k2, v2) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k2, v2);
+}
+__name(_ts_metadata3, "_ts_metadata");
+function _ts_param3(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param3, "_ts_param");
+var McpManifestController = class _McpManifestController {
+  static {
+    __name(this, "McpManifestController");
+  }
+  manifest;
+  registry;
+  logger = new import_common6.Logger(_McpManifestController.name);
+  constructor(manifest, registry) {
+    this.manifest = manifest;
+    this.registry = registry;
+  }
+  async get(res) {
+    res.setHeader("Cache-Control", "no-store");
+    if (!this.registry.isInitialized()) {
+      res.status(503).type("application/problem+json").json({
+        type: "about:blank",
+        title: "Service Unavailable",
+        status: 503
+      });
+      return;
+    }
+    try {
+      res.json(await this.manifest.catalog());
+    } catch (error) {
+      this.logger.error(error instanceof Error ? error.stack : String(error));
+      res.status(500).type("application/problem+json").json({
+        type: "about:blank",
+        title: "Internal Server Error",
+        status: 500
+      });
+    }
+  }
+};
+_ts_decorate3([
+  (0, import_common6.Get)(),
+  _ts_param3(0, (0, import_common6.Res)()),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof Response === "undefined" ? Object : Response
+  ]),
+  _ts_metadata3("design:returntype", Promise)
+], McpManifestController.prototype, "get", null);
+McpManifestController = _ts_decorate3([
+  (0, import_swagger.ApiExcludeController)(),
+  (0, import_common6.Controller)("__innerapi__/mcp/manifest"),
+  _ts_param3(0, (0, import_common6.Inject)(McpManifestService)),
+  _ts_param3(1, (0, import_common6.Inject)(McpRegistryService)),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof McpManifestService === "undefined" ? Object : McpManifestService,
+    typeof McpRegistryService === "undefined" ? Object : McpRegistryService
+  ])
+], McpManifestController);
+
+// src/controllers/mcp.controller.ts
+var import_common8 = require("@nestjs/common");
+var import_swagger2 = require("@nestjs/swagger");
+
+// src/services/mcp-server.service.ts
+var import_common7 = require("@nestjs/common");
+var import_streamableHttp = require("@modelcontextprotocol/sdk/server/streamableHttp.js");
+function _ts_decorate4(decorators, target, key, desc) {
+  var c = arguments.length, r2 = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d2;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r2 = Reflect.decorate(decorators, target, key, desc);
+  else for (var i2 = decorators.length - 1; i2 >= 0; i2--) if (d2 = decorators[i2]) r2 = (c < 3 ? d2(r2) : c > 3 ? d2(target, key, r2) : d2(target, key)) || r2;
+  return c > 3 && r2 && Object.defineProperty(target, key, r2), r2;
+}
+__name(_ts_decorate4, "_ts_decorate");
+function _ts_metadata4(k2, v2) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k2, v2);
+}
+__name(_ts_metadata4, "_ts_metadata");
+function _ts_param4(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param4, "_ts_param");
+var McpServerService = class _McpServerService {
+  static {
+    __name(this, "McpServerService");
+  }
+  registry;
+  options;
+  logger = new import_common7.Logger(_McpServerService.name);
+  constructor(registry, options) {
+    this.registry = registry;
+    this.options = options;
+  }
+  /**
+  * 为一次 HTTP 请求构造执行上下文。
+  */
+  createContext(req, extra) {
+    return {
+      user: req.userContext ?? {},
+      request: req,
+      signal: extra?.signal ?? new AbortController().signal,
+      requestId: extra?.requestId ?? "",
+      extra
+    };
+  }
+  /**
+  * 处理一条 MCP over Streamable HTTP 请求（POST）。
+  */
+  async handle(req, res) {
+    const skill = await readMcpSkill();
+    if (!this.registry.hasAny() && !skill) {
+      res.status(404).json({
+        jsonrpc: "2.0",
+        error: {
+          code: -32e3,
+          message: "\u5F53\u524D\u5E94\u7528\u672A\u6CE8\u518C\u4EFB\u4F55 MCP \u80FD\u529B"
+        },
+        id: null
+      });
+      return;
+    }
+    const server = createMcpServer({
+      skill,
+      tools: this.registry.getTools(),
+      resources: this.registry.getResources(),
+      options: this.options,
+      createContext: /* @__PURE__ */ __name((extra) => this.createContext(req, extra), "createContext"),
+      onError: /* @__PURE__ */ __name((error, location) => {
+        this.logger.error(`MCP \u5DE5\u5177\u6267\u884C\u5F02\u5E38\uFF08${location}\uFF09\uFF1A${error instanceof Error ? error.stack ?? error.message : String(error)}`);
+      }, "onError")
+    });
+    const transport = new import_streamableHttp.StreamableHTTPServerTransport({
+      sessionIdGenerator: void 0,
+      enableJsonResponse: true
+    });
+    res.on("close", () => {
+      server.close().catch((error) => {
+        this.logger.warn(`\u5173\u95ED McpServer \u5931\u8D25\uFF1A${error instanceof Error ? error.message : String(error)}`);
+      });
+    });
+    await server.connect(transport);
+    await transport.handleRequest(req, res, req.body);
+  }
+};
+McpServerService = _ts_decorate4([
+  (0, import_common7.Injectable)(),
+  _ts_param4(0, (0, import_common7.Inject)(McpRegistryService)),
+  _ts_param4(1, (0, import_common7.Inject)(MCP_MODULE_OPTIONS)),
+  _ts_metadata4("design:type", Function),
+  _ts_metadata4("design:paramtypes", [
+    typeof McpRegistryService === "undefined" ? Object : McpRegistryService,
+    typeof McpModuleOptions === "undefined" ? Object : McpModuleOptions
+  ])
+], McpServerService);
+
+// src/controllers/mcp.controller.ts
+function _ts_decorate5(decorators, target, key, desc) {
+  var c = arguments.length, r2 = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d2;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r2 = Reflect.decorate(decorators, target, key, desc);
+  else for (var i2 = decorators.length - 1; i2 >= 0; i2--) if (d2 = decorators[i2]) r2 = (c < 3 ? d2(r2) : c > 3 ? d2(target, key, r2) : d2(target, key)) || r2;
+  return c > 3 && r2 && Object.defineProperty(target, key, r2), r2;
+}
+__name(_ts_decorate5, "_ts_decorate");
+function _ts_metadata5(k2, v2) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k2, v2);
+}
+__name(_ts_metadata5, "_ts_metadata");
+function _ts_param5(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param5, "_ts_param");
+var McpController = class _McpController {
+  static {
+    __name(this, "McpController");
+  }
+  serverService;
+  logger = new import_common8.Logger(_McpController.name);
+  constructor(serverService) {
+    this.serverService = serverService;
+  }
+  async handlePost(req, res) {
+    try {
+      await this.serverService.handle(req, res);
+    } catch (error) {
+      this.logger.error(`\u5904\u7406 MCP \u8BF7\u6C42\u5931\u8D25\uFF1A${error instanceof Error ? error.stack ?? error.message : String(error)}`);
+      if (!res.headersSent) {
+        res.status(500).json({
+          jsonrpc: "2.0",
+          error: {
+            code: -32603,
+            message: "Internal server error"
+          },
+          id: null
+        });
+      }
+    }
+  }
+  /** GET / DELETE 等其他方法：无状态模式不提供 SSE 会话，统一 405 */
+  handleOthers(res) {
+    this.methodNotAllowed(res);
+  }
+  methodNotAllowed(res) {
+    res.setHeader("Allow", "POST");
+    res.status(405).json({
+      jsonrpc: "2.0",
+      error: {
+        code: -32e3,
+        message: "Method not allowed. \u4EC5\u652F\u6301 POST\uFF08\u65E0\u72B6\u6001 Streamable HTTP\uFF09"
+      },
+      id: null
+    });
+  }
+};
+_ts_decorate5([
+  (0, import_common8.Post)(),
+  _ts_param5(0, (0, import_common8.Req)()),
+  _ts_param5(1, (0, import_common8.Res)()),
+  _ts_metadata5("design:type", Function),
+  _ts_metadata5("design:paramtypes", [
+    typeof Request === "undefined" ? Object : Request,
+    typeof Response === "undefined" ? Object : Response
+  ]),
+  _ts_metadata5("design:returntype", Promise)
+], McpController.prototype, "handlePost", null);
+_ts_decorate5([
+  (0, import_common8.All)(),
+  _ts_param5(0, (0, import_common8.Res)()),
+  _ts_metadata5("design:type", Function),
+  _ts_metadata5("design:paramtypes", [
+    typeof Response === "undefined" ? Object : Response
+  ]),
+  _ts_metadata5("design:returntype", void 0)
+], McpController.prototype, "handleOthers", null);
+McpController = _ts_decorate5([
+  (0, import_swagger2.ApiExcludeController)(),
+  (0, import_common8.Controller)(MCP_CONTROLLER_PATH),
+  _ts_param5(0, (0, import_common8.Inject)(McpServerService)),
+  _ts_metadata5("design:type", Function),
+  _ts_metadata5("design:paramtypes", [
+    typeof McpServerService === "undefined" ? Object : McpServerService
+  ])
+], McpController);
+
+// src/mcp.module.ts
+function _ts_decorate6(decorators, target, key, desc) {
+  var c = arguments.length, r2 = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d2;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r2 = Reflect.decorate(decorators, target, key, desc);
+  else for (var i2 = decorators.length - 1; i2 >= 0; i2--) if (d2 = decorators[i2]) r2 = (c < 3 ? d2(r2) : c > 3 ? d2(target, key, r2) : d2(target, key)) || r2;
+  return c > 3 && r2 && Object.defineProperty(target, key, r2), r2;
+}
+__name(_ts_decorate6, "_ts_decorate");
+var McpModule = class _McpModule {
+  static {
+    __name(this, "McpModule");
+  }
+  static forRoot(options = {}) {
+    const enabled = options.enabled !== false;
+    const providers = [
+      {
+        provide: MCP_MODULE_OPTIONS,
+        useValue: options
+      },
+      McpRegistryService,
+      McpServerService,
+      McpManifestService
+    ];
+    return {
+      module: _McpModule,
+      global: true,
+      imports: [
+        import_core2.DiscoveryModule
+      ],
+      controllers: enabled ? [
+        McpManifestController,
+        McpController
+      ] : [],
+      providers,
+      exports: [
+        McpRegistryService,
+        McpServerService,
+        McpManifestService
+      ]
+    };
+  }
+};
+McpModule = _ts_decorate6([
+  (0, import_common9.Module)({})
+], McpModule);
+
+// src/ui-template.ts
+var import_node_fs4 = require("fs");
+var import_node_path5 = __toESM(require("path"), 1);
+var cache = /* @__PURE__ */ new Map();
+async function readMcpUiTemplate(entry, cwd = process.cwd()) {
+  if (!/^[A-Za-z0-9_-]+$/.test(entry)) {
+    throw new Error(`MCP Apps \u754C\u9762\u5165\u53E3\u540D\u300C${entry}\u300D\u4E0D\u5408\u6CD5\uFF0C\u4EC5\u5141\u8BB8\u5B57\u6BCD\u3001\u6570\u5B57\u3001\u4E0B\u5212\u7EBF\u4E0E\u8FDE\u5B57\u7B26`);
+  }
+  const file = import_node_path5.default.join(cwd, MCP_UI_DIST_DIR, `${entry}.html`);
+  const useCache = process.env.NODE_ENV === "production";
+  if (useCache && cache.has(file)) {
+    return cache.get(file);
+  }
+  let html;
+  try {
+    html = await import_node_fs4.promises.readFile(file, "utf8");
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    throw new Error(`\u8BFB\u53D6 MCP Apps \u754C\u9762\u4EA7\u7269\u5931\u8D25\uFF1A${file}\u3002\u8BF7\u786E\u8BA4 client/mcp-ui/${entry}/index.html \u5B58\u5728\u4E14\u5DF2\u6267\u884C\u6784\u5EFA\u3002\u539F\u56E0\uFF1A${reason}`);
+  }
+  if (useCache) cache.set(file, html);
+  return html;
+}
+__name(readMcpUiTemplate, "readMcpUiTemplate");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MCP_CONTROLLER_PATH,
+  MCP_DEFAULT_SERVER_NAME,
+  MCP_DEFAULT_SERVER_VERSION,
+  MCP_ENDPOINT_PATH,
+  MCP_MANIFEST_PATH,
+  MCP_MANIFEST_VERSION,
+  MCP_MODULE_OPTIONS,
+  MCP_SKILL_PATH,
+  MCP_SKILL_URI,
+  MCP_TOOLS_METADATA_KEY,
+  MCP_TOOL_METADATA_KEY,
+  MCP_TOOL_NAME_PATTERN,
+  MCP_UI_DIST_DIR,
+  MCP_UI_RESOURCE_METADATA_KEY,
+  MCP_UI_RESOURCE_SCHEME,
+  McpModule,
+  McpTool,
+  McpToolError,
+  McpTools,
+  McpUiResource,
+  readMcpUiTemplate
+});
+//# sourceMappingURL=index.cjs.map