@leanmcp/core 0.4.4 → 0.4.6

package/dist/chunk-GTCGBX2K.mjs

@@ -0,0 +1,279 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/dynamodb-session-store.ts
+import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
+import { DynamoDBDocumentClient, GetCommand, PutCommand, DeleteCommand, UpdateCommand } from "@aws-sdk/lib-dynamodb";
+
+// 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 COLORS = {
+  reset: "\x1B[0m",
+  gray: "\x1B[38;5;244m",
+  blue: "\x1B[1;34m",
+  amber: "\x1B[38;5;214m",
+  red: "\x1B[1;31m"
+};
+var levelStyles = {
+  [0]: {
+    label: "DEBUG",
+    color: COLORS.gray
+  },
+  [1]: {
+    label: "INFO",
+    color: COLORS.blue
+  },
+  [2]: {
+    label: "WARN",
+    color: COLORS.amber
+  },
+  [3]: {
+    label: "ERROR",
+    color: COLORS.red
+  },
+  [4]: {
+    label: "NONE",
+    color: COLORS.gray
+  }
+};
+var Logger = class {
+  static {
+    __name(this, "Logger");
+  }
+  level;
+  prefix;
+  timestamps;
+  colorize;
+  context;
+  handlers;
+  constructor(options = {}) {
+    this.level = options.level ?? 1;
+    this.prefix = options.prefix ?? "";
+    this.timestamps = options.timestamps ?? true;
+    this.colorize = options.colorize ?? true;
+    this.context = options.context;
+    this.handlers = options.handlers ?? [];
+  }
+  format(level, message) {
+    const style = levelStyles[level];
+    const timestamp = this.timestamps ? `[${(/* @__PURE__ */ new Date()).toISOString()}]` : "";
+    const prefix = this.prefix ? `[${this.prefix}]` : "";
+    const context = this.context ? `[${this.context}]` : "";
+    const label = `[${style.label}]`;
+    const parts = `${timestamp}${prefix}${context}${label} ${message}`;
+    if (!this.colorize) return parts;
+    return `${style.color}${parts}${COLORS.reset}`;
+  }
+  shouldLog(level) {
+    return level >= this.level && this.level !== 4;
+  }
+  emit(level, message, consoleFn, ...args) {
+    if (!this.shouldLog(level)) return;
+    const payload = {
+      level,
+      levelLabel: levelStyles[level].label,
+      message,
+      args,
+      prefix: this.prefix,
+      context: this.context,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    consoleFn(this.format(level, message), ...args);
+    this.handlers.forEach((handler) => {
+      try {
+        handler(payload);
+      } catch (err) {
+        console.debug("Logger handler error", err);
+      }
+    });
+  }
+  debug(message, ...args) {
+    this.emit(0, message, console.debug, ...args);
+  }
+  info(message, ...args) {
+    this.emit(1, message, console.info, ...args);
+  }
+  warn(message, ...args) {
+    this.emit(2, message, console.warn, ...args);
+  }
+  error(message, ...args) {
+    this.emit(3, message, console.error, ...args);
+  }
+  setLevel(level) {
+    this.level = level;
+  }
+  getLevel() {
+    return this.level;
+  }
+};
+var defaultLogger = new Logger({
+  level: 1,
+  prefix: "LeanMCP"
+});
+
+// src/dynamodb-session-store.ts
+var DEFAULT_TABLE_NAME = "leanmcp-sessions";
+var DEFAULT_TTL_SECONDS = 86400;
+var DynamoDBSessionStore = class {
+  static {
+    __name(this, "DynamoDBSessionStore");
+  }
+  client;
+  tableName;
+  ttlSeconds;
+  logger;
+  constructor(options) {
+    this.tableName = options?.tableName || process.env.DYNAMODB_TABLE_NAME || DEFAULT_TABLE_NAME;
+    this.ttlSeconds = options?.ttlSeconds || DEFAULT_TTL_SECONDS;
+    this.logger = new Logger({
+      level: options?.logging ? LogLevel.INFO : LogLevel.NONE,
+      prefix: "DynamoDBSessionStore"
+    });
+    const dynamoClient = new DynamoDBClient({
+      region: options?.region || process.env.AWS_REGION || "us-east-1"
+    });
+    this.client = DynamoDBDocumentClient.from(dynamoClient);
+    this.logger.info(`Initialized with table: ${this.tableName}, TTL: ${this.ttlSeconds}s`);
+  }
+  /**
+  * Check if a session exists in DynamoDB
+  */
+  async sessionExists(sessionId) {
+    try {
+      const result = await this.client.send(new GetCommand({
+        TableName: this.tableName,
+        Key: {
+          sessionId
+        },
+        ProjectionExpression: "sessionId"
+      }));
+      const exists = !!result.Item;
+      this.logger.debug(`Session ${sessionId} exists: ${exists}`);
+      return exists;
+    } catch (error) {
+      this.logger.error(`Error checking session existence: ${error.message}`);
+      return false;
+    }
+  }
+  /**
+  * Create a new session in DynamoDB
+  */
+  async createSession(sessionId, data) {
+    try {
+      const now = /* @__PURE__ */ new Date();
+      const ttl = Math.floor(Date.now() / 1e3) + this.ttlSeconds;
+      await this.client.send(new PutCommand({
+        TableName: this.tableName,
+        Item: {
+          sessionId,
+          createdAt: now.toISOString(),
+          updatedAt: now.toISOString(),
+          ttl,
+          data: data || {}
+        }
+      }));
+      this.logger.info(`Created session: ${sessionId} (TTL: ${new Date(ttl * 1e3).toISOString()})`);
+    } catch (error) {
+      this.logger.error(`Error creating session ${sessionId}: ${error.message}`);
+      throw new Error(`Failed to create session: ${error.message}`);
+    }
+  }
+  /**
+  * Get session data from DynamoDB
+  */
+  async getSession(sessionId) {
+    try {
+      const result = await this.client.send(new GetCommand({
+        TableName: this.tableName,
+        Key: {
+          sessionId
+        }
+      }));
+      if (!result.Item) {
+        this.logger.debug(`Session ${sessionId} not found`);
+        return null;
+      }
+      const sessionData = {
+        sessionId: result.Item.sessionId,
+        createdAt: new Date(result.Item.createdAt),
+        updatedAt: new Date(result.Item.updatedAt),
+        ttl: result.Item.ttl,
+        data: result.Item.data
+      };
+      this.logger.debug(`Retrieved session: ${sessionId}`);
+      return sessionData;
+    } catch (error) {
+      this.logger.error(`Error getting session ${sessionId}: ${error.message}`);
+      return null;
+    }
+  }
+  /**
+  * Update session data in DynamoDB
+  * Automatically refreshes TTL on each update
+  */
+  async updateSession(sessionId, updates) {
+    try {
+      const ttl = Math.floor(Date.now() / 1e3) + this.ttlSeconds;
+      await this.client.send(new UpdateCommand({
+        TableName: this.tableName,
+        Key: {
+          sessionId
+        },
+        UpdateExpression: "SET updatedAt = :now, #data = :data, #ttl = :ttl",
+        ExpressionAttributeNames: {
+          "#data": "data",
+          "#ttl": "ttl"
+        },
+        ExpressionAttributeValues: {
+          ":now": (/* @__PURE__ */ new Date()).toISOString(),
+          ":data": updates.data || {},
+          ":ttl": ttl
+        }
+      }));
+      this.logger.debug(`Updated session: ${sessionId}`);
+    } catch (error) {
+      this.logger.error(`Error updating session ${sessionId}: ${error.message}`);
+      throw new Error(`Failed to update session: ${error.message}`);
+    }
+  }
+  /**
+  * Delete a session from DynamoDB
+  */
+  async deleteSession(sessionId) {
+    try {
+      await this.client.send(new DeleteCommand({
+        TableName: this.tableName,
+        Key: {
+          sessionId
+        }
+      }));
+      this.logger.info(`Deleted session: ${sessionId}`);
+    } catch (error) {
+      this.logger.error(`Error deleting session ${sessionId}: ${error.message}`);
+    }
+  }
+};
+
+export {
+  __name,
+  __require,
+  LogLevel,
+  Logger,
+  defaultLogger,
+  DEFAULT_TABLE_NAME,
+  DEFAULT_TTL_SECONDS,
+  DynamoDBSessionStore
+};

package/dist/dynamodb-session-store-G7V5ZRR6.mjs

@@ -0,0 +1,10 @@
+import {
+  DEFAULT_TABLE_NAME,
+  DEFAULT_TTL_SECONDS,
+  DynamoDBSessionStore
+} from "./chunk-GTCGBX2K.mjs";
+export {
+  DEFAULT_TABLE_NAME,
+  DEFAULT_TTL_SECONDS,
+  DynamoDBSessionStore
+};

package/dist/index.d.mts

@@ -382,11 +382,31 @@ declare function SchemaConstraint(constraints: {
     enum?: any[];
     description?: string;
     default?: any;
+    type?: string;
 }): PropertyDecorator;
 /**
- * Enhanced schema generator that includes constraints
+ * Enhanced schema generator that includes constraints.
+ * Now integrates with type-parser to extract actual TypeScript types
+ * (including array element types like `string[]`).
  */
-declare function classToJsonSchemaWithConstraints(classConstructor: new () => any): any;
+declare function classToJsonSchemaWithConstraints(classConstructor: new () => any, sourceFilePath?: string): any;
+
+/**
+ * Register the source file path for an input class.
+ * This is called during decorator execution to capture the source location.
+ */
+declare function registerClassSource(className: string, sourceFile: string): void;
+/**
+ * Parse a TypeScript class and extract JSON Schema types for each property.
+ * Automatically detects array types like `string[]` and adds proper `items`.
+ *
+ * This is now SYNCHRONOUS for easier integration with existing code.
+ */
+declare function parseClassTypesSync(classConstructor: new () => any, sourceFilePath?: string): Map<string, any>;
+/**
+ * Clear the type cache (useful for hot reloading)
+ */
+declare function clearTypeCache(): void;
 
 /**
  * Input validation utilities for LeanMCP
@@ -965,4 +985,4 @@ declare class MCPServerRuntime {
  */
 declare function startMCPServer(options: MCPServerOptions): Promise<MCPServerRuntime>;
 
-export { Auth, type AuthErrorOptions, type AuthErrorResult, type AuthOptions, DEFAULT_TABLE_NAME, DEFAULT_TTL_SECONDS, Deprecated, DynamoDBSessionStore, type HTTPServerAuthOptions, type HTTPServerInput, type HTTPServerOptions, type ISessionStore, InMemorySessionStore, LeanMCPSessionProvider, type LeanMCPSessionProviderOptions, LogLevel, type LogPayload, Logger, type LoggerHandler, type LoggerOptions, MCPServer, type MCPServerConstructorOptions, type MCPServerFactory, type MCPServerOptions, MCPServerRuntime, Optional, Prompt, type PromptOptions, type ProtectedResourceMetadata, Render, Resource, type ResourceOptions, SchemaConstraint, type SecurityScheme, type SessionData, Tool, type ToolOptions, UI, UserEnvs, classToJsonSchema, classToJsonSchemaWithConstraints, createAuthError, createHTTPServer, createProtectedResourceMetadata, defaultLogger, extractBearerToken, getDecoratedMethods, getMethodMetadata, isAuthError, startMCPServer, validateNonEmpty, validatePath, validatePort, validateServiceName, validateUrl };
+export { Auth, type AuthErrorOptions, type AuthErrorResult, type AuthOptions, DEFAULT_TABLE_NAME, DEFAULT_TTL_SECONDS, Deprecated, DynamoDBSessionStore, type HTTPServerAuthOptions, type HTTPServerInput, type HTTPServerOptions, type ISessionStore, InMemorySessionStore, LeanMCPSessionProvider, type LeanMCPSessionProviderOptions, LogLevel, type LogPayload, Logger, type LoggerHandler, type LoggerOptions, MCPServer, type MCPServerConstructorOptions, type MCPServerFactory, type MCPServerOptions, MCPServerRuntime, Optional, Prompt, type PromptOptions, type ProtectedResourceMetadata, Render, Resource, type ResourceOptions, SchemaConstraint, type SecurityScheme, type SessionData, Tool, type ToolOptions, UI, UserEnvs, classToJsonSchema, classToJsonSchemaWithConstraints, clearTypeCache, createAuthError, createHTTPServer, createProtectedResourceMetadata, defaultLogger, extractBearerToken, getDecoratedMethods, getMethodMetadata, isAuthError, parseClassTypesSync, registerClassSource, startMCPServer, validateNonEmpty, validatePath, validatePort, validateServiceName, validateUrl };

package/dist/index.d.ts

@@ -382,11 +382,31 @@ declare function SchemaConstraint(constraints: {
     enum?: any[];
     description?: string;
     default?: any;
+    type?: string;
 }): PropertyDecorator;
 /**
- * Enhanced schema generator that includes constraints
+ * Enhanced schema generator that includes constraints.
+ * Now integrates with type-parser to extract actual TypeScript types
+ * (including array element types like `string[]`).
  */
-declare function classToJsonSchemaWithConstraints(classConstructor: new () => any): any;
+declare function classToJsonSchemaWithConstraints(classConstructor: new () => any, sourceFilePath?: string): any;
+
+/**
+ * Register the source file path for an input class.
+ * This is called during decorator execution to capture the source location.
+ */
+declare function registerClassSource(className: string, sourceFile: string): void;
+/**
+ * Parse a TypeScript class and extract JSON Schema types for each property.
+ * Automatically detects array types like `string[]` and adds proper `items`.
+ *
+ * This is now SYNCHRONOUS for easier integration with existing code.
+ */
+declare function parseClassTypesSync(classConstructor: new () => any, sourceFilePath?: string): Map<string, any>;
+/**
+ * Clear the type cache (useful for hot reloading)
+ */
+declare function clearTypeCache(): void;
 
 /**
  * Input validation utilities for LeanMCP
@@ -965,4 +985,4 @@ declare class MCPServerRuntime {
  */
 declare function startMCPServer(options: MCPServerOptions): Promise<MCPServerRuntime>;
 
-export { Auth, type AuthErrorOptions, type AuthErrorResult, type AuthOptions, DEFAULT_TABLE_NAME, DEFAULT_TTL_SECONDS, Deprecated, DynamoDBSessionStore, type HTTPServerAuthOptions, type HTTPServerInput, type HTTPServerOptions, type ISessionStore, InMemorySessionStore, LeanMCPSessionProvider, type LeanMCPSessionProviderOptions, LogLevel, type LogPayload, Logger, type LoggerHandler, type LoggerOptions, MCPServer, type MCPServerConstructorOptions, type MCPServerFactory, type MCPServerOptions, MCPServerRuntime, Optional, Prompt, type PromptOptions, type ProtectedResourceMetadata, Render, Resource, type ResourceOptions, SchemaConstraint, type SecurityScheme, type SessionData, Tool, type ToolOptions, UI, UserEnvs, classToJsonSchema, classToJsonSchemaWithConstraints, createAuthError, createHTTPServer, createProtectedResourceMetadata, defaultLogger, extractBearerToken, getDecoratedMethods, getMethodMetadata, isAuthError, startMCPServer, validateNonEmpty, validatePath, validatePort, validateServiceName, validateUrl };
+export { Auth, type AuthErrorOptions, type AuthErrorResult, type AuthOptions, DEFAULT_TABLE_NAME, DEFAULT_TTL_SECONDS, Deprecated, DynamoDBSessionStore, type HTTPServerAuthOptions, type HTTPServerInput, type HTTPServerOptions, type ISessionStore, InMemorySessionStore, LeanMCPSessionProvider, type LeanMCPSessionProviderOptions, LogLevel, type LogPayload, Logger, type LoggerHandler, type LoggerOptions, MCPServer, type MCPServerConstructorOptions, type MCPServerFactory, type MCPServerOptions, MCPServerRuntime, Optional, Prompt, type PromptOptions, type ProtectedResourceMetadata, Render, Resource, type ResourceOptions, SchemaConstraint, type SecurityScheme, type SessionData, Tool, type ToolOptions, UI, UserEnvs, classToJsonSchema, classToJsonSchemaWithConstraints, clearTypeCache, createAuthError, createHTTPServer, createProtectedResourceMetadata, defaultLogger, extractBearerToken, getDecoratedMethods, getMethodMetadata, isAuthError, parseClassTypesSync, registerClassSource, startMCPServer, validateNonEmpty, validatePath, validatePort, validateServiceName, validateUrl };

package/dist/index.js

@@ -185,6 +185,186 @@ var init_decorators = __esm({
   }
 });
 
