@leanmcp/core 0.1.2 → 0.3.0

package/dist/index.js

@@ -6,6 +6,9 @@ var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -28,48 +31,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 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);
@@ -81,7 +43,6 @@ function Tool(options = {}) {
     }
   };
 }
-__name(Tool, "Tool");
 function Prompt(options = {}) {
   return (target, propertyKey, descriptor) => {
     const promptName = String(propertyKey);
@@ -98,7 +59,6 @@ function Prompt(options = {}) {
     }
   };
 }
-__name(Prompt, "Prompt");
 function Resource(options = {}) {
   return (target, propertyKey, descriptor) => {
     const resourceName = String(propertyKey);
@@ -114,7 +74,6 @@ function Resource(options = {}) {
     }
   };
 }
-__name(Resource, "Resource");
 function Auth(options) {
   return (target, propertyKey, descriptor) => {
     if (propertyKey && descriptor) {
@@ -126,14 +85,12 @@ function Auth(options) {
     }
   };
 }
-__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) {
@@ -143,13 +100,11 @@ function UI(component) {
     }
   };
 }
-__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";
@@ -168,7 +123,6 @@ function Deprecated(message) {
     }
   };
 }
-__name(Deprecated, "Deprecated");
 function getMethodMetadata(method) {
   return {
     // Tool metadata
@@ -192,7 +146,6 @@ function getMethodMetadata(method) {
     deprecationMessage: Reflect.getMetadata("deprecated:message", method)
   };
 }
-__name(getMethodMetadata, "getMethodMetadata");
 function getDecoratedMethods(target, metadataKey) {
   const methods = [];
   const prototype = target.prototype || target;
@@ -211,10 +164,25 @@ function getDecoratedMethods(target, metadataKey) {
   }
   return methods;
 }
-__name(getDecoratedMethods, "getDecoratedMethods");
+var import_reflect_metadata;
+var init_decorators = __esm({
+  "src/decorators.ts"() {
+    "use strict";
+    import_reflect_metadata = require("reflect-metadata");
+    __name(Tool, "Tool");
+    __name(Prompt, "Prompt");
+    __name(Resource, "Resource");
+    __name(Auth, "Auth");
+    __name(UserEnvs, "UserEnvs");
+    __name(UI, "UI");
+    __name(Render, "Render");
+    __name(Deprecated, "Deprecated");
+    __name(getMethodMetadata, "getMethodMetadata");
+    __name(getDecoratedMethods, "getDecoratedMethods");
+  }
+});
 
 // src/schema-generator.ts
-var import_reflect_metadata2 = require("reflect-metadata");
 function classToJsonSchema(classConstructor) {
   const instance = new classConstructor();
   const properties = {};
@@ -261,19 +229,16 @@ function classToJsonSchema(classConstructor) {
     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 = {};
@@ -334,70 +299,83 @@ function classToJsonSchemaWithConstraints(classConstructor) {
     required: required.length > 0 ? required : void 0
   };
 }
-__name(classToJsonSchemaWithConstraints, "classToJsonSchemaWithConstraints");
-
-// src/http-server.ts
-var import_node_crypto = require("crypto");
+var import_reflect_metadata2;
+var init_schema_generator = __esm({
+  "src/schema-generator.ts"() {
+    "use strict";
+    import_reflect_metadata2 = require("reflect-metadata");
+    __name(classToJsonSchema, "classToJsonSchema");
+    __name(Optional, "Optional");
+    __name(SchemaConstraint, "SchemaConstraint");
+    __name(classToJsonSchemaWithConstraints, "classToJsonSchemaWithConstraints");
+  }
+});
 
 // 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 LogLevel, Logger, defaultLogger;
+var init_logger = __esm({
+  "src/logger.ts"() {
+    "use strict";
+    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;
+    })({});
+    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;
+      }
+    };
+    defaultLogger = new Logger({
+      level: 1,
+      prefix: "LeanMCP"
+    });
   }
-};
-var defaultLogger = new Logger({
-  level: 1,
-  prefix: "LeanMCP"
 });
 
 // src/validation.ts
