@eaperezc/mcpgen 0.1.0

package/dist/index.js

@@ -0,0 +1,1481 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { ListToolsRequestSchema, CallToolRequestSchema, ListResourcesRequestSchema, ReadResourceRequestSchema, ListPromptsRequestSchema, GetPromptRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import { AsyncLocalStorage } from 'async_hooks';
+import { randomUUID } from 'crypto';
+import pino from 'pino';
+import { createServer } from 'http';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+export { z } from 'zod';
+
+// src/server/McpServer.ts
+
+// src/errors/types.ts
+var McpErrorCode = /* @__PURE__ */ ((McpErrorCode2) => {
+  McpErrorCode2["SERVER_NOT_INITIALIZED"] = "SERVER_NOT_INITIALIZED";
+  McpErrorCode2["SERVER_ALREADY_RUNNING"] = "SERVER_ALREADY_RUNNING";
+  McpErrorCode2["SERVER_SHUTDOWN_ERROR"] = "SERVER_SHUTDOWN_ERROR";
+  McpErrorCode2["TOOL_NOT_FOUND"] = "TOOL_NOT_FOUND";
+  McpErrorCode2["TOOL_EXECUTION_ERROR"] = "TOOL_EXECUTION_ERROR";
+  McpErrorCode2["TOOL_VALIDATION_ERROR"] = "TOOL_VALIDATION_ERROR";
+  McpErrorCode2["TOOL_ALREADY_REGISTERED"] = "TOOL_ALREADY_REGISTERED";
+  McpErrorCode2["RESOURCE_NOT_FOUND"] = "RESOURCE_NOT_FOUND";
+  McpErrorCode2["RESOURCE_READ_ERROR"] = "RESOURCE_READ_ERROR";
+  McpErrorCode2["RESOURCE_ALREADY_REGISTERED"] = "RESOURCE_ALREADY_REGISTERED";
+  McpErrorCode2["PROMPT_NOT_FOUND"] = "PROMPT_NOT_FOUND";
+  McpErrorCode2["PROMPT_RENDER_ERROR"] = "PROMPT_RENDER_ERROR";
+  McpErrorCode2["PROMPT_ALREADY_REGISTERED"] = "PROMPT_ALREADY_REGISTERED";
+  McpErrorCode2["AUTH_INVALID_TOKEN"] = "AUTH_INVALID_TOKEN";
+  McpErrorCode2["AUTH_TOKEN_EXPIRED"] = "AUTH_TOKEN_EXPIRED";
+  McpErrorCode2["AUTH_INSUFFICIENT_SCOPE"] = "AUTH_INSUFFICIENT_SCOPE";
+  McpErrorCode2["AUTH_MISSING_CREDENTIALS"] = "AUTH_MISSING_CREDENTIALS";
+  McpErrorCode2["TRANSPORT_ERROR"] = "TRANSPORT_ERROR";
+  McpErrorCode2["TRANSPORT_CONNECTION_CLOSED"] = "TRANSPORT_CONNECTION_CLOSED";
+  McpErrorCode2["VALIDATION_ERROR"] = "VALIDATION_ERROR";
+  McpErrorCode2["SCHEMA_ERROR"] = "SCHEMA_ERROR";
+  McpErrorCode2["INTERNAL_ERROR"] = "INTERNAL_ERROR";
+  McpErrorCode2["NOT_IMPLEMENTED"] = "NOT_IMPLEMENTED";
+  return McpErrorCode2;
+})(McpErrorCode || {});
+
+// src/errors/McpError.ts
+var McpError = class _McpError extends Error {
+  code;
+  details;
+  timestamp;
+  constructor(options) {
+    super(options.message);
+    this.name = "McpError";
+    this.code = options.code;
+    this.details = options.details;
+    this.timestamp = /* @__PURE__ */ new Date();
+    if (options.cause) {
+      this.cause = options.cause;
+    }
+    Error.captureStackTrace?.(this, this.constructor);
+  }
+  /**
+   * Convert error to a JSON-serializable object
+   */
+  toJSON() {
+    return {
+      name: this.name,
+      code: this.code,
+      message: this.message,
+      details: this.details,
+      timestamp: this.timestamp.toISOString(),
+      stack: this.stack
+    };
+  }
+  /**
+   * Create an error for tool not found
+   */
+  static toolNotFound(toolName) {
+    return new _McpError({
+      code: "TOOL_NOT_FOUND" /* TOOL_NOT_FOUND */,
+      message: `Tool '${toolName}' not found`,
+      details: { toolName }
+    });
+  }
+  /**
+   * Create an error for resource not found
+   */
+  static resourceNotFound(uri) {
+    return new _McpError({
+      code: "RESOURCE_NOT_FOUND" /* RESOURCE_NOT_FOUND */,
+      message: `Resource '${uri}' not found`,
+      details: { uri }
+    });
+  }
+  /**
+   * Create an error for prompt not found
+   */
+  static promptNotFound(promptName) {
+    return new _McpError({
+      code: "PROMPT_NOT_FOUND" /* PROMPT_NOT_FOUND */,
+      message: `Prompt '${promptName}' not found`,
+      details: { promptName }
+    });
+  }
+  /**
+   * Create a validation error
+   */
+  static validationError(message, details) {
+    return new _McpError({
+      code: "VALIDATION_ERROR" /* VALIDATION_ERROR */,
+      message,
+      details
+    });
+  }
+  /**
+   * Create an authentication error
+   */
+  static authError(code, message) {
+    return new _McpError({
+      code,
+      message
+    });
+  }
+  /**
+   * Create an internal error
+   */
+  static internal(message, cause) {
+    return new _McpError({
+      code: "INTERNAL_ERROR" /* INTERNAL_ERROR */,
+      message,
+      cause
+    });
+  }
+};
+
+// src/logging/types.ts
+var LOG_LEVEL_PRIORITY = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+
+// src/logging/Logger.ts
+var Logger = class _Logger {
+  pino;
+  config;
+  defaultContext;
+  constructor(config = {}) {
+    this.config = {
+      level: config.level ?? "info",
+      json: config.json ?? process.env["NODE_ENV"] === "production",
+      timestamps: config.timestamps ?? true,
+      pretty: config.pretty ?? process.env["NODE_ENV"] !== "production",
+      defaultContext: config.defaultContext ?? {}
+    };
+    this.defaultContext = this.config.defaultContext ?? {};
+    this.pino = pino({
+      level: this.config.level,
+      transport: this.config.pretty ? {
+        target: "pino-pretty",
+        options: {
+          colorize: true,
+          translateTime: "SYS:standard",
+          ignore: "pid,hostname"
+        }
+      } : void 0,
+      formatters: {
+        level: (label) => ({ level: label })
+      },
+      timestamp: this.config.timestamps ? pino.stdTimeFunctions.isoTime : false
+    });
+  }
+  /**
+   * Check if a log level should be output
+   */
+  shouldLog(level) {
+    return LOG_LEVEL_PRIORITY[level] >= LOG_LEVEL_PRIORITY[this.config.level];
+  }
+  /**
+   * Create a child logger with additional context
+   */
+  child(context) {
+    const child = new _Logger(this.config);
+    child.defaultContext = { ...this.defaultContext, ...context };
+    child.pino = this.pino.child(context);
+    return child;
+  }
+  /**
+   * Log a debug message
+   */
+  debug(message, context) {
+    if (this.shouldLog("debug")) {
+      this.pino.debug({ ...this.defaultContext, ...context }, message);
+    }
+  }
+  /**
+   * Log an info message
+   */
+  info(message, context) {
+    if (this.shouldLog("info")) {
+      this.pino.info({ ...this.defaultContext, ...context }, message);
+    }
+  }
+  /**
+   * Log a warning message
+   */
+  warn(message, context) {
+    if (this.shouldLog("warn")) {
+      this.pino.warn({ ...this.defaultContext, ...context }, message);
+    }
+  }
+  /**
+   * Log an error message
+   */
+  error(message, error) {
+    if (this.shouldLog("error")) {
+      if (error instanceof Error) {
+        this.pino.error(
+          {
+            ...this.defaultContext,
+            err: {
+              message: error.message,
+              name: error.name,
+              stack: error.stack
+            }
+          },
+          message
+        );
+      } else {
+        this.pino.error({ ...this.defaultContext, ...error }, message);
+      }
+    }
+  }
+  /**
+   * Log with correlation ID for request tracing
+   */
+  withCorrelationId(correlationId) {
+    return this.child({ correlationId });
+  }
+  /**
+   * Set the log level
+   */
+  setLevel(level) {
+    this.config.level = level;
+    this.pino.level = level;
+  }
+  /**
+   * Get the current log level
+   */
+  getLevel() {
+    return this.config.level;
+  }
+};
+var logger = new Logger();
+
+// src/context/RequestContext.ts
+var asyncLocalStorage = new AsyncLocalStorage();
+function createRequestContext(correlationId, logger2) {
+  const id = correlationId ?? randomUUID();
+  const contextLogger = (logger2 ?? logger).withCorrelationId(id);
+  return {
+    correlationId: id,
+    startTime: /* @__PURE__ */ new Date(),
+    logger: contextLogger,
+    custom: /* @__PURE__ */ new Map()
+  };
+}
+function runInRequestContext(fn, context) {
+  const ctx = context ?? createRequestContext();
+  return asyncLocalStorage.run(ctx, fn);
+}
+async function runInRequestContextAsync(fn, context) {
+  const ctx = context ?? createRequestContext();
+  return asyncLocalStorage.run(ctx, fn);
+}
+function getRequestContext() {
+  return asyncLocalStorage.getStore();
+}
+function requireRequestContext() {
+  const context = getRequestContext();
+  if (!context) {
+    throw new Error("No request context available. Ensure code is running within runInRequestContext.");
+  }
+  return context;
+}
+function getCorrelationId() {
+  return getRequestContext()?.correlationId;
+}
+function getContextLogger() {
+  return getRequestContext()?.logger ?? logger;
+}
+function setAuthContext(auth) {
+  const context = requireRequestContext();
+  context.auth = auth;
+}
+function getAuthContext() {
+  return getRequestContext()?.auth;
+}
+function setContextValue(key, value) {
+  const context = requireRequestContext();
+  context.custom.set(key, value);
+}
+function getContextValue(key) {
+  return getRequestContext()?.custom.get(key);
+}
+function getRequestDuration() {
+  const context = getRequestContext();
+  if (!context) return void 0;
+  return Date.now() - context.startTime.getTime();
+}
+
+// src/tools/BaseTool.ts
+var BaseTool = class {
+  /** Required scopes for this tool (optional) */
+  scopes = [];
+  /**
+   * Validate and execute the tool
+   */
+  async run(input) {
+    const logger2 = getContextLogger();
+    const parseResult = this.schema.safeParse(input);
+    if (!parseResult.success) {
+      const errors = parseResult.error.errors.map((e) => ({
+        path: e.path.join("."),
+        message: e.message
+      }));
+      logger2.warn("Tool input validation failed", {
+        tool: this.name,
+        errors
+      });
+      throw new McpError({
+        code: "TOOL_VALIDATION_ERROR" /* TOOL_VALIDATION_ERROR */,
+        message: `Invalid input for tool '${this.name}'`,
+        details: { errors }
+      });
+    }
+    try {
+      logger2.debug("Executing tool", { tool: this.name });
+      const result = await this.execute(parseResult.data);
+      logger2.debug("Tool executed successfully", { tool: this.name });
+      return result;
+    } catch (error) {
+      if (error instanceof McpError) {
+        throw error;
+      }
+      logger2.error("Tool execution failed", error instanceof Error ? error : void 0);
+      throw new McpError({
+        code: "TOOL_EXECUTION_ERROR" /* TOOL_EXECUTION_ERROR */,
+        message: `Tool '${this.name}' execution failed: ${error instanceof Error ? error.message : "Unknown error"}`,
+        cause: error instanceof Error ? error : void 0
+      });
+    }
+  }
+  /**
+   * Get tool metadata for registration
+   */
+  getMetadata() {
+    return {
+      name: this.name,
+      description: this.description,
+      inputSchema: this.schema,
+      scopes: this.scopes
+    };
+  }
+  /**
+   * Convert schema to JSON Schema format for MCP protocol
+   */
+  getJsonSchema() {
+    return zodToJsonSchema(this.schema);
+  }
+};
+function zodToJsonSchema(schema) {
+  const def = schema._def;
+  const typeName = def.typeName;
+  if (typeName === "ZodObject") {
+    const shape = schema.shape;
+    const properties = {};
+    const required = [];
+    for (const [key, value] of Object.entries(shape)) {
+      const zodValue = value;
+      properties[key] = zodToJsonSchema(zodValue);
+      if (!zodValue.isOptional()) {
+        required.push(key);
+      }
+    }
+    return {
+      type: "object",
+      properties,
+      required: required.length > 0 ? required : void 0
+    };
+  }
+  if (typeName === "ZodString") {
+    const result = { type: "string" };
+    if (def.description) result["description"] = def.description;
+    return result;
+  }
+  if (typeName === "ZodNumber") {
+    const result = { type: "number" };
+    if (def.description) result["description"] = def.description;
+    return result;
+  }
+  if (typeName === "ZodBoolean") {
+    const result = { type: "boolean" };
+    if (def.description) result["description"] = def.description;
+    return result;
+  }
+  if (typeName === "ZodArray") {
+    return {
+      type: "array",
+      items: zodToJsonSchema(def.type)
+    };
+  }
+  if (typeName === "ZodOptional") {
+    return zodToJsonSchema(def.innerType);
+  }
+  if (typeName === "ZodDefault") {
+    const inner = zodToJsonSchema(def.innerType);
+    return { ...inner, default: def.defaultValue() };
+  }
+  return {};
+}
+
+// src/tools/registry.ts
+var InlineTool = class extends BaseTool {
+  name;
+  description;
+  schema;
+  scopes;
+  handler;
+  constructor(name, definition) {
+    super();
+    this.name = name;
+    this.description = definition.description;
+    this.schema = definition.schema;
+    this.scopes = definition.scopes ?? [];
+    this.handler = definition.handler;
+  }
+  async execute(input) {
+    return this.handler(input);
+  }
+};
+var ToolRegistry = class {
+  tools = /* @__PURE__ */ new Map();
+  /**
+   * Register a tool instance
+   */
+  register(tool) {
+    if (this.tools.has(tool.name)) {
+      throw new McpError({
+        code: "TOOL_ALREADY_REGISTERED" /* TOOL_ALREADY_REGISTERED */,
+        message: `Tool '${tool.name}' is already registered`,
+        details: { toolName: tool.name }
+      });
+    }
+    this.tools.set(tool.name, tool);
+  }
+  /**
+   * Register an inline tool definition
+   */
+  registerInline(name, definition) {
+    const tool = new InlineTool(name, definition);
+    this.register(tool);
+  }
+  /**
+   * Get a tool by name
+   */
+  get(name) {
+    return this.tools.get(name);
+  }
+  /**
+   * Get a tool by name or throw if not found
+   */
+  getOrThrow(name) {
+    const tool = this.tools.get(name);
+    if (!tool) {
+      throw McpError.toolNotFound(name);
+    }
+    return tool;
+  }
+  /**
+   * Check if a tool exists
+   */
+  has(name) {
+    return this.tools.has(name);
+  }
+  /**
+   * Remove a tool
+   */
+  remove(name) {
+    return this.tools.delete(name);
+  }
+  /**
+   * Get all registered tools
+   */
+  getAll() {
+    return Array.from(this.tools.values());
+  }
+  /**
+   * Get all tool names
+   */
+  getNames() {
+    return Array.from(this.tools.keys());
+  }
+  /**
+   * Get the number of registered tools
+   */
+  get size() {
+    return this.tools.size;
+  }
+  /**
+   * Clear all tools
+   */
+  clear() {
+    this.tools.clear();
+  }
+};
+
+// src/resources/BaseResource.ts
+var BaseResource = class {
+  /** Description of the resource */
+  description;
+  /** MIME type of the resource content */
+  mimeType = "text/plain";
+  /** Required scopes for this resource (optional) */
+  scopes = [];
+  /**
+   * Safely read the resource with error handling
+   */
+  async safeRead() {
+    const logger2 = getContextLogger();
+    try {
+      logger2.debug("Reading resource", { uri: this.uri });
+      const result = await this.read();
+      logger2.debug("Resource read successfully", { uri: this.uri });
+      return result;
+    } catch (error) {
+      if (error instanceof McpError) {
+        throw error;
+      }
+      logger2.error("Resource read failed", error instanceof Error ? error : void 0);
+      throw new McpError({
+        code: "RESOURCE_READ_ERROR" /* RESOURCE_READ_ERROR */,
+        message: `Failed to read resource '${this.uri}': ${error instanceof Error ? error.message : "Unknown error"}`,
+        cause: error instanceof Error ? error : void 0,
+        details: { uri: this.uri }
+      });
+    }
+  }
+  /**
+   * Get resource metadata for registration
+   */
+  getMetadata() {
+    return {
+      uri: this.uri,
+      name: this.name,
+      description: this.description,
+      mimeType: this.mimeType,
+      scopes: this.scopes
+    };
+  }
+  /**
+   * Helper to create text content
+   */
+  text(content) {
+    return { type: "text", text: content };
+  }
+  /**
+   * Helper to create JSON content
+   */
+  json(data) {
+    return { type: "text", text: JSON.stringify(data, null, 2) };
+  }
+  /**
+   * Helper to create blob content
+   */
+  blob(data, mimeType) {
+    return { type: "blob", data, mimeType };
+  }
+};
+
+// src/resources/registry.ts
+var InlineResource = class extends BaseResource {
+  uri;
+  name;
+  description;
+  mimeType;
+  scopes;
+  handler;
+  constructor(uri, definition) {
+    super();
+    this.uri = uri;
+    this.name = definition.name;
+    this.description = definition.description;
+    this.mimeType = definition.mimeType;
+    this.scopes = definition.scopes ?? [];
+    this.handler = definition.read;
+  }
+  async read() {
+    return this.handler();
+  }
+};
+var ResourceRegistry = class {
+  resources = /* @__PURE__ */ new Map();
+  /**
+   * Register a resource instance
+   */
+  register(resource) {
+    if (this.resources.has(resource.uri)) {
+      throw new McpError({
+        code: "RESOURCE_ALREADY_REGISTERED" /* RESOURCE_ALREADY_REGISTERED */,
+        message: `Resource '${resource.uri}' is already registered`,
+        details: { uri: resource.uri }
+      });
+    }
+    this.resources.set(resource.uri, resource);
+  }
+  /**
+   * Register an inline resource definition
+   */
+  registerInline(uri, definition) {
+    const resource = new InlineResource(uri, definition);
+    this.register(resource);
+  }
+  /**
+   * Get a resource by URI
+   */
+  get(uri) {
+    return this.resources.get(uri);
+  }
+  /**
+   * Get a resource by URI or throw if not found
+   */
+  getOrThrow(uri) {
+    const resource = this.resources.get(uri);
+    if (!resource) {
+      throw McpError.resourceNotFound(uri);
+    }
+    return resource;
+  }
+  /**
+   * Check if a resource exists
+   */
+  has(uri) {
+    return this.resources.has(uri);
+  }
+  /**
+   * Remove a resource
+   */
+  remove(uri) {
+    return this.resources.delete(uri);
+  }
+  /**
+   * Get all registered resources
+   */
+  getAll() {
+    return Array.from(this.resources.values());
+  }
+  /**
+   * Get all resource URIs
+   */
+  getUris() {
+    return Array.from(this.resources.keys());
+  }
+  /**
+   * Get the number of registered resources
+   */
+  get size() {
+    return this.resources.size;
+  }
+  /**
+   * Clear all resources
+   */
+  clear() {
+    this.resources.clear();
+  }
+};
+
+// src/prompts/BasePrompt.ts
+var BasePrompt = class {
+  /** Human-readable description */
+  description;
+  /** Zod schema for arguments validation */
+  arguments;
+  /** Required scopes for this prompt (optional) */
+  scopes = [];
+  /**
+   * Validate arguments and render the prompt
+   */
+  async safeRender(args) {
+    const logger2 = getContextLogger();
+    if (this.arguments) {
+      const parseResult = this.arguments.safeParse(args);
+      if (!parseResult.success) {
+        const errors = parseResult.error.errors.map((e) => ({
+          path: e.path.join("."),
+          message: e.message
+        }));
+        logger2.warn("Prompt argument validation failed", {
+          prompt: this.name,
+          errors
+        });
+        throw new McpError({
+          code: "VALIDATION_ERROR" /* VALIDATION_ERROR */,
+          message: `Invalid arguments for prompt '${this.name}'`,
+          details: { errors }
+        });
+      }
+      args = parseResult.data;
+    }
+    try {
+      logger2.debug("Rendering prompt", { prompt: this.name });
+      const result = await this.render(args);
+      logger2.debug("Prompt rendered successfully", { prompt: this.name });
+      return result;
+    } catch (error) {
+      if (error instanceof McpError) {
+        throw error;
+      }
+      logger2.error("Prompt render failed", error instanceof Error ? error : void 0);
+      throw new McpError({
+        code: "PROMPT_RENDER_ERROR" /* PROMPT_RENDER_ERROR */,
+        message: `Failed to render prompt '${this.name}': ${error instanceof Error ? error.message : "Unknown error"}`,
+        cause: error instanceof Error ? error : void 0,
+        details: { promptName: this.name }
+      });
+    }
+  }
+  /**
+   * Get prompt metadata for registration
+   */
+  getMetadata() {
+    return {
+      name: this.name,
+      description: this.description,
+      arguments: this.getArgumentsMetadata(),
+      scopes: this.scopes
+    };
+  }
+  /**
+   * Get arguments metadata from schema
+   */
+  getArgumentsMetadata() {
+    if (!this.arguments) return [];
+    const def = this.arguments._def;
+    if (def.typeName !== "ZodObject") return [];
+    const shape = this.arguments.shape;
+    const result = [];
+    for (const [name, value] of Object.entries(shape)) {
+      const zodValue = value;
+      const zodDef = zodValue._def;
+      result.push({
+        name,
+        description: zodDef.description,
+        required: !zodValue.isOptional()
+      });
+    }
+    return result;
+  }
+  /**
+   * Helper to create a user message
+   */
+  user(content) {
+    return { role: "user", content };
+  }
+  /**
+   * Helper to create an assistant message
+   */
+  assistant(content) {
+    return { role: "assistant", content };
+  }
+};
+
+// src/prompts/registry.ts
+var InlinePrompt = class extends BasePrompt {
+  name;
+  description;
+  arguments;
+  scopes;
+  handler;
+  constructor(name, definition) {
+    super();
+    this.name = name;
+    this.description = definition.description;
+    this.arguments = definition.arguments;
+    this.scopes = definition.scopes ?? [];
+    this.handler = definition.render;
+  }
+  async render(args) {
+    return this.handler(args);
+  }
+};
+var PromptRegistry = class {
+  prompts = /* @__PURE__ */ new Map();
+  /**
+   * Register a prompt instance
+   */
+  register(prompt) {
+    if (this.prompts.has(prompt.name)) {
+      throw new McpError({
+        code: "PROMPT_ALREADY_REGISTERED" /* PROMPT_ALREADY_REGISTERED */,
+        message: `Prompt '${prompt.name}' is already registered`,
+        details: { promptName: prompt.name }
+      });
+    }
+    this.prompts.set(prompt.name, prompt);
+  }
+  /**
+   * Register an inline prompt definition
+   */
+  registerInline(name, definition) {
+    const prompt = new InlinePrompt(name, definition);
+    this.register(prompt);
+  }
+  /**
+   * Get a prompt by name
+   */
+  get(name) {
+    return this.prompts.get(name);
+  }
+  /**
+   * Get a prompt by name or throw if not found
+   */
+  getOrThrow(name) {
+    const prompt = this.prompts.get(name);
+    if (!prompt) {
+      throw McpError.promptNotFound(name);
+    }
+    return prompt;
+  }
+  /**
+   * Check if a prompt exists
+   */
+  has(name) {
+    return this.prompts.has(name);
+  }
+  /**
+   * Remove a prompt
+   */
+  remove(name) {
+    return this.prompts.delete(name);
+  }
+  /**
+   * Get all registered prompts
+   */
+  getAll() {
+    return Array.from(this.prompts.values());
+  }
+  /**
+   * Get all prompt names
+   */
+  getNames() {
+    return Array.from(this.prompts.keys());
+  }
+  /**
+   * Get the number of registered prompts
+   */
+  get size() {
+    return this.prompts.size;
+  }
+  /**
+   * Clear all prompts
+   */
+  clear() {
+    this.prompts.clear();
+  }
+};
+var DEFAULT_CORS = {
+  origin: "*",
+  methods: ["GET", "POST", "OPTIONS"],
+  allowedHeaders: ["Content-Type", "Authorization", "Mcp-Session-Id"],
+  exposedHeaders: ["Mcp-Session-Id"],
+  credentials: false,
+  maxAge: 86400
+  // 24 hours
+};
+var HttpTransport = class {
+  config;
+  logger;
+  httpServer = null;
+  mcpTransport = null;
+  running = false;
+  constructor(config, logger2) {
+    this.config = {
+      ...config,
+      host: config.host ?? "0.0.0.0",
+      basePath: config.basePath ?? "/mcp",
+      cors: { ...DEFAULT_CORS, ...config.cors }
+    };
+    this.logger = logger2 ?? new Logger({ level: "info" });
+  }
+  /**
+   * Start the HTTP transport
+   */
+  async start(mcpServer) {
+    if (this.running) {
+      throw new Error("Transport is already running");
+    }
+    this.mcpTransport = new StreamableHTTPServerTransport({
+      sessionIdGenerator: () => randomUUID()
+    });
+    if (mcpServer) {
+      await mcpServer.connect(this.mcpTransport);
+    }
+    this.httpServer = createServer((req, res) => {
+      this.handleRequest(req, res);
+    });
+    return new Promise((resolve, reject) => {
+      const server = this.httpServer;
+      server.on("error", (error) => {
+        this.logger.error("HTTP server error", error);
+        reject(error);
+      });
+      server.listen(this.config.port, this.config.host, () => {
+        this.running = true;
+        this.logger.info("HTTP transport started", {
+          host: this.config.host,
+          port: this.config.port,
+          basePath: this.config.basePath
+        });
+        resolve();
+      });
+    });
+  }
+  /**
+   * Stop the HTTP transport
+   */
+  async stop() {
+    if (!this.running) {
+      return;
+    }
+    if (this.mcpTransport) {
+      await this.mcpTransport.close();
+      this.mcpTransport = null;
+    }
+    if (this.httpServer) {
+      return new Promise((resolve, reject) => {
+        this.httpServer.close((error) => {
+          if (error) {
+            this.logger.error("Error closing HTTP server", error);
+            reject(error);
+          } else {
+            this.running = false;
+            this.httpServer = null;
+            this.logger.info("HTTP transport stopped");
+            resolve();
+          }
+        });
+      });
+    }
+  }
+  /**
+   * Check if transport is running
+   */
+  isRunning() {
+    return this.running;
+  }
+  /**
+   * Get the underlying MCP transport (for advanced use cases)
+   */
+  getMcpTransport() {
+    return this.mcpTransport;
+  }
+  /**
+   * Handle incoming HTTP request
+   */
+  async handleRequest(req, res) {
+    const url = new URL(req.url ?? "/", `http://${req.headers.host}`);
+    const path = url.pathname;
+    if (req.method === "OPTIONS") {
+      this.setCorsHeaders(res);
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+    this.setCorsHeaders(res);
+    if (path === "/health" || path === `${this.config.basePath}/health`) {
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ status: "healthy" }));
+      return;
+    }
+    if (path === this.config.basePath || path === `${this.config.basePath}/`) {
+      if (!this.mcpTransport) {
+        res.writeHead(503, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "Transport not initialized" }));
+        return;
+      }
+      try {
+        let body = void 0;
+        if (req.method === "POST") {
+          body = await this.parseBody(req);
+        }
+        await this.mcpTransport.handleRequest(req, res, body);
+      } catch (error) {
+        this.logger.error("Error handling MCP request", error instanceof Error ? error : void 0);
+        if (!res.headersSent) {
+          res.writeHead(500, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "Internal server error" }));
+        }
+      }
+      return;
+    }
+    res.writeHead(404, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: "Not found" }));
+  }
+  /**
+   * Set CORS headers on response
+   */
+  setCorsHeaders(res) {
+    const cors = this.config.cors;
+    if (cors.origin === true) {
+      res.setHeader("Access-Control-Allow-Origin", "*");
+    } else if (cors.origin === false) ; else if (typeof cors.origin === "string") {
+      res.setHeader("Access-Control-Allow-Origin", cors.origin);
+    } else if (Array.isArray(cors.origin)) {
+      res.setHeader("Access-Control-Allow-Origin", cors.origin.join(", "));
+    }
+    if (cors.methods) {
+      res.setHeader("Access-Control-Allow-Methods", cors.methods.join(", "));
+    }
+    if (cors.allowedHeaders) {
+      res.setHeader("Access-Control-Allow-Headers", cors.allowedHeaders.join(", "));
+    }
+    if (cors.exposedHeaders) {
+      res.setHeader("Access-Control-Expose-Headers", cors.exposedHeaders.join(", "));
+    }
+    if (cors.credentials) {
+      res.setHeader("Access-Control-Allow-Credentials", "true");
+    }
+    if (cors.maxAge) {
+      res.setHeader("Access-Control-Max-Age", cors.maxAge.toString());
+    }
+  }
+  /**
+   * Parse request body as JSON
+   */
+  parseBody(req) {
+    return new Promise((resolve, reject) => {
+      const chunks = [];
+      req.on("data", (chunk) => {
+        chunks.push(chunk);
+      });
+      req.on("end", () => {
+        try {
+          const body = Buffer.concat(chunks).toString("utf8");
+          if (!body) {
+            resolve(void 0);
+            return;
+          }
+          resolve(JSON.parse(body));
+        } catch (error) {
+          reject(new Error("Invalid JSON body"));
+        }
+      });
+      req.on("error", reject);
+    });
+  }
+};
+
+// src/server/McpServer.ts
+var McpServer = class {
+  server;
+  config;
+  logger;
+  running = false;
+  httpTransport = null;
+  toolRegistry = new ToolRegistry();
+  resourceRegistry = new ResourceRegistry();
+  promptRegistry = new PromptRegistry();
+  hooks = {};
+  constructor(config) {
+    this.config = config;
+    this.logger = new Logger({
+      level: config.logging?.level ?? "info",
+      pretty: config.logging?.pretty,
+      defaultContext: { server: config.name }
+    });
+    this.server = new Server(
+      {
+        name: config.name,
+        version: config.version
+      },
+      {
+        capabilities: this.getCapabilities()
+      }
+    );
+    this.setupHandlers();
+  }
+  /**
+   * Get server info
+   */
+  getInfo() {
+    return {
+      name: this.config.name,
+      version: this.config.version,
+      description: this.config.description
+    };
+  }
+  /**
+   * Get server capabilities
+   */
+  getCapabilities() {
+    return {
+      tools: {},
+      resources: {},
+      prompts: {}
+    };
+  }
+  /**
+   * Set up MCP request handlers
+   */
+  setupHandlers() {
+    this.server.setRequestHandler(ListToolsRequestSchema, async () => {
+      return runInRequestContextAsync(async () => {
+        const tools = this.toolRegistry.getAll();
+        return {
+          tools: tools.map((tool) => ({
+            name: tool.name,
+            description: tool.description,
+            inputSchema: tool.getJsonSchema()
+          }))
+        };
+      });
+    });
+    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+      return runInRequestContextAsync(async () => {
+        const { name, arguments: args } = request.params;
+        const tool = this.toolRegistry.get(name);
+        if (!tool) {
+          throw McpError.toolNotFound(name);
+        }
+        const result = await tool.run(args);
+        return {
+          content: [
+            {
+              type: "text",
+              text: typeof result.content === "string" ? result.content : JSON.stringify(result.content)
+            }
+          ],
+          isError: result.isError
+        };
+      });
+    });
+    this.server.setRequestHandler(ListResourcesRequestSchema, async () => {
+      return runInRequestContextAsync(async () => {
+        const resources = this.resourceRegistry.getAll();
+        return {
+          resources: resources.map((resource) => ({
+            uri: resource.uri,
+            name: resource.name,
+            description: resource.description,
+            mimeType: resource.mimeType
+          }))
+        };
+      });
+    });
+    this.server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+      return runInRequestContextAsync(async () => {
+        const { uri } = request.params;
+        const resource = this.resourceRegistry.get(uri);
+        if (!resource) {
+          throw McpError.resourceNotFound(uri);
+        }
+        const result = await resource.safeRead();
+        return {
+          contents: result.contents.map((content) => ({
+            uri,
+            ...content
+          }))
+        };
+      });
+    });
+    this.server.setRequestHandler(ListPromptsRequestSchema, async () => {
+      return runInRequestContextAsync(async () => {
+        const prompts = this.promptRegistry.getAll();
+        return {
+          prompts: prompts.map((prompt) => {
+            const metadata = prompt.getMetadata();
+            return {
+              name: prompt.name,
+              description: metadata.description,
+              arguments: metadata.arguments.map((arg) => ({
+                name: arg.name,
+                description: arg.description,
+                required: arg.required
+              }))
+            };
+          })
+        };
+      });
+    });
+    this.server.setRequestHandler(GetPromptRequestSchema, async (request) => {
+      return runInRequestContextAsync(async () => {
+        const { name, arguments: args } = request.params;
+        const prompt = this.promptRegistry.get(name);
+        if (!prompt) {
+          throw McpError.promptNotFound(name);
+        }
+        const result = await prompt.safeRender(args);
+        return {
+          description: result.description,
+          messages: result.messages.map((msg) => ({
+            role: msg.role,
+            content: { type: "text", text: msg.content }
+          }))
+        };
+      });
+    });
+  }
+  tool(toolOrName, definition) {
+    if (typeof toolOrName === "string" && definition) {
+      this.toolRegistry.registerInline(toolOrName, definition);
+    } else if (toolOrName instanceof BaseTool) {
+      this.toolRegistry.register(toolOrName);
+    }
+    return this;
+  }
+  resource(resourceOrUri, definition) {
+    if (typeof resourceOrUri === "string" && definition) {
+      this.resourceRegistry.registerInline(resourceOrUri, definition);
+    } else if (resourceOrUri instanceof BaseResource) {
+      this.resourceRegistry.register(resourceOrUri);
+    }
+    return this;
+  }
+  prompt(promptOrName, definition) {
+    if (typeof promptOrName === "string" && definition) {
+      this.promptRegistry.registerInline(promptOrName, definition);
+    } else if (promptOrName instanceof BasePrompt) {
+      this.promptRegistry.register(promptOrName);
+    }
+    return this;
+  }
+  /**
+   * Set lifecycle hooks
+   */
+  setHooks(hooks) {
+    this.hooks = { ...this.hooks, ...hooks };
+    return this;
+  }
+  /**
+   * Start the server
+   */
+  async start() {
+    if (this.running) {
+      throw new McpError({
+        code: "SERVER_ALREADY_RUNNING" /* SERVER_ALREADY_RUNNING */,
+        message: "Server is already running"
+      });
+    }
+    const transportConfig = this.config.transport ?? "stdio";
+    const transportType = typeof transportConfig === "string" ? transportConfig : transportConfig.type;
+    this.logger.info("Starting MCP server", {
+      name: this.config.name,
+      version: this.config.version,
+      transport: transportType,
+      tools: this.toolRegistry.size,
+      resources: this.resourceRegistry.size,
+      prompts: this.promptRegistry.size
+    });
+    try {
+      await this.hooks.onBeforeStart?.();
+      if (transportType === "stdio") {
+        const transport = new StdioServerTransport();
+        await this.server.connect(transport);
+      } else if (transportType === "http") {
+        const httpConfig = transportConfig;
+        this.httpTransport = new HttpTransport(httpConfig, this.logger);
+        await this.httpTransport.start(this.server);
+      } else if (transportType === "sse") {
+        throw new McpError({
+          code: "NOT_IMPLEMENTED" /* NOT_IMPLEMENTED */,
+          message: "SSE transport not yet implemented. Use HTTP transport instead."
+        });
+      }
+      this.running = true;
+      await this.hooks.onAfterStart?.();
+      this.logger.info("MCP server started successfully", {
+        transport: transportType,
+        ...transportType === "http" && {
+          port: transportConfig.port,
+          host: transportConfig.host ?? "0.0.0.0"
+        }
+      });
+    } catch (error) {
+      this.logger.error("Failed to start server", error instanceof Error ? error : void 0);
+      await this.hooks.onError?.(error instanceof Error ? error : new Error(String(error)));
+      throw error;
+    }
+  }
+  /**
+   * Stop the server
+   */
+  async stop() {
+    if (!this.running) {
+      return;
+    }
+    this.logger.info("Stopping MCP server");
+    try {
+      await this.hooks.onBeforeStop?.();
+      if (this.httpTransport) {
+        await this.httpTransport.stop();
+        this.httpTransport = null;
+      }
+      await this.server.close();
+      this.running = false;
+      await this.hooks.onAfterStop?.();
+      this.logger.info("MCP server stopped");
+    } catch (error) {
+      this.logger.error("Error stopping server", error instanceof Error ? error : void 0);
+      await this.hooks.onError?.(error instanceof Error ? error : new Error(String(error)));
+      throw error;
+    }
+  }
+  /**
+   * Check if server is running
+   */
+  isRunning() {
+    return this.running;
+  }
+  /**
+   * Get the logger instance
+   */
+  getLogger() {
+    return this.logger;
+  }
+  /**
+   * Get tool registry (for testing)
+   */
+  getToolRegistry() {
+    return this.toolRegistry;
+  }
+  /**
+   * Get resource registry (for testing)
+   */
+  getResourceRegistry() {
+    return this.resourceRegistry;
+  }
+  /**
+   * Get prompt registry (for testing)
+   */
+  getPromptRegistry() {
+    return this.promptRegistry;
+  }
+};
+
+// src/server/ServerBuilder.ts
+var ServerBuilder = class {
+  config;
+  tools = [];
+  resources = [];
+  prompts = [];
+  hooks = {};
+  constructor(config) {
+    this.config = {
+      name: config.name,
+      version: config.version,
+      description: config.description
+    };
+  }
+  /**
+   * Add a tool using inline definition
+   */
+  tool(name, definition) {
+    this.tools.push({ name, definition });
+    return this;
+  }
+  /**
+   * Add a resource using inline definition
+   */
+  resource(uri, definition) {
+    this.resources.push({ uri, definition });
+    return this;
+  }
+  /**
+   * Add a prompt using inline definition
+   */
+  prompt(name, definition) {
+    this.prompts.push({ name, definition });
+    return this;
+  }
+  /**
+   * Configure transport
+   */
+  withTransport(transport) {
+    this.config.transport = transport;
+    return this;
+  }
+  /**
+   * Configure authentication
+   */
+  withAuth(auth) {
+    this.config.auth = auth;
+    return this;
+  }
+  /**
+   * Configure logging
+   */
+  withLogging(options) {
+    this.config.logging = options;
+    return this;
+  }
+  /**
+   * Configure auto-discovery
+   */
+  withDiscovery(options) {
+    this.config.discovery = options;
+    return this;
+  }
+  /**
+   * Add lifecycle hooks
+   */
+  withHooks(hooks) {
+    this.hooks = { ...this.hooks, ...hooks };
+    return this;
+  }
+  /**
+   * Add a hook for before start
+   */
+  onBeforeStart(fn) {
+    this.hooks.onBeforeStart = fn;
+    return this;
+  }
+  /**
+   * Add a hook for after start
+   */
+  onAfterStart(fn) {
+    this.hooks.onAfterStart = fn;
+    return this;
+  }
+  /**
+   * Add a hook for before stop
+   */
+  onBeforeStop(fn) {
+    this.hooks.onBeforeStop = fn;
+    return this;
+  }
+  /**
+   * Add a hook for after stop
+   */
+  onAfterStop(fn) {
+    this.hooks.onAfterStop = fn;
+    return this;
+  }
+  /**
+   * Add an error handler
+   */
+  onError(fn) {
+    this.hooks.onError = fn;
+    return this;
+  }
+  /**
+   * Build the server instance
+   */
+  build() {
+    const server = new McpServer(this.config);
+    for (const { name, definition } of this.tools) {
+      server.tool(name, definition);
+    }
+    for (const { uri, definition } of this.resources) {
+      server.resource(uri, definition);
+    }
+    for (const { name, definition } of this.prompts) {
+      server.prompt(name, definition);
+    }
+    if (Object.keys(this.hooks).length > 0) {
+      server.setHooks(this.hooks);
+    }
+    return server;
+  }
+  /**
+   * Build and start the server
+   */
+  async start() {
+    const server = this.build();
+    await server.start();
+    return server;
+  }
+};
+function createServer2(config) {
+  return new ServerBuilder(config);
+}
+
+export { BasePrompt, BaseResource, BaseTool, HttpTransport, Logger, McpError, McpErrorCode, McpServer, PromptRegistry, ResourceRegistry, ServerBuilder, ToolRegistry, createRequestContext, createServer2 as createServer, getAuthContext, getContextLogger, getContextValue, getCorrelationId, getRequestContext, getRequestDuration, logger, requireRequestContext, runInRequestContext, runInRequestContextAsync, setAuthContext, setContextValue };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map