@leanmcp/core 0.1.0

package/dist/index.js

@@ -0,0 +1,1162 @@
+"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 index_exports = {};
+__export(index_exports, {
+  Auth: () => Auth,
+  Deprecated: () => Deprecated,
+  LogLevel: () => LogLevel,
+  Logger: () => Logger,
+  MCPServer: () => MCPServer,
+  MCPServerRuntime: () => MCPServerRuntime,
+  Optional: () => Optional,
+  Prompt: () => Prompt,
+  Render: () => Render,
+  Resource: () => Resource,
+  SchemaConstraint: () => SchemaConstraint,
+  Tool: () => Tool,
+  UI: () => UI,
+  UserEnvs: () => UserEnvs,
+  classToJsonSchema: () => classToJsonSchema,
+  classToJsonSchemaWithConstraints: () => classToJsonSchemaWithConstraints,
+  createHTTPServer: () => createHTTPServer,
+  defaultLogger: () => defaultLogger,
+  getDecoratedMethods: () => getDecoratedMethods,
+  getMethodMetadata: () => getMethodMetadata,
+  startMCPServer: () => startMCPServer,
+  validateNonEmpty: () => validateNonEmpty,
+  validatePath: () => validatePath,
+  validatePort: () => validatePort,
+  validateServiceName: () => validateServiceName,
+  validateUrl: () => validateUrl
+});
+module.exports = __toCommonJS(index_exports);
+var import_reflect_metadata3 = require("reflect-metadata");
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+var import_url = require("url");
+var import_server = require("@modelcontextprotocol/sdk/server/index.js");
+var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
+var import_types = require("@modelcontextprotocol/sdk/types.js");
+var import_ajv = __toESM(require("ajv"));
+
+// src/decorators.ts
+var import_reflect_metadata = require("reflect-metadata");
+function Tool(options = {}) {
+  return (target, propertyKey, descriptor) => {
+    const toolName = String(propertyKey);
+    Reflect.defineMetadata("tool:name", toolName, descriptor.value);
+    Reflect.defineMetadata("tool:description", options.description || "", descriptor.value);
+    Reflect.defineMetadata("tool:propertyKey", propertyKey, descriptor.value);
+    if (options.inputClass) {
+      Reflect.defineMetadata("tool:inputClass", options.inputClass, descriptor.value);
+    }
+  };
+}
+__name(Tool, "Tool");
+function Prompt(options = {}) {
+  return (target, propertyKey, descriptor) => {
+    const promptName = String(propertyKey);
+    Reflect.defineMetadata("prompt:name", promptName, descriptor.value);
+    Reflect.defineMetadata("prompt:description", options.description || "", descriptor.value);
+    Reflect.defineMetadata("prompt:propertyKey", propertyKey, descriptor.value);
+    if (options.inputClass) {
+      Reflect.defineMetadata("prompt:inputClass", options.inputClass, descriptor.value);
+    } else {
+      const paramTypes = Reflect.getMetadata("design:paramtypes", target, propertyKey);
+      if (paramTypes && paramTypes.length > 0 && paramTypes[0] !== Object) {
+        Reflect.defineMetadata("prompt:inputClass", paramTypes[0], descriptor.value);
+      }
+    }
+  };
+}
+__name(Prompt, "Prompt");
+function Resource(options = {}) {
+  return (target, propertyKey, descriptor) => {
+    const resourceName = String(propertyKey);
+    const className = target.constructor.name.toLowerCase().replace("service", "");
+    const resourceUri = `${className}://${resourceName}`;
+    Reflect.defineMetadata("resource:uri", resourceUri, descriptor.value);
+    Reflect.defineMetadata("resource:name", resourceName, descriptor.value);
+    Reflect.defineMetadata("resource:description", options.description || "", descriptor.value);
+    Reflect.defineMetadata("resource:mimeType", options.mimeType || "application/json", descriptor.value);
+    Reflect.defineMetadata("resource:propertyKey", propertyKey, descriptor.value);
+    if (options.inputClass) {
+      Reflect.defineMetadata("resource:inputClass", options.inputClass, descriptor.value);
+    }
+  };
+}
+__name(Resource, "Resource");
+function Auth(options) {
+  return (target, propertyKey, descriptor) => {
+    if (propertyKey && descriptor) {
+      Reflect.defineMetadata("auth:provider", options.provider, descriptor.value);
+      Reflect.defineMetadata("auth:required", true, descriptor.value);
+    } else {
+      Reflect.defineMetadata("auth:provider", options.provider, target);
+      Reflect.defineMetadata("auth:required", true, target);
+    }
+  };
+}
+__name(Auth, "Auth");
+function UserEnvs() {
+  return (target, propertyKey) => {
+    const constructor = target.constructor;
+    Reflect.defineMetadata("userenvs:propertyKey", propertyKey, constructor);
+  };
+}
+__name(UserEnvs, "UserEnvs");
+function UI(component) {
+  return (target, propertyKey, descriptor) => {
+    if (propertyKey && descriptor) {
+      Reflect.defineMetadata("ui:component", component, descriptor.value);
+    } else {
+      Reflect.defineMetadata("ui:component", component, target);
+    }
+  };
+}
+__name(UI, "UI");
+function Render(format) {
+  return (target, propertyKey, descriptor) => {
+    Reflect.defineMetadata("render:format", format, descriptor.value);
+  };
+}
+__name(Render, "Render");
+function Deprecated(message) {
+  return (target, propertyKey, descriptor) => {
+    const deprecationMessage = message || "This feature is deprecated";
+    if (propertyKey && descriptor) {
+      Reflect.defineMetadata("deprecated:message", deprecationMessage, descriptor.value);
+      Reflect.defineMetadata("deprecated:true", true, descriptor.value);
+      const originalMethod = descriptor.value;
+      descriptor.value = function(...args) {
+        console.warn(`DEPRECATED: ${String(propertyKey)} - ${deprecationMessage}`);
+        return originalMethod.apply(this, args);
+      };
+    } else {
+      Reflect.defineMetadata("deprecated:message", deprecationMessage, target);
+      Reflect.defineMetadata("deprecated:true", true, target);
+      console.warn(`DEPRECATED: ${target.name} - ${deprecationMessage}`);
+    }
+  };
+}
+__name(Deprecated, "Deprecated");
+function getMethodMetadata(method) {
+  return {
+    // Tool metadata
+    toolName: Reflect.getMetadata("tool:name", method),
+    toolDescription: Reflect.getMetadata("tool:description", method),
+    // Prompt metadata
+    promptName: Reflect.getMetadata("prompt:name", method),
+    promptDescription: Reflect.getMetadata("prompt:description", method),
+    // Resource metadata
+    resourceUri: Reflect.getMetadata("resource:uri", method),
+    resourceName: Reflect.getMetadata("resource:name", method),
+    resourceDescription: Reflect.getMetadata("resource:description", method),
+    // Common metadata
+    inputSchema: Reflect.getMetadata("schema:input", method),
+    outputSchema: Reflect.getMetadata("schema:output", method),
+    authProvider: Reflect.getMetadata("auth:provider", method),
+    authRequired: Reflect.getMetadata("auth:required", method),
+    uiComponent: Reflect.getMetadata("ui:component", method),
+    renderFormat: Reflect.getMetadata("render:format", method),
+    deprecated: Reflect.getMetadata("deprecated:true", method),
+    deprecationMessage: Reflect.getMetadata("deprecated:message", method)
+  };
+}
+__name(getMethodMetadata, "getMethodMetadata");
+function getDecoratedMethods(target, metadataKey) {
+  const methods = [];
+  const prototype = target.prototype || target;
+  for (const propertyKey of Object.getOwnPropertyNames(prototype)) {
+    const descriptor = Object.getOwnPropertyDescriptor(prototype, propertyKey);
+    if (descriptor && typeof descriptor.value === "function") {
+      const metadata = Reflect.getMetadata(metadataKey, descriptor.value);
+      if (metadata !== void 0) {
+        methods.push({
+          method: descriptor.value,
+          propertyKey,
+          metadata
+        });
+      }
+    }
+  }
+  return methods;
+}
+__name(getDecoratedMethods, "getDecoratedMethods");
+
+// src/schema-generator.ts
+var import_reflect_metadata2 = require("reflect-metadata");
+function classToJsonSchema(classConstructor) {
+  const instance = new classConstructor();
+  const properties = {};
+  const required = [];
+  const propertyNames = Object.keys(instance);
+  for (const propertyName of propertyNames) {
+    const propertyType = Reflect.getMetadata("design:type", instance, propertyName);
+    let jsonSchemaType = "any";
+    if (propertyType) {
+      switch (propertyType.name) {
+        case "String":
+          jsonSchemaType = "string";
+          break;
+        case "Number":
+          jsonSchemaType = "number";
+          break;
+        case "Boolean":
+          jsonSchemaType = "boolean";
+          break;
+        case "Array":
+          jsonSchemaType = "array";
+          break;
+        case "Object":
+          jsonSchemaType = "object";
+          break;
+        default:
+          jsonSchemaType = "object";
+      }
+    }
+    properties[propertyName] = {
+      type: jsonSchemaType
+    };
+    const descriptor = Object.getOwnPropertyDescriptor(instance, propertyName);
+    if (descriptor && descriptor.value === void 0) {
+      const isOptional = propertyName.endsWith("?") || Reflect.getMetadata("optional", instance, propertyName);
+      if (!isOptional) {
+        required.push(propertyName);
+      }
+    }
+  }
+  return {
+    type: "object",
+    properties,
+    required: required.length > 0 ? required : void 0
+  };
+}
+__name(classToJsonSchema, "classToJsonSchema");
+function Optional() {
+  return (target, propertyKey) => {
+    Reflect.defineMetadata("optional", true, target, propertyKey);
+  };
+}
+__name(Optional, "Optional");
+function SchemaConstraint(constraints) {
+  return (target, propertyKey) => {
+    Reflect.defineMetadata("schema:constraints", constraints, target, propertyKey);
+  };
+}
+__name(SchemaConstraint, "SchemaConstraint");
+function classToJsonSchemaWithConstraints(classConstructor) {
+  const instance = new classConstructor();
+  const properties = {};
+  const required = [];
+  const propertyNames = Object.keys(instance);
+  for (const propertyName of propertyNames) {
+    const propertyType = Reflect.getMetadata("design:type", instance, propertyName);
+    const constraints = Reflect.getMetadata("schema:constraints", instance, propertyName);
+    const isOptional = Reflect.getMetadata("optional", instance, propertyName);
+    let jsonSchemaType = "string";
+    if (propertyType) {
+      switch (propertyType.name) {
+        case "String":
+          jsonSchemaType = "string";
+          break;
+        case "Number":
+          jsonSchemaType = "number";
+          break;
+        case "Boolean":
+          jsonSchemaType = "boolean";
+          break;
+        case "Array":
+          jsonSchemaType = "array";
+          break;
+        case "Object":
+          jsonSchemaType = "object";
+          break;
+        default:
+          jsonSchemaType = "object";
+      }
+    } else if (constraints) {
+      if (constraints.minLength !== void 0 || constraints.maxLength !== void 0 || constraints.pattern) {
+        jsonSchemaType = "string";
+      } else if (constraints.minimum !== void 0 || constraints.maximum !== void 0) {
+        jsonSchemaType = "number";
+      } else if (constraints.enum && constraints.enum.length > 0) {
+        const firstValue = constraints.enum[0];
+        if (typeof firstValue === "number") {
+          jsonSchemaType = "number";
+        } else if (typeof firstValue === "boolean") {
+          jsonSchemaType = "boolean";
+        } else {
+          jsonSchemaType = "string";
+        }
+      }
+    }
+    properties[propertyName] = {
+      type: jsonSchemaType,
+      ...constraints || {}
+    };
+    if (!isOptional) {
+      required.push(propertyName);
+    }
+  }
+  return {
+    type: "object",
+    properties,
+    required: required.length > 0 ? required : void 0
+  };
+}
+__name(classToJsonSchemaWithConstraints, "classToJsonSchemaWithConstraints");
+
+// src/http-server.ts
+var import_node_crypto = require("crypto");
+
+// src/logger.ts
+var LogLevel = /* @__PURE__ */ (function(LogLevel2) {
+  LogLevel2[LogLevel2["DEBUG"] = 0] = "DEBUG";
+  LogLevel2[LogLevel2["INFO"] = 1] = "INFO";
+  LogLevel2[LogLevel2["WARN"] = 2] = "WARN";
+  LogLevel2[LogLevel2["ERROR"] = 3] = "ERROR";
+  LogLevel2[LogLevel2["NONE"] = 4] = "NONE";
+  return LogLevel2;
+})({});
+var Logger = class {
+  static {
+    __name(this, "Logger");
+  }
+  level;
+  prefix;
+  timestamps;
+  constructor(options = {}) {
+    this.level = options.level ?? 1;
+    this.prefix = options.prefix ?? "";
+    this.timestamps = options.timestamps ?? true;
+  }
+  format(level, message, ...args) {
+    const timestamp = this.timestamps ? `[${(/* @__PURE__ */ new Date()).toISOString()}]` : "";
+    const prefix = this.prefix ? `[${this.prefix}]` : "";
+    return `${timestamp}${prefix}[${level}] ${message}`;
+  }
+  shouldLog(level) {
+    return level >= this.level;
+  }
+  debug(message, ...args) {
+    if (this.shouldLog(0)) {
+      console.debug(this.format("DEBUG", message), ...args);
+    }
+  }
+  info(message, ...args) {
+    if (this.shouldLog(1)) {
+      console.info(this.format("INFO", message), ...args);
+    }
+  }
+  warn(message, ...args) {
+    if (this.shouldLog(2)) {
+      console.warn(this.format("WARN", message), ...args);
+    }
+  }
+  error(message, ...args) {
+    if (this.shouldLog(3)) {
+      console.error(this.format("ERROR", message), ...args);
+    }
+  }
+  setLevel(level) {
+    this.level = level;
+  }
+  getLevel() {
+    return this.level;
+  }
+};
+var defaultLogger = new Logger({
+  level: 1,
+  prefix: "LeanMCP"
+});
+
+// src/validation.ts
+function validatePort(port) {
+  if (!Number.isInteger(port) || port < 1 || port > 65535) {
+    throw new Error(`Invalid port: ${port}. Must be an integer between 1-65535`);
+  }
+}
+__name(validatePort, "validatePort");
+function validatePath(path2) {
+  if (path2.includes("..") || path2.includes("~")) {
+    throw new Error(`Invalid path: ${path2}. Path traversal patterns are not allowed`);
+  }
+}
+__name(validatePath, "validatePath");
+function validateServiceName(name) {
+  const validNamePattern = /^[a-zA-Z0-9_-]+$/;
+  if (!validNamePattern.test(name)) {
+    throw new Error(`Invalid service name: ${name}. Service names must contain only alphanumeric characters, hyphens, and underscores`);
+  }
+}
+__name(validateServiceName, "validateServiceName");
+function validateNonEmpty(value, fieldName) {
+  if (!value || value.trim().length === 0) {
+    throw new Error(`${fieldName} cannot be empty`);
+  }
+}
+__name(validateNonEmpty, "validateNonEmpty");
+function validateUrl(url, allowedProtocols = [
+  "http:",
+  "https:"
+]) {
+  try {
+    const parsed = new URL(url);
+    if (!allowedProtocols.includes(parsed.protocol)) {
+      throw new Error(`Invalid URL protocol: ${parsed.protocol}. Allowed protocols: ${allowedProtocols.join(", ")}`);
+    }
+  } catch (error) {
+    if (error instanceof TypeError) {
+      throw new Error(`Invalid URL: ${url}`);
+    }
+    throw error;
+  }
+}
+__name(validateUrl, "validateUrl");
+
+// src/http-server.ts
+function isInitializeRequest(body) {
+  return body && body.method === "initialize";
+}
+__name(isInitializeRequest, "isInitializeRequest");
+async function createHTTPServer(serverFactory, options = {}) {
+  const [express, { StreamableHTTPServerTransport }, cors] = await Promise.all([
+    // @ts-ignore
+    import("express").catch(() => {
+      throw new Error("Express not found. Install with: npm install express @types/express");
+    }),
+    // @ts-ignore
+    import("@modelcontextprotocol/sdk/server/streamableHttp.js").catch(() => {
+      throw new Error("MCP SDK not found. Install with: npm install @modelcontextprotocol/sdk");
+    }),
+    // @ts-ignore
+    options.cors ? import("cors").catch(() => null) : Promise.resolve(null)
+  ]);
+  const app = express.default();
+  const port = options.port || 3001;
+  validatePort(port);
+  const transports = {};
+  const logger = options.logger || new Logger({
+    level: options.logging ? LogLevel.INFO : LogLevel.NONE,
+    prefix: "HTTP"
+  });
+  if (cors && options.cors) {
+    const corsOptions = typeof options.cors === "object" ? {
+      origin: options.cors.origin || false,
+      methods: [
+        "GET",
+        "POST",
+        "DELETE",
+        "OPTIONS"
+      ],
+      allowedHeaders: [
+        "Content-Type",
+        "mcp-session-id",
+        "mcp-protocol-version",
+        "Authorization"
+      ],
+      exposedHeaders: [
+        "mcp-session-id"
+      ],
+      credentials: options.cors.credentials ?? false,
+      maxAge: 86400
+    } : false;
+    if (corsOptions) {
+      app.use(cors.default(corsOptions));
+    }
+  }
+  app.use(express.json());
+  logger.info("Starting LeanMCP HTTP Server...");
+  app.get("/health", (req, res) => {
+    res.json({
+      status: "ok",
+      activeSessions: Object.keys(transports).length,
+      uptime: process.uptime()
+    });
+  });
+  const handleMCPRequest = /* @__PURE__ */ __name(async (req, res) => {
+    const sessionId = req.headers["mcp-session-id"];
+    let transport;
+    try {
+      if (sessionId && transports[sessionId]) {
+        transport = transports[sessionId];
+        logger.debug(`Reusing session: ${sessionId}`);
+      } else if (!sessionId && isInitializeRequest(req.body)) {
+        logger.info("Creating new MCP session...");
+        transport = new StreamableHTTPServerTransport({
+          sessionIdGenerator: /* @__PURE__ */ __name(() => (0, import_node_crypto.randomUUID)(), "sessionIdGenerator"),
+          onsessioninitialized: /* @__PURE__ */ __name((newSessionId) => {
+            transports[newSessionId] = transport;
+            logger.info(`Session initialized: ${newSessionId}`);
+          }, "onsessioninitialized")
+        });
+        transport.onclose = () => {
+          if (transport.sessionId) {
+            delete transports[transport.sessionId];
+            logger.debug(`Session cleaned up: ${transport.sessionId}`);
+          }
+        };
+        const server = await serverFactory();
+        await server.connect(transport);
+      } else {
+        res.status(400).json({
+          jsonrpc: "2.0",
+          error: {
+            code: -32e3,
+            message: "Bad Request: Invalid session or not an init request"
+          },
+          id: null
+        });
+        return;
+      }
+      await transport.handleRequest(req, res, req.body);
+    } catch (error) {
+      logger.error("Error handling MCP request:", error);
+      if (!res.headersSent) {
+        res.status(500).json({
+          jsonrpc: "2.0",
+          error: {
+            code: -32603,
+            message: "Internal server error"
+          },
+          id: null
+        });
+      }
+    }
+  }, "handleMCPRequest");
+  app.post("/mcp", handleMCPRequest);
+  app.delete("/mcp", handleMCPRequest);
+  process.on("SIGINT", () => {
+    logger.info("\nShutting down server...");
+    Object.values(transports).forEach((t) => t.close?.());
+    process.exit(0);
+  });
+  return new Promise((resolve) => {
+    app.listen(port, () => {
+      logger.info(`Server running on http://localhost:${port}`);
+      logger.info(`MCP endpoint: http://localhost:${port}/mcp`);
+      logger.info(`Health check: http://localhost:${port}/health`);
+      resolve();
+    });
+  });
+}
+__name(createHTTPServer, "createHTTPServer");
+
+// src/index.ts
+var ajv = new import_ajv.default();
+var MCPServer = class {
+  static {
+    __name(this, "MCPServer");
+  }
+  server;
+  tools = /* @__PURE__ */ new Map();
+  prompts = /* @__PURE__ */ new Map();
+  resources = /* @__PURE__ */ new Map();
+  logging;
+  logger;
+  constructor(options) {
+    this.logging = options.logging || false;
+    this.logger = new Logger({
+      level: this.logging ? LogLevel.INFO : LogLevel.NONE,
+      prefix: "MCPServer"
+    });
+    this.server = new import_server.Server({
+      name: options.name,
+      version: options.version
+    }, {
+      capabilities: {
+        tools: {},
+        resources: {},
+        prompts: {}
+      }
+    });
+    this.setupHandlers();
+  }
+  setupHandlers() {
+    this.server.setRequestHandler(import_types.ListToolsRequestSchema, async () => {
+      const tools = [];
+      for (const [name, tool] of this.tools.entries()) {
+        tools.push({
+          name,
+          description: tool.description,
+          inputSchema: tool.inputSchema || {
+            type: "object",
+            properties: {}
+          }
+        });
+      }
+      return {
+        tools
+      };
+    });
+    this.server.setRequestHandler(import_types.CallToolRequestSchema, async (request) => {
+      const toolName = request.params.name;
+      const tool = this.tools.get(toolName);
+      if (!tool) {
+        throw new Error(`Tool ${toolName} not found`);
+      }
+      const methodMeta = getMethodMetadata(tool.method);
+      if (methodMeta.inputSchema) {
+        const validate = ajv.compile(methodMeta.inputSchema);
+        const valid = validate(request.params.arguments || {});
+        if (!valid) {
+          throw new Error(`Input validation failed: ${JSON.stringify(validate.errors)}`);
+        }
+      }
+      try {
+        const result = await tool.method.call(tool.instance, request.params.arguments);
+        let formattedResult = result;
+        if (methodMeta.renderFormat === "markdown" && typeof result === "string") {
+          formattedResult = result;
+        } else if (methodMeta.renderFormat === "json" || typeof result === "object") {
+          formattedResult = JSON.stringify(result, null, 2);
+        } else {
+          formattedResult = String(result);
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: formattedResult
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: ${error.message}`
+            }
+          ],
+          isError: true
+        };
+      }
+    });
+    this.server.setRequestHandler(import_types.ListResourcesRequestSchema, async () => {
+      const resources = [];
+      for (const [uri, resource] of this.resources.entries()) {
+        const resourceInfo = {
+          uri: resource.uri,
+          name: resource.name,
+          description: resource.description,
+          mimeType: resource.mimeType
+        };
+        if (resource.inputSchema) {
+          resourceInfo.inputSchema = resource.inputSchema;
+        }
+        resources.push(resourceInfo);
+      }
+      return {
+        resources
+      };
+    });
+    this.server.setRequestHandler(import_types.ReadResourceRequestSchema, async (request) => {
+      const uri = request.params.uri;
+      const resource = this.resources.get(uri);
+      if (!resource) {
+        throw new Error(`Resource ${uri} not found`);
+      }
+      try {
+        const result = await resource.method.call(resource.instance);
+        return {
+          contents: [
+            {
+              uri,
+              mimeType: resource.mimeType,
+              text: typeof result === "string" ? result : JSON.stringify(result, null, 2)
+            }
+          ]
+        };
+      } catch (error) {
+        throw new Error(`Failed to read resource ${uri}: ${error.message}`);
+      }
+    });
+    this.server.setRequestHandler(import_types.ListPromptsRequestSchema, async () => {
+      const prompts = [];
+      for (const [name, prompt] of this.prompts.entries()) {
+        prompts.push({
+          name,
+          description: prompt.description,
+          arguments: prompt.arguments
+        });
+      }
+      return {
+        prompts
+      };
+    });
+    this.server.setRequestHandler(import_types.GetPromptRequestSchema, async (request) => {
+      const promptName = request.params.name;
+      const prompt = this.prompts.get(promptName);
+      if (!prompt) {
+        throw new Error(`Prompt ${promptName} not found`);
+      }
+      try {
+        const result = await prompt.method.call(prompt.instance, request.params.arguments || {});
+        if (result && result.messages) {
+          return result;
+        }
+        return {
+          description: prompt.description,
+          messages: [
+            {
+              role: "user",
+              content: {
+                type: "text",
+                text: typeof result === "string" ? result : JSON.stringify(result)
+              }
+            }
+          ]
+        };
+      } catch (error) {
+        throw new Error(`Failed to get prompt ${promptName}: ${error.message}`);
+      }
+    });
+  }
+  /**
+  * Register a service instance with decorated methods
+  */
+  registerService(instance) {
+    const cls = instance.constructor;
+    const toolMethods = getDecoratedMethods(cls, "tool:name");
+    for (const { method, propertyKey } of toolMethods) {
+      const methodMeta = getMethodMetadata(method);
+      const inputClass = Reflect.getMetadata?.("tool:inputClass", method);
+      let inputSchema = methodMeta.inputSchema;
+      if (inputClass) {
+        inputSchema = classToJsonSchemaWithConstraints(inputClass);
+      }
+      this.tools.set(methodMeta.toolName, {
+        name: methodMeta.toolName,
+        description: methodMeta.toolDescription || "",
+        inputSchema,
+        method,
+        instance,
+        propertyKey
+      });
+      if (this.logging) {
+        this.logger.info(`Registered tool: ${methodMeta.toolName}${inputClass ? " (class-based schema)" : ""}`);
+      }
+    }
+    const promptMethods = getDecoratedMethods(cls, "prompt:name");
+    for (const { method, propertyKey } of promptMethods) {
+      const methodMeta = getMethodMetadata(method);
+      const inputClass = Reflect.getMetadata?.("prompt:inputClass", method);
+      let inputSchema = methodMeta.inputSchema;
+      if (inputClass) {
+        inputSchema = classToJsonSchemaWithConstraints(inputClass);
+      }
+      const promptArgs = inputSchema?.properties ? Object.keys(inputSchema.properties).map((key) => ({
+        name: key,
+        description: inputSchema?.properties?.[key]?.description || "",
+        required: inputSchema?.required?.includes(key) || false
+      })) : [];
+      this.prompts.set(methodMeta.promptName, {
+        name: methodMeta.promptName,
+        description: methodMeta.promptDescription || "",
+        arguments: promptArgs,
+        method,
+        instance,
+        propertyKey
+      });
+      if (this.logging) {
+        this.logger.info(`Registered prompt: ${methodMeta.promptName}`);
+      }
+    }
+    const resourceMethods = getDecoratedMethods(cls, "resource:uri");
+    for (const { method, propertyKey } of resourceMethods) {
+      const methodMeta = getMethodMetadata(method);
+      const inputClass = Reflect.getMetadata?.("resource:inputClass", method);
+      let inputSchema = methodMeta.inputSchema;
+      if (inputClass) {
+        inputSchema = classToJsonSchemaWithConstraints(inputClass);
+      }
+      const mimeType = Reflect.getMetadata?.("resource:mimeType", method) || "application/json";
+      this.resources.set(methodMeta.resourceUri, {
+        uri: methodMeta.resourceUri,
+        name: methodMeta.resourceName || methodMeta.resourceUri,
+        description: methodMeta.resourceDescription || "",
+        mimeType,
+        inputSchema,
+        method,
+        instance,
+        propertyKey
+      });
+      if (this.logging) {
+        this.logger.info(`Registered resource: ${methodMeta.resourceUri}`);
+      }
+    }
+  }
+  /**
+  * Get the underlying MCP SDK Server instance
+  */
+  getServer() {
+    return this.server;
+  }
+};
+var MCPServerRuntime = class {
+  static {
+    __name(this, "MCPServerRuntime");
+  }
+  server;
+  tools = /* @__PURE__ */ new Map();
+  prompts = /* @__PURE__ */ new Map();
+  resources = /* @__PURE__ */ new Map();
+  options;
+  logger;
+  constructor(options) {
+    this.options = options;
+    this.logger = new Logger({
+      level: this.options.logging ? LogLevel.INFO : LogLevel.NONE,
+      prefix: "MCPServerRuntime"
+    });
+    this.server = new import_server.Server({
+      name: "leanmcp-server",
+      version: "0.1.0"
+    }, {
+      capabilities: {
+        tools: {},
+        resources: {},
+        prompts: {}
+      }
+    });
+    this.setupHandlers();
+  }
+  setupHandlers() {
+    this.server.setRequestHandler(import_types.ListToolsRequestSchema, async () => {
+      const tools = [];
+      for (const [name, tool] of this.tools.entries()) {
+        tools.push({
+          name,
+          description: tool.description,
+          inputSchema: tool.inputSchema || {
+            type: "object",
+            properties: {}
+          }
+        });
+      }
+      return {
+        tools
+      };
+    });
+    this.server.setRequestHandler(import_types.CallToolRequestSchema, async (request) => {
+      const toolName = request.params.name;
+      const tool = this.tools.get(toolName);
+      if (!tool) {
+        throw new Error(`Tool ${toolName} not found`);
+      }
+      const methodMeta = getMethodMetadata(tool.method);
+      if (methodMeta.inputSchema) {
+        const validate = ajv.compile(methodMeta.inputSchema);
+        const valid = validate(request.params.arguments || {});
+        if (!valid) {
+          throw new Error(`Input validation failed: ${JSON.stringify(validate.errors)}`);
+        }
+      }
+      if (methodMeta.authRequired) {
+        if (this.options.logging) {
+          this.logger.info(`Auth required for ${toolName} (provider: ${methodMeta.authProvider})`);
+        }
+      }
+      try {
+        const result = await tool.method.call(tool.instance, request.params.arguments);
+        if (result && typeof result === "object" && result.type === "elicitation") {
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify(result, null, 2)
+              }
+            ],
+            isError: false
+          };
+        }
+        let formattedResult = result;
+        if (methodMeta.renderFormat === "markdown" && typeof result === "string") {
+          formattedResult = result;
+        } else if (methodMeta.renderFormat === "json" || typeof result === "object") {
+          formattedResult = JSON.stringify(result, null, 2);
+        } else {
+          formattedResult = String(result);
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: formattedResult
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: ${error.message}`
+            }
+          ],
+          isError: true
+        };
+      }
+    });
+    this.server.setRequestHandler(import_types.ListResourcesRequestSchema, async () => {
+      const resources = [];
+      for (const [uri, resource] of this.resources.entries()) {
+        resources.push({
+          uri: resource.uri,
+          name: resource.name,
+          description: resource.description,
+          mimeType: resource.mimeType
+        });
+      }
+      return {
+        resources
+      };
+    });
+    this.server.setRequestHandler(import_types.ReadResourceRequestSchema, async (request) => {
+      const uri = request.params.uri;
+      const resource = this.resources.get(uri);
+      if (!resource) {
+        throw new Error(`Resource ${uri} not found`);
+      }
+      try {
+        const result = await resource.method.call(resource.instance);
+        return {
+          contents: [
+            {
+              uri,
+              mimeType: resource.mimeType,
+              text: typeof result === "string" ? result : JSON.stringify(result, null, 2)
+            }
+          ]
+        };
+      } catch (error) {
+        throw new Error(`Failed to read resource ${uri}: ${error.message}`);
+      }
+    });
+    this.server.setRequestHandler(import_types.ListPromptsRequestSchema, async () => {
+      const prompts = [];
+      for (const [name, prompt] of this.prompts.entries()) {
+        prompts.push({
+          name,
+          description: prompt.description,
+          arguments: prompt.arguments
+        });
+      }
+      return {
+        prompts
+      };
+    });
+    this.server.setRequestHandler(import_types.GetPromptRequestSchema, async (request) => {
+      const promptName = request.params.name;
+      const prompt = this.prompts.get(promptName);
+      if (!prompt) {
+        throw new Error(`Prompt ${promptName} not found`);
+      }
+      try {
+        const result = await prompt.method.call(prompt.instance, request.params.arguments || {});
+        if (result && result.messages) {
+          return result;
+        }
+        return {
+          description: prompt.description,
+          messages: [
+            {
+              role: "user",
+              content: {
+                type: "text",
+                text: typeof result === "string" ? result : JSON.stringify(result)
+              }
+            }
+          ]
+        };
+      } catch (error) {
+        throw new Error(`Failed to get prompt ${promptName}: ${error.message}`);
+      }
+    });
+  }
+  async loadServices() {
+    const absPath = import_path.default.resolve(this.options.servicesDir);
+    if (!import_fs.default.existsSync(absPath)) {
+      this.logger.error(`Services directory not found: ${absPath}`);
+      return;
+    }
+    const files = import_fs.default.readdirSync(absPath);
+    let toolCount = 0;
+    let promptCount = 0;
+    let resourceCount = 0;
+    for (const dir of files) {
+      const modulePath = import_path.default.join(absPath, dir, "index.ts");
+      const modulePathJs = import_path.default.join(absPath, dir, "index.js");
+      const finalPath = import_fs.default.existsSync(modulePath) ? modulePath : import_fs.default.existsSync(modulePathJs) ? modulePathJs : null;
+      if (finalPath) {
+        try {
+          const fileUrl = (0, import_url.pathToFileURL)(finalPath).href;
+          const mod = await import(fileUrl);
+          const exportedClasses = Object.values(mod).filter((val) => typeof val === "function" && val.prototype);
+          for (const cls of exportedClasses) {
+            const instance = new cls();
+            const envsPropKey = Reflect.getMetadata?.("userenvs:propertyKey", cls);
+            if (envsPropKey) {
+              instance[envsPropKey] = process.env;
+            }
+            const toolMethods = getDecoratedMethods(cls, "tool:name");
+            for (const { method, propertyKey, metadata } of toolMethods) {
+              const methodMeta = getMethodMetadata(method);
+              const inputClass = Reflect.getMetadata?.("tool:inputClass", method);
+              const outputClass = Reflect.getMetadata?.("tool:outputClass", method);
+              let inputSchema = methodMeta.inputSchema;
+              if (inputClass) {
+                inputSchema = classToJsonSchemaWithConstraints(inputClass);
+              }
+              this.tools.set(methodMeta.toolName, {
+                name: methodMeta.toolName,
+                description: methodMeta.toolDescription || "",
+                inputSchema,
+                method,
+                instance,
+                propertyKey
+              });
+              toolCount++;
+              if (this.options.logging) {
+                this.logger.info(`Loaded tool: ${methodMeta.toolName}${inputClass ? " (class-based schema)" : ""}`);
+              }
+            }
+            const promptMethods = getDecoratedMethods(cls, "prompt:name");
+            for (const { method, propertyKey, metadata } of promptMethods) {
+              const methodMeta = getMethodMetadata(method);
+              const promptArgs = methodMeta.inputSchema?.properties ? Object.keys(methodMeta.inputSchema.properties).map((key) => ({
+                name: key,
+                description: methodMeta.inputSchema?.properties?.[key]?.description || "",
+                required: methodMeta.inputSchema?.required?.includes(key) || false
+              })) : [];
+              this.prompts.set(methodMeta.promptName, {
+                name: methodMeta.promptName,
+                description: methodMeta.promptDescription || "",
+                arguments: promptArgs,
+                method,
+                instance,
+                propertyKey
+              });
+              promptCount++;
+              if (this.options.logging) {
+                this.logger.info(`Loaded prompt: ${methodMeta.promptName}`);
+              }
+            }
+            const resourceMethods = getDecoratedMethods(cls, "resource:uri");
+            for (const { method, propertyKey, metadata } of resourceMethods) {
+              const methodMeta = getMethodMetadata(method);
+              this.resources.set(methodMeta.resourceUri, {
+                uri: methodMeta.resourceUri,
+                name: methodMeta.resourceName || methodMeta.resourceUri,
+                description: methodMeta.resourceDescription || "",
+                mimeType: "application/json",
+                method,
+                instance,
+                propertyKey
+              });
+              resourceCount++;
+              if (this.options.logging) {
+                this.logger.info(`Loaded resource: ${methodMeta.resourceUri}`);
+              }
+            }
+          }
+        } catch (error) {
+          this.logger.error(`Failed to load from ${dir}:`, error.message || error);
+          if (this.options.logging) {
+            this.logger.error("Full error:", error);
+          }
+        }
+      }
+    }
+    if (this.options.logging) {
+      this.logger.info(`
+Loaded ${toolCount} tools, ${promptCount} prompts, ${resourceCount} resources`);
+    }
+  }
+  async start() {
+    await this.loadServices();
+    const transport = new import_stdio.StdioServerTransport();
+    await this.server.connect(transport);
+    if (this.options.logging) {
+      this.logger.info("LeanMCP server running on stdio");
+    }
+  }
+  getServer() {
+    return this.server;
+  }
+  getTools() {
+    return Array.from(this.tools.values());
+  }
+  getPrompts() {
+    return Array.from(this.prompts.values());
+  }
+  getResources() {
+    return Array.from(this.resources.values());
+  }
+};
+async function startMCPServer(options) {
+  const runtime = new MCPServerRuntime(options);
+  await runtime.start();
+  return runtime;
+}
+__name(startMCPServer, "startMCPServer");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Auth,
+  Deprecated,
+  LogLevel,
+  Logger,
+  MCPServer,
+  MCPServerRuntime,
+  Optional,
+  Prompt,
+  Render,
+  Resource,
+  SchemaConstraint,
+  Tool,
+  UI,
+  UserEnvs,
+  classToJsonSchema,
+  classToJsonSchemaWithConstraints,
+  createHTTPServer,
+  defaultLogger,
+  getDecoratedMethods,
+  getMethodMetadata,
+  startMCPServer,
+  validateNonEmpty,
+  validatePath,
+  validatePort,
+  validateServiceName,
+  validateUrl
+});