@@ -406,26 +384,22 @@ function validatePort(port) {
     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:"
@@ -442,14 +416,41 @@ function validateUrl(url, allowedProtocols = [
     throw error;
   }
 }
-__name(validateUrl, "validateUrl");
+var init_validation = __esm({
+  "src/validation.ts"() {
+    "use strict";
+    __name(validatePort, "validatePort");
+    __name(validatePath, "validatePath");
+    __name(validateServiceName, "validateServiceName");
+    __name(validateNonEmpty, "validateNonEmpty");
+    __name(validateUrl, "validateUrl");
+  }
+});
 
 // src/http-server.ts
 function isInitializeRequest(body) {
   return body && body.method === "initialize";
 }
-__name(isInitializeRequest, "isInitializeRequest");
-async function createHTTPServer(serverFactory, options = {}) {
+async function createHTTPServer(serverInput, options) {
+  let serverFactory;
+  let httpOptions;
+  if (typeof serverInput === "function") {
+    serverFactory = serverInput;
+    httpOptions = options || {};
+  } else {
+    const serverOptions = serverInput;
+    const { MCPServer: MCPServer2 } = await Promise.resolve().then(() => (init_index(), index_exports));
+    serverFactory = /* @__PURE__ */ __name(async () => {
+      const mcpServer2 = new MCPServer2(serverOptions);
+      return mcpServer2.getServer();
+    }, "serverFactory");
+    httpOptions = {
+      port: serverOptions.port,
+      cors: serverOptions.cors,
+      logging: serverOptions.logging,
+      sessionTimeout: serverOptions.sessionTimeout
+    };
+  }
   const [express, { StreamableHTTPServerTransport }, cors] = await Promise.all([
     // @ts-ignore
     import("express").catch(() => {
@@ -460,19 +461,20 @@ async function createHTTPServer(serverFactory, options = {}) {
       throw new Error("MCP SDK not found. Install with: npm install @modelcontextprotocol/sdk");
     }),
     // @ts-ignore
-    options.cors ? import("cors").catch(() => null) : Promise.resolve(null)
+    httpOptions.cors ? import("cors").catch(() => null) : Promise.resolve(null)
   ]);
   const app = express.default();
-  const port = options.port || 3001;
+  const port = httpOptions.port || 3001;
   validatePort(port);
   const transports = {};
-  const logger = options.logger || new Logger({
-    level: options.logging ? LogLevel.INFO : LogLevel.NONE,
+  let mcpServer = null;
+  const logger = httpOptions.logger || new Logger({
+    level: httpOptions.logging ? LogLevel.INFO : LogLevel.NONE,
     prefix: "HTTP"
   });
-  if (cors && options.cors) {
-    const corsOptions = typeof options.cors === "object" ? {
-      origin: options.cors.origin || false,
+  if (cors && httpOptions.cors) {
+    const corsOptions = typeof httpOptions.cors === "object" ? {
+      origin: httpOptions.cors.origin || false,
       methods: [
         "GET",
         "POST",
@@ -488,7 +490,7 @@ async function createHTTPServer(serverFactory, options = {}) {
       exposedHeaders: [
         "mcp-session-id"
       ],
-      credentials: options.cors.credentials ?? false,
+      credentials: httpOptions.cors.credentials ?? false,
       maxAge: 86400
     } : false;
     if (corsOptions) {
@@ -507,6 +509,18 @@ async function createHTTPServer(serverFactory, options = {}) {
   const handleMCPRequest = /* @__PURE__ */ __name(async (req, res) => {
     const sessionId = req.headers["mcp-session-id"];
     let transport;
+    const method = req.body?.method || "unknown";
+    const params = req.body?.params;
+    let logMessage = `${req.method} /mcp - ${method}`;
+    if (params?.name) {
+      logMessage += ` [${params.name}]`;
+    } else if (params?.uri) {
+      logMessage += ` [${params.uri}]`;
+    }
+    if (sessionId) {
+      logMessage += ` (session: ${sessionId.substring(0, 8)}...)`;
+    }
+    logger.info(logMessage);
     try {
       if (sessionId && transports[sessionId]) {
         transport = transports[sessionId];
@@ -526,8 +540,10 @@ async function createHTTPServer(serverFactory, options = {}) {
             logger.debug(`Session cleaned up: ${transport.sessionId}`);
           }
         };
-        const server = await serverFactory();
-        await server.connect(transport);
+        if (!mcpServer) {
+          throw new Error("MCP server not initialized");
+        }
+        await mcpServer.connect(transport);
       } else {
         res.status(400).json({
           jsonrpc: "2.0",
@@ -556,583 +572,833 @@ async function createHTTPServer(serverFactory, options = {}) {
   }, "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();
-    });
+  return new Promise(async (resolve, reject) => {
+    try {
+      mcpServer = await serverFactory();
+      if (mcpServer && typeof mcpServer.waitForInit === "function") {
+        await mcpServer.waitForInit();
+      }
+      const listener = 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(listener);
+      });
+      listener.on("error", (error) => {
+        logger.error(`Server error: ${error.message}`);
+        reject(error);
+      });
+      const cleanup = /* @__PURE__ */ __name(() => {
+        logger.info("\nShutting down server...");
+        Object.values(transports).forEach((t) => t.close?.());
+        listener.close(() => {
+          logger.info("Server closed");
+          process.exit(0);
+        });
+        setTimeout(() => {
+          logger.warn("Forcing shutdown...");
+          process.exit(1);
+        }, 5e3);
+      }, "cleanup");
+      process.on("SIGINT", cleanup);
+      process.on("SIGTERM", cleanup);
+    } catch (error) {
+      reject(error);
+    }
   });
 }
-__name(createHTTPServer, "createHTTPServer");
+var import_node_crypto;
+var init_http_server = __esm({
+  "src/http-server.ts"() {
+    "use strict";
+    import_node_crypto = require("crypto");
+    init_logger();
+    init_validation();
+    __name(isInitializeRequest, "isInitializeRequest");
+    __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: {}
+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);
+async function startMCPServer(options) {
+  const runtime = new MCPServerRuntime(options);
+  await runtime.start();
+  return runtime;
+}
+var import_reflect_metadata3, import_fs, import_path, import_url, import_server, import_stdio, import_types, import_ajv, ajv, MCPServer, MCPServerRuntime;
+var init_index = __esm({
+  "src/index.ts"() {
+    import_reflect_metadata3 = require("reflect-metadata");
+    import_fs = __toESM(require("fs"));
+    import_path = __toESM(require("path"));
+    import_url = require("url");
+    import_server = require("@modelcontextprotocol/sdk/server/index.js");
+    import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
+    import_types = require("@modelcontextprotocol/sdk/types.js");
+    import_ajv = __toESM(require("ajv"));
+    init_decorators();
+    init_schema_generator();
+    init_http_server();
+    init_logger();
+    init_validation();
+    init_decorators();
+    init_schema_generator();
+    init_logger();
+    ajv = new import_ajv.default();
+    MCPServer = class {
+      static {
+        __name(this, "MCPServer");
       }
-    });
-    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: {}
+      server;
+      tools = /* @__PURE__ */ new Map();
+      prompts = /* @__PURE__ */ new Map();
+      resources = /* @__PURE__ */ new Map();
+      logging;
+      logger;
+      options;
+      initPromise;
+      autoDiscovered = false;
+      constructor(options) {
+        this.options = options;
+        this.logging = options.logging || false;
+        let logLevel = LogLevel.NONE;
+        if (options.logging) {
+          logLevel = options.debug ? LogLevel.DEBUG : LogLevel.INFO;
+        }
+        this.logger = new Logger({
+          level: logLevel,
+          prefix: "MCPServer"
+        });
+        this.server = new import_server.Server({
+          name: options.name,
+          version: options.version
+        }, {
+          capabilities: {
+            tools: {},
+            prompts: {},
+            resources: {}
           }
         });
+        this.setupHandlers();
+        this.initPromise = this.autoInit();
       }
-      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)}`);
+      /**
+      * Internal initialization - runs automatically in constructor
+      */
+      async autoInit() {
+        const options = this.options;
+        if (options.autoDiscover !== false) {
+          await this.autoDiscoverServices(options.mcpDir, options.serviceFactories);
         }
       }
-      try {
-        const meta = request.params._meta;
-        const result = await tool.method.call(tool.instance, request.params.arguments, meta);
-        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
-        };
+      /**
+      * Wait for initialization to complete
+      * This is called internally by createHTTPServer
+      */
+      async waitForInit() {
+        await this.initPromise;
       }
-    });
-    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;
+      /**
+      * Automatically discover and register services from the mcp directory
+      * Called by init() unless autoDiscover is set to false
+      */
+      async autoDiscoverServices(customMcpDir, serviceFactories) {
+        if (this.autoDiscovered) return;
+        this.autoDiscovered = true;
+        try {
+          let mcpDir;
+          if (customMcpDir) {
+            mcpDir = customMcpDir;
+          } else {
+            const callerFile = this.getCallerFile();
+            if (callerFile) {
+              const callerDir = import_path.default.dirname(callerFile);
+              mcpDir = import_path.default.join(callerDir, "mcp");
+            } else {
+              mcpDir = import_path.default.join(process.cwd(), "mcp");
+            }
+          }
+          if (import_fs.default.existsSync(mcpDir)) {
+            this.logger.debug(`Auto-discovering services from: ${mcpDir}`);
+            await this.autoRegisterServices(mcpDir, serviceFactories);
+          } else {
+            this.logger.debug(`MCP directory not found at ${mcpDir}, skipping auto-discovery`);
+          }
+        } catch (error) {
+          this.logger.warn(`Auto-discovery failed: ${error.message}`);
         }
-        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)
+      /**
+      * Get the file path of the caller (the file that instantiated MCPServer)
+      */
+      getCallerFile() {
+        const originalPrepareStackTrace = Error.prepareStackTrace;
+        try {
+          const err = new Error();
+          Error.prepareStackTrace = (_, stack2) => stack2;
+          const stack = err.stack;
+          for (let i = 0; i < stack.length; i++) {
+            let fileName = stack[i].getFileName();
+            if (fileName && !fileName.includes("@leanmcp") && !fileName.includes("leanmcp-sdk\\packages\\core") && !fileName.includes("leanmcp-sdk/packages/core") && (fileName.endsWith(".ts") || fileName.endsWith(".js") || fileName.endsWith(".mjs"))) {
+              if (fileName.startsWith("file://")) {
+                fileName = fileName.replace("file:///", "").replace("file://", "");
+                if (process.platform === "win32" && fileName.startsWith("/")) {
+                  fileName = fileName.substring(1);
+                }
+              }
+              return fileName;
             }
-          ]
-        };
-      } 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 null;
+        } finally {
+          Error.prepareStackTrace = originalPrepareStackTrace;
         }
-        return {
-          description: prompt.description,
-          messages: [
-            {
-              role: "user",
-              content: {
-                type: "text",
-                text: typeof result === "string" ? result : JSON.stringify(result)
+      }
+      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)}`);
             }
-          ]
-        };
-      } 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: {}
+          }
+          try {
+            const meta = request.params._meta;
+            const result = await tool.method.call(tool.instance, request.params.arguments, meta);
+            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}`);
           }
         });
       }
-      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)}`);
+      /**
+      * Auto-register all services from the mcp directory
+      * Scans the directory recursively and registers all exported classes
+      * 
+      * @param mcpDir - Path to the mcp directory containing service files
+      * @param serviceFactories - Optional map of service class names to factory functions for dependency injection
+      * 
+      * @example
+      * // Auto-register services with no dependencies
+      * await server.autoRegisterServices('./mcp');
+      * 
+      * @example
+      * // Auto-register with dependency injection
+      * await server.autoRegisterServices('./mcp', {
+      *   SlackService: () => new SlackService(process.env.SLACK_TOKEN),
+      *   AuthService: () => new AuthService(authProvider)
+      * });
+      */
+      async autoRegisterServices(mcpDir, serviceFactories) {
+        this.logger.debug(`Auto-registering services from: ${mcpDir}`);
+        if (!import_fs.default.existsSync(mcpDir)) {
+          this.logger.warn(`MCP directory not found: ${mcpDir}`);
+          return;
+        }
+        const serviceFiles = this.findServiceFiles(mcpDir);
+        this.logger.debug(`Found ${serviceFiles.length} service file(s)`);
+        for (const filePath of serviceFiles) {
+          try {
+            await this.loadAndRegisterService(filePath, serviceFactories);
+          } catch (error) {
+            this.logger.error(`Failed to load service from ${filePath}: ${error.message}`);
+          }
         }
       }
-      if (methodMeta.authRequired) {
-        if (this.options.logging) {
-          this.logger.info(`Auth required for ${toolName} (provider: ${methodMeta.authProvider})`);
+      /**
+      * Recursively find all index.ts/index.js files in the mcp directory
+      */
+      findServiceFiles(dir) {
+        const files = [];
+        const entries = import_fs.default.readdirSync(dir, {
+          withFileTypes: true
+        });
+        for (const entry of entries) {
+          const fullPath = import_path.default.join(dir, entry.name);
+          if (entry.isDirectory()) {
+            files.push(...this.findServiceFiles(fullPath));
+          } else if (entry.isFile()) {
+            if (entry.name === "index.ts" || entry.name === "index.js") {
+              files.push(fullPath);
+            }
+          }
         }
+        return files;
       }
-      try {
-        const meta = request.params._meta;
-        const result = await tool.method.call(tool.instance, request.params.arguments, meta);
-        if (result && typeof result === "object" && result.type === "elicitation") {
-          return {
-            content: [
-              {
-                type: "text",
-                text: JSON.stringify(result, null, 2)
+      /**
+      * Load a service file and register all exported classes
+      */
+      async loadAndRegisterService(filePath, serviceFactories) {
+        this.logger.debug(`Loading service from: ${filePath}`);
+        const fileUrl = (0, import_url.pathToFileURL)(filePath).href;
+        const module2 = await import(fileUrl);
+        let registeredCount = 0;
+        for (const [exportName, exportValue] of Object.entries(module2)) {
+          if (typeof exportValue === "function" && exportValue.prototype) {
+            try {
+              let instance;
+              if (serviceFactories && serviceFactories[exportName]) {
+                instance = serviceFactories[exportName]();
+                this.logger.info(`Using factory for service: ${exportName}`);
+              } else {
+                instance = new exportValue();
               }
-            ],
-            isError: false
-          };
+              this.registerService(instance);
+              registeredCount++;
+              this.logger.debug(`Registered service: ${exportName} from ${import_path.default.basename(filePath)}`);
+            } catch (error) {
+              this.logger.warn(`Skipped ${exportName}: ${error.message}`);
+            }
+          }
         }
-        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);
+        if (registeredCount === 0) {
+          this.logger.warn(`No services registered from ${filePath}`);
         }
-        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
-        });
+      /**
+      * 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.debug(`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.debug(`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.debug(`Registered resource: ${methodMeta.resourceUri}`);
+          }
+        }
       }
-      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`);
+      /**
+      * Get the underlying MCP SDK Server instance
+      * Attaches waitForInit method for HTTP server initialization
+      */
+      getServer() {
+        this.server.waitForInit = () => this.waitForInit();
+        return this.server;
       }
-      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}`);
+    };
+    MCPServerRuntime = class {
+      static {
+        __name(this, "MCPServerRuntime");
       }
-    });
-    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
+      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();
       }
-      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)
+      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)}`);
             }
-          ]
-        };
-      } 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;
+          }
+          if (methodMeta.authRequired) {
+            if (this.options.logging) {
+              this.logger.info(`Auth required for ${toolName} (provider: ${methodMeta.authProvider})`);
             }
-            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)" : ""}`);
-              }
+          }
+          try {
+            const meta = request.params._meta;
+            const result = await tool.method.call(tool.instance, request.params.arguments, meta);
+            if (result && typeof result === "object" && result.type === "elicitation") {
+              return {
+                content: [
+                  {
+                    type: "text",
+                    text: JSON.stringify(result, null, 2)
+                  }
+                ],
+                isError: false
+              };
             }
-            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}`);
-              }
+            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;
             }
-            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++;
+            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.info(`Loaded resource: ${methodMeta.resourceUri}`);
+                this.logger.error("Full error:", error);
               }
             }
           }
-        } 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(`
+        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 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());
+      }
+    };
+    __name(startMCPServer, "startMCPServer");
   }
-};
-async function startMCPServer(options) {
-  const runtime = new MCPServerRuntime(options);
-  await runtime.start();
-  return runtime;
-}
-__name(startMCPServer, "startMCPServer");
+});
+init_index();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Auth,