mcp-use 1.0.3 → 1.0.4

package/dist/index.cjs

@@ -496,6 +496,7 @@ __export(index_exports, {
   Telemetry: () => Telemetry,
   ToolMessage: () => import_messages3.ToolMessage,
   WebSocketConnector: () => WebSocketConnector,
+  createMCPServer: () => createMCPServer,
   createOAuthMCPConfig: () => createOAuthMCPConfig,
   createReadableStreamFromGenerator: () => createReadableStreamFromGenerator,
   loadConfigFile: () => loadConfigFile,
@@ -2585,6 +2586,7 @@ var MCPAgent = class {
           totalResponseLength += event.data.chunk.content.length;
         }
         yield event;
+        await new Promise((resolve) => setTimeout(resolve, 0));
         if (event.event === "on_chain_end" && event.data?.output) {
           const output = event.data.output;
           if (Array.isArray(output) && output.length > 0 && output[0]?.text) {
@@ -3999,6 +4001,643 @@ async function* streamEventsToAISDKWithTools(streamEvents) {
 }
 __name(streamEventsToAISDKWithTools, "streamEventsToAISDKWithTools");
 
+// src/server/mcp-server.ts
+var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
+var import_zod7 = require("zod");
+var import_express = __toESM(require("express"), 1);
+var import_node_fs3 = require("fs");
+var import_node_path2 = require("path");
+
+// src/server/logging.ts
+function requestLogger(req, res, next) {
+  const timestamp2 = (/* @__PURE__ */ new Date()).toISOString().substring(11, 23);
+  const method = req.method;
+  const url = req.url;
+  const originalEnd = res.end.bind(res);
+  res.end = function(chunk, encoding, cb) {
+    const statusCode = res.statusCode;
+    let statusColor = "";
+    if (statusCode >= 200 && statusCode < 300) {
+      statusColor = "\x1B[32m";
+    } else if (statusCode >= 300 && statusCode < 400) {
+      statusColor = "\x1B[33m";
+    } else if (statusCode >= 400 && statusCode < 500) {
+      statusColor = "\x1B[31m";
+    } else if (statusCode >= 500) {
+      statusColor = "\x1B[35m";
+    }
+    let logMessage = `[${timestamp2}] ${method} \x1B[1m${url}\x1B[0m`;
+    if (method === "POST" && url === "/mcp" && req.body?.method) {
+      logMessage += ` \x1B[1m[${req.body.method}]\x1B[0m`;
+    }
+    logMessage += ` ${statusColor}${statusCode}\x1B[0m`;
+    console.log(logMessage);
+    return originalEnd(chunk, encoding, cb);
+  };
+  next();
+}
+__name(requestLogger, "requestLogger");
+
+// src/server/mcp-server.ts
+var McpServer = class {
+  static {
+    __name(this, "McpServer");
+  }
+  server;
+  config;
+  app;
+  mcpMounted = false;
+  inspectorMounted = false;
+  serverPort;
+  /**
+   * Creates a new MCP server instance with Express integration
+   * 
+   * Initializes the server with the provided configuration, sets up CORS headers,
+   * configures widget serving routes, and creates a proxy that allows direct
+   * access to Express methods while preserving MCP server functionality.
+   * 
+   * @param config - Server configuration including name, version, and description
+   * @returns A proxied McpServer instance that supports both MCP and Express methods
+   */
+  constructor(config2) {
+    this.config = config2;
+    this.server = new import_mcp.McpServer({
+      name: config2.name,
+      version: config2.version
+    });
+    this.app = (0, import_express.default)();
+    this.app.use(import_express.default.json());
+    this.app.use((req, res, next) => {
+      res.header("Access-Control-Allow-Origin", "*");
+      res.header("Access-Control-Allow-Methods", "GET, POST, DELETE, OPTIONS");
+      res.header("Access-Control-Allow-Headers", "Content-Type");
+      next();
+    });
+    this.app.use(requestLogger);
+    this.setupWidgetRoutes();
+    return new Proxy(this, {
+      get(target, prop) {
+        if (prop in target) {
+          return target[prop];
+        }
+        const value = target.app[prop];
+        return typeof value === "function" ? value.bind(target.app) : value;
+      }
+    });
+  }
+  /**
+   * Define a static resource that can be accessed by clients
+   * 
+   * Registers a resource with the MCP server that clients can access via HTTP.
+   * Resources are static content like files, data, or pre-computed results that
+   * can be retrieved by clients without requiring parameters.
+   * 
+   * @param resourceDefinition - Configuration object containing resource metadata and handler function
+   * @param resourceDefinition.name - Unique identifier for the resource
+   * @param resourceDefinition.uri - URI pattern for accessing the resource
+   * @param resourceDefinition.title - Optional human-readable title for the resource
+   * @param resourceDefinition.description - Optional description of the resource
+   * @param resourceDefinition.mimeType - MIME type of the resource content
+   * @param resourceDefinition.annotations - Optional annotations (audience, priority, lastModified)
+   * @param resourceDefinition.fn - Async function that returns the resource content
+   * @returns The server instance for method chaining
+   * 
+   * @example
+   * ```typescript
+   * server.resource({
+   *   name: 'config',
+   *   uri: 'config://app-settings',
+   *   title: 'Application Settings',
+   *   mimeType: 'application/json',
+   *   description: 'Current application configuration',
+   *   annotations: {
+   *     audience: ['user'],
+   *     priority: 0.8
+   *   },
+   *   fn: async () => ({
+   *     contents: [{
+   *       uri: 'config://app-settings',
+   *       mimeType: 'application/json',
+   *       text: JSON.stringify({ theme: 'dark', language: 'en' })
+   *     }]
+   *   })
+   * })
+   * ```
+   */
+  resource(resourceDefinition) {
+    this.server.resource(
+      resourceDefinition.name,
+      resourceDefinition.uri,
+      {
+        name: resourceDefinition.name,
+        title: resourceDefinition.title,
+        description: resourceDefinition.description,
+        mimeType: resourceDefinition.mimeType,
+        annotations: resourceDefinition.annotations
+      },
+      async () => {
+        return await resourceDefinition.fn();
+      }
+    );
+    return this;
+  }
+  /**
+   * Define a dynamic resource template with parameters
+   * 
+   * Registers a parameterized resource template with the MCP server. Templates use URI
+   * patterns with placeholders that can be filled in at request time, allowing dynamic
+   * resource generation based on parameters.
+   * 
+   * @param resourceTemplateDefinition - Configuration object for the resource template
+   * @param resourceTemplateDefinition.name - Unique identifier for the template
+   * @param resourceTemplateDefinition.resourceTemplate - ResourceTemplate object with uriTemplate and metadata
+   * @param resourceTemplateDefinition.fn - Async function that generates resource content from URI and params
+   * @returns The server instance for method chaining
+   * 
+   * @example
+   * ```typescript
+   * server.resourceTemplate({
+   *   name: 'user-profile',
+   *   resourceTemplate: {
+   *     uriTemplate: 'user://{userId}/profile',
+   *     name: 'User Profile',
+   *     mimeType: 'application/json'
+   *   },
+   *   fn: async (uri, params) => ({
+   *     contents: [{
+   *       uri: uri.toString(),
+   *       mimeType: 'application/json',
+   *       text: JSON.stringify({ userId: params.userId, name: 'John Doe' })
+   *     }]
+   *   })
+   * })
+   * ```
+   */
+  resourceTemplate(resourceTemplateDefinition) {
+    const template = new import_mcp.ResourceTemplate(
+      resourceTemplateDefinition.resourceTemplate.uriTemplate,
+      {
+        list: void 0,
+        // Optional: callback to list all matching resources
+        complete: void 0
+        // Optional: callback for auto-completion
+      }
+    );
+    const metadata = {};
+    if (resourceTemplateDefinition.resourceTemplate.name) {
+      metadata.name = resourceTemplateDefinition.resourceTemplate.name;
+    }
+    if (resourceTemplateDefinition.title) {
+      metadata.title = resourceTemplateDefinition.title;
+    }
+    if (resourceTemplateDefinition.description || resourceTemplateDefinition.resourceTemplate.description) {
+      metadata.description = resourceTemplateDefinition.description || resourceTemplateDefinition.resourceTemplate.description;
+    }
+    if (resourceTemplateDefinition.resourceTemplate.mimeType) {
+      metadata.mimeType = resourceTemplateDefinition.resourceTemplate.mimeType;
+    }
+    if (resourceTemplateDefinition.annotations) {
+      metadata.annotations = resourceTemplateDefinition.annotations;
+    }
+    this.server.resource(
+      resourceTemplateDefinition.name,
+      template,
+      metadata,
+      async (uri) => {
+        const params = this.parseTemplateUri(
+          resourceTemplateDefinition.resourceTemplate.uriTemplate,
+          uri.toString()
+        );
+        return await resourceTemplateDefinition.fn(uri, params);
+      }
+    );
+    return this;
+  }
+  /**
+   * Define a tool that can be called by clients
+   * 
+   * Registers a tool with the MCP server that clients can invoke with parameters.
+   * Tools are functions that perform actions, computations, or operations and
+   * return results. They accept structured input parameters and return structured output.
+   * 
+   * @param toolDefinition - Configuration object containing tool metadata and handler function
+   * @param toolDefinition.name - Unique identifier for the tool
+   * @param toolDefinition.description - Human-readable description of what the tool does
+   * @param toolDefinition.inputs - Array of input parameter definitions with types and validation
+   * @param toolDefinition.fn - Async function that executes the tool logic with provided parameters
+   * @returns The server instance for method chaining
+   * 
+   * @example
+   * ```typescript
+   * server.tool({
+   *   name: 'calculate',
+   *   description: 'Performs mathematical calculations',
+   *   inputs: [
+   *     { name: 'expression', type: 'string', required: true },
+   *     { name: 'precision', type: 'number', required: false }
+   *   ],
+   *   fn: async ({ expression, precision = 2 }) => {
+   *     const result = eval(expression)
+   *     return { result: Number(result.toFixed(precision)) }
+   *   }
+   * })
+   * ```
+   */
+  tool(toolDefinition) {
+    const inputSchema = this.createToolInputSchema(toolDefinition.inputs || []);
+    this.server.tool(
+      toolDefinition.name,
+      toolDefinition.description ?? "",
+      inputSchema,
+      async (params) => {
+        return await toolDefinition.fn(params);
+      }
+    );
+    return this;
+  }
+  /**
+   * Define a prompt template
+   * 
+   * Registers a prompt template with the MCP server that clients can use to generate
+   * structured prompts for AI models. Prompt templates accept parameters and return
+   * formatted text that can be used as input to language models or other AI systems.
+   * 
+   * @param promptDefinition - Configuration object containing prompt metadata and handler function
+   * @param promptDefinition.name - Unique identifier for the prompt template
+   * @param promptDefinition.description - Human-readable description of the prompt's purpose
+   * @param promptDefinition.args - Array of argument definitions with types and validation
+   * @param promptDefinition.fn - Async function that generates the prompt from provided arguments
+   * @returns The server instance for method chaining
+   * 
+   * @example
+   * ```typescript
+   * server.prompt({
+   *   name: 'code-review',
+   *   description: 'Generates a code review prompt',
+   *   args: [
+   *     { name: 'language', type: 'string', required: true },
+   *     { name: 'focus', type: 'string', required: false }
+   *   ],
+   *   fn: async ({ language, focus = 'general' }) => {
+   *     return {
+   *       messages: [{
+   *         role: 'user',
+   *         content: `Please review this ${language} code with focus on ${focus}...`
+   *       }]
+   *     }
+   *   }
+   * })
+   * ```
+   */
+  prompt(promptDefinition) {
+    const argsSchema = this.createPromptArgsSchema(promptDefinition.args || []);
+    this.server.prompt(
+      promptDefinition.name,
+      promptDefinition.description ?? "",
+      argsSchema,
+      async (params) => {
+        return await promptDefinition.fn(params);
+      }
+    );
+    return this;
+  }
+  /**
+   * Mount MCP server endpoints at /mcp
+   * 
+   * Sets up the HTTP transport layer for the MCP server, creating endpoints for
+   * Server-Sent Events (SSE) streaming, POST message handling, and DELETE session cleanup.
+   * Uses stateless mode for session management, making it suitable for stateless deployments.
+   * 
+   * This method is called automatically when the server starts listening and ensures
+   * that MCP clients can communicate with the server over HTTP.
+   * 
+   * @private
+   * @returns Promise that resolves when MCP endpoints are successfully mounted
+   * 
+   * @example
+   * Endpoints created:
+   * - GET /mcp - SSE streaming endpoint for real-time communication
+   * - POST /mcp - Message handling endpoint for MCP protocol messages
+   * - DELETE /mcp - Session cleanup endpoint
+   */
+  async mountMcp() {
+    if (this.mcpMounted) return;
+    const { StreamableHTTPServerTransport } = await import("@modelcontextprotocol/sdk/server/streamableHttp.js");
+    const httpTransport = new StreamableHTTPServerTransport({
+      sessionIdGenerator: void 0
+      // Stateless mode
+    });
+    await this.server.connect(httpTransport);
+    const endpoint = "/mcp";
+    this.app.get(endpoint, async (req, res) => {
+      await httpTransport.handleRequest(req, res);
+    });
+    this.app.post(endpoint, import_express.default.json(), async (req, res) => {
+      await httpTransport.handleRequest(req, res, req.body);
+    });
+    this.app.delete(endpoint, async (req, res) => {
+      await httpTransport.handleRequest(req, res);
+    });
+    this.mcpMounted = true;
+    console.log(`[MCP] Server mounted at ${endpoint}`);
+  }
+  /**
+   * Start the Express server with MCP endpoints
+   * 
+   * Initiates the server startup process by mounting MCP endpoints, configuring
+   * the inspector UI (if available), and starting the Express server to listen
+   * for incoming connections. This is the main entry point for running the server.
+   * 
+   * The server will be accessible at the specified port with MCP endpoints at /mcp
+   * and inspector UI at /inspector (if the inspector package is installed).
+   * 
+   * @param port - Port number to listen on (defaults to 3001 if not specified)
+   * @returns Promise that resolves when the server is successfully listening
+   * 
+   * @example
+   * ```typescript
+   * await server.listen(8080)
+   * // Server now running at http://localhost:8080
+   * // MCP endpoints: http://localhost:8080/mcp
+   * // Inspector UI: http://localhost:8080/inspector
+   * ```
+   */
+  async listen(port) {
+    await this.mountMcp();
+    this.serverPort = port || 3001;
+    this.mountInspector();
+    this.app.listen(this.serverPort, () => {
+      console.log(`[SERVER] Listening on http://localhost:${this.serverPort}`);
+      console.log(`[MCP] Endpoints: http://localhost:${this.serverPort}/mcp`);
+    });
+  }
+  /**
+   * Mount MCP Inspector UI at /inspector
+   * 
+   * Dynamically loads and mounts the MCP Inspector UI package if available, providing
+   * a web-based interface for testing and debugging MCP servers. The inspector
+   * automatically connects to the local MCP server endpoints.
+   * 
+   * This method gracefully handles cases where the inspector package is not installed,
+   * allowing the server to function without the inspector in production environments.
+   * 
+   * @private
+   * @returns void
+   * 
+   * @example
+   * If @mcp-use/inspector is installed:
+   * - Inspector UI available at http://localhost:PORT/inspector
+   * - Automatically connects to http://localhost:PORT/mcp
+   * 
+   * If not installed:
+   * - Server continues to function normally
+   * - No inspector UI available
+   */
+  mountInspector() {
+    if (this.inspectorMounted) return;
+    import("@mcp-use/inspector").then(({ mountInspector }) => {
+      const mcpServerUrl = `http://localhost:${this.serverPort}/mcp`;
+      mountInspector(this.app, "/inspector", mcpServerUrl);
+      this.inspectorMounted = true;
+      console.log(`[INSPECTOR] UI available at http://localhost:${this.serverPort}/inspector`);
+    }).catch(() => {
+    });
+  }
+  /**
+   * Setup default widget serving routes
+   * 
+   * Configures Express routes to serve MCP UI widgets and their static assets.
+   * Widgets are served from the dist/resources/mcp-use/widgets directory and can
+   * be accessed via HTTP endpoints for embedding in web applications.
+   * 
+   * Routes created:
+   * - GET /mcp-use/widgets/:widget - Serves widget's index.html
+   * - GET /mcp-use/widgets/:widget/assets/* - Serves widget-specific assets
+   * - GET /mcp-use/widgets/assets/* - Fallback asset serving with auto-discovery
+   * 
+   * @private
+   * @returns void
+   * 
+   * @example
+   * Widget routes:
+   * - http://localhost:3001/mcp-use/widgets/kanban-board
+   * - http://localhost:3001/mcp-use/widgets/todo-list/assets/style.css
+   * - http://localhost:3001/mcp-use/widgets/assets/script.js (auto-discovered)
+   */
+  setupWidgetRoutes() {
+    this.app.get("/mcp-use/widgets/:widget/assets/*", (req, res, next) => {
+      const widget = req.params.widget;
+      const assetFile = req.params[0];
+      const assetPath = (0, import_node_path2.join)(process.cwd(), "dist", "resources", "mcp-use", "widgets", widget, "assets", assetFile);
+      res.sendFile(assetPath, (err) => err ? next() : void 0);
+    });
+    this.app.get("/mcp-use/widgets/assets/*", (req, res, next) => {
+      const assetFile = req.params[0];
+      const widgetsDir = (0, import_node_path2.join)(process.cwd(), "dist", "resources", "mcp-use", "widgets");
+      try {
+        const widgets = (0, import_node_fs3.readdirSync)(widgetsDir);
+        for (const widget of widgets) {
+          const assetPath = (0, import_node_path2.join)(widgetsDir, widget, "assets", assetFile);
+          if ((0, import_node_fs3.existsSync)(assetPath)) {
+            return res.sendFile(assetPath);
+          }
+        }
+        next();
+      } catch {
+        next();
+      }
+    });
+    this.app.get("/mcp-use/widgets/:widget", (req, res, next) => {
+      const filePath = (0, import_node_path2.join)(process.cwd(), "dist", "resources", "mcp-use", "widgets", req.params.widget, "index.html");
+      res.sendFile(filePath, (err) => err ? next() : void 0);
+    });
+  }
+  /**
+   * Create input schema for resource templates
+   * 
+   * Parses a URI template string to extract parameter names and generates a Zod
+   * validation schema for those parameters. Used internally for validating resource
+   * template parameters before processing requests.
+   * 
+   * @param uriTemplate - URI template string with parameter placeholders (e.g., "/users/{id}/posts/{postId}")
+   * @returns Object mapping parameter names to Zod string schemas
+   * 
+   * @example
+   * ```typescript
+   * const schema = this.createInputSchema("/users/{id}/posts/{postId}")
+   * // Returns: { id: z.string(), postId: z.string() }
+   * ```
+   */
+  createInputSchema(uriTemplate) {
+    const params = this.extractTemplateParams(uriTemplate);
+    const schema = {};
+    params.forEach((param) => {
+      schema[param] = import_zod7.z.string();
+    });
+    return schema;
+  }
+  /**
+   * Create input schema for tools
+   * 
+   * Converts tool input definitions into Zod validation schemas for runtime validation.
+   * Supports common data types (string, number, boolean, object, array) and optional
+   * parameters. Used internally when registering tools with the MCP server.
+   * 
+   * @param inputs - Array of input parameter definitions with name, type, and optional flag
+   * @returns Object mapping parameter names to Zod validation schemas
+   * 
+   * @example
+   * ```typescript
+   * const schema = this.createToolInputSchema([
+   *   { name: 'query', type: 'string', required: true },
+   *   { name: 'limit', type: 'number', required: false }
+   * ])
+   * // Returns: { query: z.string(), limit: z.number().optional() }
+   * ```
+   */
+  createToolInputSchema(inputs) {
+    const schema = {};
+    inputs.forEach((input) => {
+      let zodType;
+      switch (input.type) {
+        case "string":
+          zodType = import_zod7.z.string();
+          break;
+        case "number":
+          zodType = import_zod7.z.number();
+          break;
+        case "boolean":
+          zodType = import_zod7.z.boolean();
+          break;
+        case "object":
+          zodType = import_zod7.z.object({});
+          break;
+        case "array":
+          zodType = import_zod7.z.array(import_zod7.z.any());
+          break;
+        default:
+          zodType = import_zod7.z.any();
+      }
+      if (!input.required) {
+        zodType = zodType.optional();
+      }
+      schema[input.name] = zodType;
+    });
+    return schema;
+  }
+  /**
+   * Create arguments schema for prompts
+   * 
+   * Converts prompt argument definitions into Zod validation schemas for runtime validation.
+   * Supports common data types (string, number, boolean, object, array) and optional
+   * parameters. Used internally when registering prompt templates with the MCP server.
+   * 
+   * @param inputs - Array of argument definitions with name, type, and optional flag
+   * @returns Object mapping argument names to Zod validation schemas
+   * 
+   * @example
+   * ```typescript
+   * const schema = this.createPromptArgsSchema([
+   *   { name: 'topic', type: 'string', required: true },
+   *   { name: 'style', type: 'string', required: false }
+   * ])
+   * // Returns: { topic: z.string(), style: z.string().optional() }
+   * ```
+   */
+  createPromptArgsSchema(inputs) {
+    const schema = {};
+    inputs.forEach((input) => {
+      let zodType;
+      switch (input.type) {
+        case "string":
+          zodType = import_zod7.z.string();
+          break;
+        case "number":
+          zodType = import_zod7.z.number();
+          break;
+        case "boolean":
+          zodType = import_zod7.z.boolean();
+          break;
+        case "object":
+          zodType = import_zod7.z.object({});
+          break;
+        case "array":
+          zodType = import_zod7.z.array(import_zod7.z.any());
+          break;
+        default:
+          zodType = import_zod7.z.any();
+      }
+      if (!input.required) {
+        zodType = zodType.optional();
+      }
+      schema[input.name] = zodType;
+    });
+    return schema;
+  }
+  /**
+   * Extract parameter names from URI template
+   * 
+   * Parses a URI template string to extract parameter names enclosed in curly braces.
+   * Used internally to identify dynamic parameters in resource templates and generate
+   * appropriate validation schemas.
+   * 
+   * @param uriTemplate - URI template string with parameter placeholders (e.g., "/users/{id}/posts/{postId}")
+   * @returns Array of parameter names found in the template
+   * 
+   * @example
+   * ```typescript
+   * const params = this.extractTemplateParams("/users/{id}/posts/{postId}")
+   * // Returns: ["id", "postId"]
+   * ```
+   */
+  extractTemplateParams(uriTemplate) {
+    const matches = uriTemplate.match(/\{([^}]+)\}/g);
+    return matches ? matches.map((match) => match.slice(1, -1)) : [];
+  }
+  /**
+   * Parse parameter values from a URI based on a template
+   * 
+   * Extracts parameter values from an actual URI by matching it against a URI template.
+   * The template contains placeholders like {param} which are extracted as key-value pairs.
+   * 
+   * @param template - URI template with placeholders (e.g., "user://{userId}/posts/{postId}")
+   * @param uri - Actual URI to parse (e.g., "user://123/posts/456")
+   * @returns Object mapping parameter names to their values
+   * 
+   * @example
+   * ```typescript
+   * const params = this.parseTemplateUri("user://{userId}/posts/{postId}", "user://123/posts/456")
+   * // Returns: { userId: "123", postId: "456" }
+   * ```
+   */
+  parseTemplateUri(template, uri) {
+    const params = {};
+    let regexPattern = template.replace(/[.*+?^$()[\]\\|]/g, "\\$&");
+    const paramNames = [];
+    regexPattern = regexPattern.replace(/\\\{([^}]+)\\\}/g, (_, paramName) => {
+      paramNames.push(paramName);
+      return "([^/]+)";
+    });
+    const regex = new RegExp(`^${regexPattern}$`);
+    const match = uri.match(regex);
+    if (match) {
+      paramNames.forEach((paramName, index) => {
+        params[paramName] = match[index + 1];
+      });
+    }
+    return params;
+  }
+};
+function createMCPServer(name, config2 = {}) {
+  const instance = new McpServer({
+    name,
+    version: config2.version || "1.0.0",
+    description: config2.description
+  });
+  return instance;
+}
+__name(createMCPServer, "createMCPServer");
+
 // src/oauth-helper.ts
 var OAuthHelper = class {
   static {
@@ -5347,6 +5986,7 @@ var import_messages3 = require("@langchain/core/messages");
   Telemetry,
   ToolMessage,
   WebSocketConnector,
+  createMCPServer,
   createOAuthMCPConfig,
   createReadableStreamFromGenerator,
   loadConfigFile,

package/dist/index.d.ts

@@ -13,6 +13,8 @@ export * from './src/agents/utils/index.js';
 export { ServerManager } from './src/managers/server_manager.js';
 export * from './src/managers/tools/index.js';
 export { type ObservabilityConfig, ObservabilityManager } from './src/observability/index.js';
+export { createMCPServer } from './src/server/index.js';
+export type { InputDefinition, PromptDefinition, PromptHandler, ResourceDefinition, ResourceHandler, ServerConfig, ToolDefinition, ToolHandler, } from './src/server/types.js';
 export { setTelemetrySource, Telemetry } from './src/telemetry/index.js';
 export { OAuthHelper, LINEAR_OAUTH_CONFIG, createOAuthMCPConfig } from './src/oauth-helper.js';
 export type { OAuthConfig, OAuthDiscovery, ClientRegistration, OAuthResult, OAuthState } from './src/oauth-helper.js';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,2BAA2B,CAAA;AACpD,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAA;AACpD,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAC3C,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAA;AAChD,OAAO,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAA;AACxD,OAAO,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAA;AACxD,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAA;AAC1D,OAAO,EAAE,kBAAkB,EAAE,MAAM,+BAA+B,CAAA;AAElE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAA;AACjD,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAE7C,OAAO,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAA;AAEvE,cAAc,6BAA6B,CAAA;AAC3C,OAAO,EAAE,aAAa,EAAE,MAAM,kCAAkC,CAAA;AAEhE,cAAc,+BAA+B,CAAA;AAG7C,OAAO,EAAE,KAAK,mBAAmB,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAA;AAG7F,OAAO,EAAE,kBAAkB,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAA;AAGxE,OAAO,EAAE,WAAW,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAA;AAC9F,YAAY,EAAE,WAAW,EAAE,cAAc,EAAE,kBAAkB,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAA;AAGrH,OAAO,EAAE,0BAA0B,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAA;AACpF,YAAY,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAA;AAGtD,cAAc,sBAAsB,CAAA;AAGpC,OAAO,EAAE,SAAS,EAAE,WAAW,EAAE,YAAY,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAA;AAG3G,YAAY,EAAE,WAAW,EAAE,MAAM,oCAAoC,CAAA;AAErE,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,SAAS,EAAE,UAAU,EAAE,WAAW,EAAE,cAAc,EAAE,kBAAkB,EAAE,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,2BAA2B,CAAA;AACpD,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAA;AACpD,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAC3C,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAA;AAChD,OAAO,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAA;AACxD,OAAO,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAA;AACxD,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAA;AAC1D,OAAO,EAAE,kBAAkB,EAAE,MAAM,+BAA+B,CAAA;AAElE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAA;AACjD,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAE7C,OAAO,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAA;AAEvE,cAAc,6BAA6B,CAAA;AAC3C,OAAO,EAAE,aAAa,EAAE,MAAM,kCAAkC,CAAA;AAEhE,cAAc,+BAA+B,CAAA;AAG7C,OAAO,EAAE,KAAK,mBAAmB,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAA;AAG7F,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAA;AAEvD,YAAY,EACV,eAAe,EACf,gBAAgB,EAChB,aAAa,EACb,kBAAkB,EAClB,eAAe,EACf,YAAY,EACZ,cAAc,EACd,WAAW,GACZ,MAAM,uBAAuB,CAAA;AAE9B,OAAO,EAAE,kBAAkB,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAA;AAGxE,OAAO,EAAE,WAAW,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAA;AAC9F,YAAY,EAAE,WAAW,EAAE,cAAc,EAAE,kBAAkB,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAA;AAGrH,OAAO,EAAE,0BAA0B,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAA;AACpF,YAAY,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAA;AAGtD,cAAc,sBAAsB,CAAA;AAGpC,OAAO,EAAE,SAAS,EAAE,WAAW,EAAE,YAAY,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAA;AAG3G,YAAY,EAAE,WAAW,EAAE,MAAM,oCAAoC,CAAA;AAErE,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,SAAS,EAAE,UAAU,EAAE,WAAW,EAAE,cAAc,EAAE,kBAAkB,EAAE,CAAA"}