+// src/type-parser.ts
+function loadTsMorph() {
+  if (tsMorphLoaded) {
+    return tsMorphProject !== null;
+  }
+  tsMorphLoaded = true;
+  try {
+    const customRequire = (0, import_node_module.createRequire)(import_meta.url);
+    const tsMorph = customRequire("ts-morph");
+    tsMorphProject = tsMorph.Project;
+    tsMorphNode = tsMorph.Node;
+    return true;
+  } catch (error) {
+    console.warn(`[type-parser] ts-morph not available: ${error.message}`);
+    return false;
+  }
+}
+function registerClassSource(className, sourceFile) {
+  classSourceMap.set(className, sourceFile);
+}
+function parseClassTypesSync(classConstructor, sourceFilePath) {
+  if (!loadTsMorph()) {
+    return /* @__PURE__ */ new Map();
+  }
+  const className = classConstructor.name;
+  let filePath = sourceFilePath || classSourceMap.get(className) || findSourceFile();
+  if (!filePath) {
+    return /* @__PURE__ */ new Map();
+  }
+  if (filePath.endsWith(".js")) {
+    const tsPath = filePath.replace(/\.js$/, ".ts");
+    if (import_fs.default.existsSync(tsPath)) {
+      filePath = tsPath;
+    }
+  }
+  const cacheKey = `${filePath}:${className}`;
+  if (typeCache.has(cacheKey)) {
+    return typeCache.get(cacheKey);
+  }
+  if (!import_fs.default.existsSync(filePath)) {
+    return /* @__PURE__ */ new Map();
+  }
+  try {
+    const project = new tsMorphProject({
+      skipAddingFilesFromTsConfig: true,
+      skipFileDependencyResolution: true,
+      useInMemoryFileSystem: false
+    });
+    const sourceFile = project.addSourceFileAtPath(filePath);
+    const classDecl = sourceFile.getClass(className);
+    if (!classDecl) {
+      return /* @__PURE__ */ new Map();
+    }
+    const propertyTypes = /* @__PURE__ */ new Map();
+    for (const prop of classDecl.getInstanceProperties()) {
+      if (tsMorphNode.isPropertyDeclaration(prop)) {
+        const propName = prop.getName();
+        const typeNode = prop.getTypeNode();
+        if (typeNode) {
+          const typeText = typeNode.getText();
+          const jsonSchemaType = typeTextToJsonSchema(typeText);
+          propertyTypes.set(propName, jsonSchemaType);
+        }
+      }
+    }
+    typeCache.set(cacheKey, propertyTypes);
+    return propertyTypes;
+  } catch (error) {
+    console.warn(`[type-parser] Failed to parse ${filePath}: ${error.message}`);
+    return /* @__PURE__ */ new Map();
+  }
+}
+function typeTextToJsonSchema(typeText) {
+  const type = typeText.trim().replace(/\?$/, "");
+  if (type.endsWith("[]")) {
+    const elementType = type.slice(0, -2);
+    return {
+      type: "array",
+      items: typeTextToJsonSchema(elementType)
+    };
+  }
+  const arrayMatch = type.match(/^Array<(.+)>$/);
+  if (arrayMatch) {
+    return {
+      type: "array",
+      items: typeTextToJsonSchema(arrayMatch[1])
+    };
+  }
+  const lowerType = type.toLowerCase();
+  switch (lowerType) {
+    case "string":
+      return {
+        type: "string"
+      };
+    case "number":
+      return {
+        type: "number"
+      };
+    case "integer":
+      return {
+        type: "integer"
+      };
+    case "boolean":
+      return {
+        type: "boolean"
+      };
+    case "object":
+      return {
+        type: "object"
+      };
+    case "any":
+    case "unknown":
+      return {};
+    // No constraints
+    case "null":
+      return {
+        type: "null"
+      };
+  }
+  if (type.includes("|")) {
+    const parts = type.split("|").map((p) => p.trim());
+    const nonNullParts = parts.filter((p) => p.toLowerCase() !== "null");
+    if (nonNullParts.length === 1) {
+      return typeTextToJsonSchema(nonNullParts[0]);
+    }
+    return {
+      anyOf: nonNullParts.map((p) => typeTextToJsonSchema(p))
+    };
+  }
+  return {
+    type: "object"
+  };
+}
+function findSourceFile() {
+  const originalPrepareStackTrace = Error.prepareStackTrace;
+  try {
+    Error.prepareStackTrace = (_, stack2) => stack2;
+    const err = new Error();
+    const stack = err.stack;
+    for (const site of stack) {
+      const fileName = site.getFileName();
+      if (fileName && !fileName.includes("node_modules") && !fileName.includes("type-parser") && !fileName.includes("schema-generator") && (fileName.endsWith(".ts") || fileName.endsWith(".js"))) {
+        if (fileName.endsWith(".js")) {
+          const tsPath = fileName.replace(/\.js$/, ".ts");
+          if (import_fs.default.existsSync(tsPath)) {
+            return tsPath;
+          }
+        }
+        return fileName;
+      }
+    }
+  } finally {
+    Error.prepareStackTrace = originalPrepareStackTrace;
+  }
+  return null;
+}
+function clearTypeCache() {
+  typeCache.clear();
+}
+var import_fs, import_node_module, import_meta, typeCache, classSourceMap, tsMorphProject, tsMorphNode, tsMorphLoaded;
+var init_type_parser = __esm({
+  "src/type-parser.ts"() {
+    "use strict";
+    import_fs = __toESM(require("fs"));
+    import_node_module = require("module");
+    import_meta = {};
+    typeCache = /* @__PURE__ */ new Map();
+    classSourceMap = /* @__PURE__ */ new Map();
+    tsMorphProject = null;
+    tsMorphNode = null;
+    tsMorphLoaded = false;
+    __name(loadTsMorph, "loadTsMorph");
+    __name(registerClassSource, "registerClassSource");
+    __name(parseClassTypesSync, "parseClassTypesSync");
+    __name(typeTextToJsonSchema, "typeTextToJsonSchema");
+    __name(findSourceFile, "findSourceFile");
+    __name(clearTypeCache, "clearTypeCache");
+  }
+});
+
 // src/schema-generator.ts
 function classToJsonSchema(classConstructor) {
   const instance = new classConstructor();
@@ -240,19 +420,44 @@ function Optional() {
 function SchemaConstraint(constraints) {
   return (target, propertyKey) => {
     Reflect.defineMetadata("schema:constraints", constraints, target, propertyKey);
+    const originalPrepareStackTrace = Error.prepareStackTrace;
+    try {
+      Error.prepareStackTrace = (_, stack2) => stack2;
+      const err = new Error();
+      const stack = err.stack;
+      for (const site of stack) {
+        const fileName = site.getFileName();
+        if (fileName && !fileName.includes("node_modules") && !fileName.includes("schema-generator") && (fileName.endsWith(".ts") || fileName.endsWith(".js"))) {
+          const className = target.constructor.name;
+          if (className && className !== "Object") {
+            registerClassSource(className, fileName);
+          }
+          break;
+        }
+      }
+    } finally {
+      Error.prepareStackTrace = originalPrepareStackTrace;
+    }
   };
 }
-function classToJsonSchemaWithConstraints(classConstructor) {
+function classToJsonSchemaWithConstraints(classConstructor, sourceFilePath) {
   const instance = new classConstructor();
   const properties = {};
   const required = [];
+  const parsedTypes = parseClassTypesSync(classConstructor, sourceFilePath);
   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) {
+    const parsedType = parsedTypes.get(propertyName);
+    let propertySchema;
+    if (parsedType && parsedType.type) {
+      propertySchema = {
+        ...parsedType
+      };
+    } else if (propertyType) {
+      let jsonSchemaType = "string";
       switch (propertyType.name) {
         case "String":
           jsonSchemaType = "string";
@@ -272,8 +477,16 @@ function classToJsonSchemaWithConstraints(classConstructor) {
         default:
           jsonSchemaType = "object";
       }
+      propertySchema = {
+        type: jsonSchemaType
+      };
     } else if (constraints) {
-      if (constraints.minLength !== void 0 || constraints.maxLength !== void 0 || constraints.pattern) {
+      let jsonSchemaType = "string";
+      if (constraints.type) {
+        jsonSchemaType = constraints.type;
+      } else if (constraints.items) {
+        jsonSchemaType = "array";
+      } else 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";
@@ -287,11 +500,30 @@ function classToJsonSchemaWithConstraints(classConstructor) {
           jsonSchemaType = "string";
         }
       }
+      propertySchema = {
+        type: jsonSchemaType
+      };
+    } else {
+      propertySchema = {
+        type: "string"
+      };
     }
-    properties[propertyName] = {
-      type: jsonSchemaType,
-      ...constraints || {}
-    };
+    if (constraints) {
+      const parsedItems = propertySchema.items;
+      propertySchema = {
+        ...propertySchema,
+        ...constraints
+      };
+      if (parsedItems && !constraints.items) {
+        propertySchema.items = parsedItems;
+      }
+    }
+    if (propertySchema.type === "array" && !propertySchema.items) {
+      propertySchema.items = {
+        type: "string"
+      };
+    }
+    properties[propertyName] = propertySchema;
     if (!isOptional) {
       required.push(propertyName);
     }
@@ -307,6 +539,7 @@ var init_schema_generator = __esm({
   "src/schema-generator.ts"() {
     "use strict";
     import_reflect_metadata2 = require("reflect-metadata");
+    init_type_parser();
     __name(classToJsonSchema, "classToJsonSchema");
     __name(Optional, "Optional");
     __name(SchemaConstraint, "SchemaConstraint");
@@ -1611,6 +1844,7 @@ __export(index_exports, {
   UserEnvs: () => UserEnvs,
   classToJsonSchema: () => classToJsonSchema,
   classToJsonSchemaWithConstraints: () => classToJsonSchemaWithConstraints,
+  clearTypeCache: () => clearTypeCache,
   createAuthError: () => createAuthError,
   createHTTPServer: () => createHTTPServer,
   createProtectedResourceMetadata: () => createProtectedResourceMetadata,
@@ -1619,6 +1853,8 @@ __export(index_exports, {
   getDecoratedMethods: () => getDecoratedMethods,
   getMethodMetadata: () => getMethodMetadata,
   isAuthError: () => isAuthError,
+  parseClassTypesSync: () => parseClassTypesSync,
+  registerClassSource: () => registerClassSource,
   startMCPServer: () => startMCPServer,
   validateNonEmpty: () => validateNonEmpty,
   validatePath: () => validatePath,
@@ -1632,11 +1868,11 @@ async function startMCPServer(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 import_reflect_metadata3, import_fs2, 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_fs2 = __toESM(require("fs"));
     import_path = __toESM(require("path"));
     import_url = require("url");
     import_server = require("@modelcontextprotocol/sdk/server/index.js");
@@ -1645,6 +1881,7 @@ var init_index = __esm({
     import_ajv = __toESM(require("ajv"));
     init_decorators();
     init_schema_generator();
+    init_type_parser();
     init_http_server();
     init_logger();
     init_validation();
@@ -1733,7 +1970,7 @@ var init_index = __esm({
               mcpDir = import_path.default.join(process.cwd(), "mcp");
             }
           }
-          if (import_fs.default.existsSync(mcpDir)) {
+          if (import_fs2.default.existsSync(mcpDir)) {
             this.logger.debug(`Auto-discovering services from: ${mcpDir}`);
             await this.autoRegisterServices(mcpDir, serviceFactories);
           } else {
@@ -1983,7 +2220,7 @@ var init_index = __esm({
       */
       async autoRegisterServices(mcpDir, serviceFactories) {
         this.logger.debug(`Auto-registering services from: ${mcpDir}`);
-        if (!import_fs.default.existsSync(mcpDir)) {
+        if (!import_fs2.default.existsSync(mcpDir)) {
           this.logger.warn(`MCP directory not found: ${mcpDir}`);
           return;
         }
@@ -2002,7 +2239,7 @@ var init_index = __esm({
       */
       findServiceFiles(dir) {
         const files = [];
-        const entries = import_fs.default.readdirSync(dir, {
+        const entries = import_fs2.default.readdirSync(dir, {
           withFileTypes: true
         });
         for (const entry of entries) {
@@ -2137,7 +2374,7 @@ var init_index = __esm({
         }
         try {
           const manifestPath = import_path.default.join(process.cwd(), "dist", "ui-manifest.json");
-          if (!import_fs.default.existsSync(manifestPath)) {
+          if (!import_fs2.default.existsSync(manifestPath)) {
             return;
           }
           if (this.logging) {
@@ -2180,7 +2417,7 @@ var init_index = __esm({
       async reloadUIManifest() {
         try {
           const manifestPath = import_path.default.join(process.cwd(), "dist", "ui-manifest.json");
-          if (!import_fs.default.existsSync(manifestPath)) {
+          if (!import_fs2.default.existsSync(manifestPath)) {
             const uiResourceUris = Array.from(this.resources.keys()).filter((uri) => uri.startsWith("ui://"));
             for (const uri of uiResourceUris) {
               this.resources.delete(uri);
@@ -2190,7 +2427,7 @@ var init_index = __esm({
             }
             return;
           }
-          const manifest = JSON.parse(import_fs.default.readFileSync(manifestPath, "utf-8"));
+          const manifest = JSON.parse(import_fs2.default.readFileSync(manifestPath, "utf-8"));
           const currentUIUris = new Set(Object.keys(manifest));
           const registeredUIUris = Array.from(this.resources.keys()).filter((uri) => uri.startsWith("ui://"));
           for (const uri of registeredUIUris) {
@@ -2206,7 +2443,7 @@ var init_index = __esm({
             const htmlPath = isString ? entry : entry.htmlPath;
             const isGPTApp = !isString && entry.isGPTApp;
             const gptMeta = !isString ? entry.gptMeta : void 0;
-            if (!import_fs.default.existsSync(htmlPath)) {
+            if (!import_fs2.default.existsSync(htmlPath)) {
               if (this.logging) {
                 this.logger.warn(`UI HTML file not found: ${htmlPath}`);
               }
@@ -2227,8 +2464,8 @@ var init_index = __esm({
               mimeType,
               inputSchema: void 0,
               method: /* @__PURE__ */ __name(async () => {
-                if (import_fs.default.existsSync(htmlPath)) {
-                  const html = import_fs.default.readFileSync(htmlPath, "utf-8");
+                if (import_fs2.default.existsSync(htmlPath)) {
+                  const html = import_fs2.default.readFileSync(htmlPath, "utf-8");
                   return {
                     text: html,
                     _meta: Object.keys(_meta).length > 0 ? _meta : void 0
@@ -2257,10 +2494,10 @@ var init_index = __esm({
       async loadUIManifest() {
         try {
           const manifestPath = import_path.default.join(process.cwd(), "dist", "ui-manifest.json");
-          if (!import_fs.default.existsSync(manifestPath)) {
+          if (!import_fs2.default.existsSync(manifestPath)) {
             return;
           }
-          const manifest = JSON.parse(import_fs.default.readFileSync(manifestPath, "utf-8"));
+          const manifest = JSON.parse(import_fs2.default.readFileSync(manifestPath, "utf-8"));
           for (const [uri, entry] of Object.entries(manifest)) {
             const isString = typeof entry === "string";
             const htmlPath = isString ? entry : entry.htmlPath;
@@ -2272,13 +2509,13 @@ var init_index = __esm({
               }
               continue;
             }
-            if (!import_fs.default.existsSync(htmlPath)) {
+            if (!import_fs2.default.existsSync(htmlPath)) {
               if (this.logging) {
                 this.logger.warn(`UI HTML file not found: ${htmlPath}`);
               }
               continue;
             }
-            const html = import_fs.default.readFileSync(htmlPath, "utf-8");
+            const html = import_fs2.default.readFileSync(htmlPath, "utf-8");
             const mimeType = isGPTApp ? "text/html+skybridge" : "text/html;profile=mcp-app";
             const _meta = {};
             if (isGPTApp) {
@@ -2530,18 +2767,18 @@ var init_index = __esm({
       }
       async loadServices() {
         const absPath = import_path.default.resolve(this.options.servicesDir);
-        if (!import_fs.default.existsSync(absPath)) {
+        if (!import_fs2.default.existsSync(absPath)) {
           this.logger.error(`Services directory not found: ${absPath}`);
           return;
         }
-        const files = import_fs.default.readdirSync(absPath);
+        const files = import_fs2.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;
+          const finalPath = import_fs2.default.existsSync(modulePath) ? modulePath : import_fs2.default.existsSync(modulePathJs) ? modulePathJs : null;
           if (finalPath) {
             try {
               const fileUrl = (0, import_url.pathToFileURL)(finalPath).href;
@@ -2675,6 +2912,7 @@ init_index();
   UserEnvs,
   classToJsonSchema,
   classToJsonSchemaWithConstraints,
+  clearTypeCache,
   createAuthError,
   createHTTPServer,
   createProtectedResourceMetadata,
@@ -2683,6 +2921,8 @@ init_index();
   getDecoratedMethods,
   getMethodMetadata,
   isAuthError,
+  parseClassTypesSync,
+  registerClassSource,
   startMCPServer,
   validateNonEmpty,
   validatePath,

package/dist/index.mjs

@@ -10,7 +10,7 @@ import {
 
 // src/index.ts
 import "reflect-metadata";
-import fs from "fs";
+import fs2 from "fs";
 import path from "path";
 import { pathToFileURL } from "url";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
@@ -168,6 +168,181 @@ __name(getDecoratedMethods, "getDecoratedMethods");
 
 // src/schema-generator.ts
 import "reflect-metadata";
+
+// src/type-parser.ts
+import fs from "fs";
+import { createRequire } from "module";
+var typeCache = /* @__PURE__ */ new Map();
+var classSourceMap = /* @__PURE__ */ new Map();
+var tsMorphProject = null;
+var tsMorphNode = null;
+var tsMorphLoaded = false;
+function loadTsMorph() {
+  if (tsMorphLoaded) {
+    return tsMorphProject !== null;
+  }
+  tsMorphLoaded = true;
+  try {
+    const customRequire = createRequire(import.meta.url);
+    const tsMorph = customRequire("ts-morph");
+    tsMorphProject = tsMorph.Project;
+    tsMorphNode = tsMorph.Node;
+    return true;
+  } catch (error) {
+    console.warn(`[type-parser] ts-morph not available: ${error.message}`);
+    return false;
+  }
+}
+__name(loadTsMorph, "loadTsMorph");
+function registerClassSource(className, sourceFile) {
+  classSourceMap.set(className, sourceFile);
+}
+__name(registerClassSource, "registerClassSource");
+function parseClassTypesSync(classConstructor, sourceFilePath) {
+  if (!loadTsMorph()) {
+    return /* @__PURE__ */ new Map();
+  }
+  const className = classConstructor.name;
+  let filePath = sourceFilePath || classSourceMap.get(className) || findSourceFile();
+  if (!filePath) {
+    return /* @__PURE__ */ new Map();
+  }
+  if (filePath.endsWith(".js")) {
+    const tsPath = filePath.replace(/\.js$/, ".ts");
+    if (fs.existsSync(tsPath)) {
+      filePath = tsPath;
+    }
+  }
+  const cacheKey = `${filePath}:${className}`;
+  if (typeCache.has(cacheKey)) {
+    return typeCache.get(cacheKey);
+  }
+  if (!fs.existsSync(filePath)) {
+    return /* @__PURE__ */ new Map();
+  }
+  try {
+    const project = new tsMorphProject({
+      skipAddingFilesFromTsConfig: true,
+      skipFileDependencyResolution: true,
+      useInMemoryFileSystem: false
+    });
+    const sourceFile = project.addSourceFileAtPath(filePath);
+    const classDecl = sourceFile.getClass(className);
+    if (!classDecl) {
+      return /* @__PURE__ */ new Map();
+    }
+    const propertyTypes = /* @__PURE__ */ new Map();
+    for (const prop of classDecl.getInstanceProperties()) {
+      if (tsMorphNode.isPropertyDeclaration(prop)) {
+        const propName = prop.getName();
+        const typeNode = prop.getTypeNode();
+        if (typeNode) {
+          const typeText = typeNode.getText();
+          const jsonSchemaType = typeTextToJsonSchema(typeText);
+          propertyTypes.set(propName, jsonSchemaType);
+        }
+      }
+    }
+    typeCache.set(cacheKey, propertyTypes);
+    return propertyTypes;
+  } catch (error) {
+    console.warn(`[type-parser] Failed to parse ${filePath}: ${error.message}`);
+    return /* @__PURE__ */ new Map();
+  }
+}
+__name(parseClassTypesSync, "parseClassTypesSync");
+function typeTextToJsonSchema(typeText) {
+  const type = typeText.trim().replace(/\?$/, "");
+  if (type.endsWith("[]")) {
+    const elementType = type.slice(0, -2);
+    return {
+      type: "array",
+      items: typeTextToJsonSchema(elementType)
+    };
+  }
+  const arrayMatch = type.match(/^Array<(.+)>$/);
+  if (arrayMatch) {
+    return {
+      type: "array",
+      items: typeTextToJsonSchema(arrayMatch[1])
+    };
+  }
+  const lowerType = type.toLowerCase();
+  switch (lowerType) {
+    case "string":
+      return {
+        type: "string"
+      };
+    case "number":
+      return {
+        type: "number"
+      };
+    case "integer":
+      return {
+        type: "integer"
+      };
+    case "boolean":
+      return {
+        type: "boolean"
+      };
+    case "object":
+      return {
+        type: "object"
+      };
+    case "any":
+    case "unknown":
+      return {};
+    // No constraints
+    case "null":
+      return {
+        type: "null"
+      };
+  }
+  if (type.includes("|")) {
+    const parts = type.split("|").map((p) => p.trim());
+    const nonNullParts = parts.filter((p) => p.toLowerCase() !== "null");
+    if (nonNullParts.length === 1) {
+      return typeTextToJsonSchema(nonNullParts[0]);
+    }
+    return {
+      anyOf: nonNullParts.map((p) => typeTextToJsonSchema(p))
+    };
+  }
+  return {
+    type: "object"
+  };
+}
+__name(typeTextToJsonSchema, "typeTextToJsonSchema");
+function findSourceFile() {
+  const originalPrepareStackTrace = Error.prepareStackTrace;
+  try {
+    Error.prepareStackTrace = (_, stack2) => stack2;
+    const err = new Error();
+    const stack = err.stack;
+    for (const site of stack) {
+      const fileName = site.getFileName();
+      if (fileName && !fileName.includes("node_modules") && !fileName.includes("type-parser") && !fileName.includes("schema-generator") && (fileName.endsWith(".ts") || fileName.endsWith(".js"))) {
+        if (fileName.endsWith(".js")) {
+          const tsPath = fileName.replace(/\.js$/, ".ts");
+          if (fs.existsSync(tsPath)) {
+            return tsPath;
+          }
+        }
+        return fileName;
+      }
+    }
+  } finally {
+    Error.prepareStackTrace = originalPrepareStackTrace;
+  }
+  return null;
+}
+__name(findSourceFile, "findSourceFile");
+function clearTypeCache() {
+  typeCache.clear();
+}
+__name(clearTypeCache, "clearTypeCache");
+
+// src/schema-generator.ts
 function classToJsonSchema(classConstructor) {
   const instance = new classConstructor();
   const properties = {};
@@ -224,20 +399,45 @@ __name(Optional, "Optional");
 function SchemaConstraint(constraints) {
   return (target, propertyKey) => {
     Reflect.defineMetadata("schema:constraints", constraints, target, propertyKey);
+    const originalPrepareStackTrace = Error.prepareStackTrace;
+    try {
+      Error.prepareStackTrace = (_, stack2) => stack2;
+      const err = new Error();
+      const stack = err.stack;
+      for (const site of stack) {
+        const fileName = site.getFileName();
+        if (fileName && !fileName.includes("node_modules") && !fileName.includes("schema-generator") && (fileName.endsWith(".ts") || fileName.endsWith(".js"))) {
+          const className = target.constructor.name;
+          if (className && className !== "Object") {
+            registerClassSource(className, fileName);
+          }
+          break;
+        }
+      }
+    } finally {
+      Error.prepareStackTrace = originalPrepareStackTrace;
+    }
   };
 }
 __name(SchemaConstraint, "SchemaConstraint");
-function classToJsonSchemaWithConstraints(classConstructor) {
+function classToJsonSchemaWithConstraints(classConstructor, sourceFilePath) {
   const instance = new classConstructor();
   const properties = {};
   const required = [];
+  const parsedTypes = parseClassTypesSync(classConstructor, sourceFilePath);
   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) {
+    const parsedType = parsedTypes.get(propertyName);
+    let propertySchema;
+    if (parsedType && parsedType.type) {
+      propertySchema = {
+        ...parsedType
+      };
+    } else if (propertyType) {
+      let jsonSchemaType = "string";
       switch (propertyType.name) {
         case "String":
           jsonSchemaType = "string";
@@ -257,8 +457,16 @@ function classToJsonSchemaWithConstraints(classConstructor) {
         default:
           jsonSchemaType = "object";
       }
+      propertySchema = {
+        type: jsonSchemaType
+      };
     } else if (constraints) {
-      if (constraints.minLength !== void 0 || constraints.maxLength !== void 0 || constraints.pattern) {
+      let jsonSchemaType = "string";
+      if (constraints.type) {
+        jsonSchemaType = constraints.type;
+      } else if (constraints.items) {
+        jsonSchemaType = "array";
+      } else 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";
@@ -272,11 +480,30 @@ function classToJsonSchemaWithConstraints(classConstructor) {
           jsonSchemaType = "string";
         }
       }
+      propertySchema = {
+        type: jsonSchemaType
+      };
+    } else {
+      propertySchema = {
+        type: "string"
+      };
     }
-    properties[propertyName] = {
-      type: jsonSchemaType,
-      ...constraints || {}
-    };
+    if (constraints) {
+      const parsedItems = propertySchema.items;
+      propertySchema = {
+        ...propertySchema,
+        ...constraints
+      };
+      if (parsedItems && !constraints.items) {
+        propertySchema.items = parsedItems;
+      }
+    }
+    if (propertySchema.type === "array" && !propertySchema.items) {
+      propertySchema.items = {
+        type: "string"
+      };
+    }
+    properties[propertyName] = propertySchema;
     if (!isOptional) {
       required.push(propertyName);
     }
@@ -1328,7 +1555,7 @@ var MCPServer = class {
           mcpDir = path.join(process.cwd(), "mcp");
         }
       }
-      if (fs.existsSync(mcpDir)) {
+      if (fs2.existsSync(mcpDir)) {
         this.logger.debug(`Auto-discovering services from: ${mcpDir}`);
         await this.autoRegisterServices(mcpDir, serviceFactories);
       } else {
@@ -1578,7 +1805,7 @@ var MCPServer = class {
   */
   async autoRegisterServices(mcpDir, serviceFactories) {
     this.logger.debug(`Auto-registering services from: ${mcpDir}`);
-    if (!fs.existsSync(mcpDir)) {
+    if (!fs2.existsSync(mcpDir)) {
       this.logger.warn(`MCP directory not found: ${mcpDir}`);
       return;
     }
@@ -1597,7 +1824,7 @@ var MCPServer = class {
   */
   findServiceFiles(dir) {
     const files = [];
-    const entries = fs.readdirSync(dir, {
+    const entries = fs2.readdirSync(dir, {
       withFileTypes: true
     });
     for (const entry of entries) {
@@ -1732,7 +1959,7 @@ var MCPServer = class {
     }
     try {
       const manifestPath = path.join(process.cwd(), "dist", "ui-manifest.json");
-      if (!fs.existsSync(manifestPath)) {
+      if (!fs2.existsSync(manifestPath)) {
         return;
       }
       if (this.logging) {
@@ -1775,7 +2002,7 @@ var MCPServer = class {
   async reloadUIManifest() {
     try {
       const manifestPath = path.join(process.cwd(), "dist", "ui-manifest.json");
-      if (!fs.existsSync(manifestPath)) {
+      if (!fs2.existsSync(manifestPath)) {
         const uiResourceUris = Array.from(this.resources.keys()).filter((uri) => uri.startsWith("ui://"));
         for (const uri of uiResourceUris) {
           this.resources.delete(uri);
@@ -1785,7 +2012,7 @@ var MCPServer = class {
         }
         return;
       }
-      const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
+      const manifest = JSON.parse(fs2.readFileSync(manifestPath, "utf-8"));
       const currentUIUris = new Set(Object.keys(manifest));
       const registeredUIUris = Array.from(this.resources.keys()).filter((uri) => uri.startsWith("ui://"));
       for (const uri of registeredUIUris) {
@@ -1801,7 +2028,7 @@ var MCPServer = class {
         const htmlPath = isString ? entry : entry.htmlPath;
         const isGPTApp = !isString && entry.isGPTApp;
         const gptMeta = !isString ? entry.gptMeta : void 0;
-        if (!fs.existsSync(htmlPath)) {
+        if (!fs2.existsSync(htmlPath)) {
           if (this.logging) {
             this.logger.warn(`UI HTML file not found: ${htmlPath}`);
           }
@@ -1822,8 +2049,8 @@ var MCPServer = class {
           mimeType,
           inputSchema: void 0,
           method: /* @__PURE__ */ __name(async () => {
-            if (fs.existsSync(htmlPath)) {
-              const html = fs.readFileSync(htmlPath, "utf-8");
+            if (fs2.existsSync(htmlPath)) {
+              const html = fs2.readFileSync(htmlPath, "utf-8");
               return {
                 text: html,
                 _meta: Object.keys(_meta).length > 0 ? _meta : void 0
@@ -1852,10 +2079,10 @@ var MCPServer = class {
   async loadUIManifest() {
     try {
       const manifestPath = path.join(process.cwd(), "dist", "ui-manifest.json");
-      if (!fs.existsSync(manifestPath)) {
+      if (!fs2.existsSync(manifestPath)) {
         return;
       }
-      const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
+      const manifest = JSON.parse(fs2.readFileSync(manifestPath, "utf-8"));
       for (const [uri, entry] of Object.entries(manifest)) {
         const isString = typeof entry === "string";
         const htmlPath = isString ? entry : entry.htmlPath;
@@ -1867,13 +2094,13 @@ var MCPServer = class {
           }
           continue;
         }
-        if (!fs.existsSync(htmlPath)) {
+        if (!fs2.existsSync(htmlPath)) {
           if (this.logging) {
             this.logger.warn(`UI HTML file not found: ${htmlPath}`);
           }
           continue;
         }
-        const html = fs.readFileSync(htmlPath, "utf-8");
+        const html = fs2.readFileSync(htmlPath, "utf-8");
         const mimeType = isGPTApp ? "text/html+skybridge" : "text/html;profile=mcp-app";
         const _meta = {};
         if (isGPTApp) {
@@ -2125,18 +2352,18 @@ var MCPServerRuntime = class {
   }
   async loadServices() {
     const absPath = path.resolve(this.options.servicesDir);
-    if (!fs.existsSync(absPath)) {
+    if (!fs2.existsSync(absPath)) {
       this.logger.error(`Services directory not found: ${absPath}`);
       return;
     }
-    const files = fs.readdirSync(absPath);
+    const files = fs2.readdirSync(absPath);
     let toolCount = 0;
     let promptCount = 0;
     let resourceCount = 0;
     for (const dir of files) {
       const modulePath = path.join(absPath, dir, "index.ts");
       const modulePathJs = path.join(absPath, dir, "index.js");
-      const finalPath = fs.existsSync(modulePath) ? modulePath : fs.existsSync(modulePathJs) ? modulePathJs : null;
+      const finalPath = fs2.existsSync(modulePath) ? modulePath : fs2.existsSync(modulePathJs) ? modulePathJs : null;
       if (finalPath) {
         try {
           const fileUrl = pathToFileURL(finalPath).href;
@@ -2271,6 +2498,7 @@ export {
   UserEnvs,
   classToJsonSchema,
   classToJsonSchemaWithConstraints,
+  clearTypeCache,
   createAuthError,
   createHTTPServer,
   createProtectedResourceMetadata,
@@ -2279,6 +2507,8 @@ export {
   getDecoratedMethods,
   getMethodMetadata,
   isAuthError,
+  parseClassTypesSync,
+  registerClassSource,
   startMCPServer,
   validateNonEmpty,
   validatePath,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leanmcp/core",
-  "version": "0.4.4",
+  "version": "0.4.6",
   "description": "Core library implementing decorators, reflection, and MCP runtime server",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -30,7 +30,8 @@
     "ajv": "^8.12.0",
     "chokidar": "^4.0.0",
     "dotenv": "^16.3.1",
-    "reflect-metadata": "^0.2.1"
+    "reflect-metadata": "^0.2.1",
+    "ts-morph": "^24.0.0"
   },
   "peerDependencies": {
     "cors": "^2.8.5",
@@ -75,4 +76,4 @@
   "publishConfig": {
     "access": "public"
   }
-}
+}