mcp-use 1.0.3 → 1.0.5

package/dist/src/server/index.js

@@ -39,6 +39,71 @@ function requestLogger(req, res, next) {
 }
 __name(requestLogger, "requestLogger");
 
+// src/server/adapters/mcp-ui-adapter.ts
+import { createUIResource } from "@mcp-ui/server";
+function buildWidgetUrl(widget, props, config) {
+  const url = new URL(
+    `/mcp-use/widgets/${widget}`,
+    `${config.baseUrl}:${config.port}`
+  );
+  if (props) {
+    Object.entries(props).forEach(([key, value]) => {
+      if (value !== void 0 && value !== null) {
+        const stringValue = typeof value === "object" ? JSON.stringify(value) : String(value);
+        url.searchParams.set(key, stringValue);
+      }
+    });
+  }
+  return url.toString();
+}
+__name(buildWidgetUrl, "buildWidgetUrl");
+function createExternalUrlResource(uri, iframeUrl, encoding = "text") {
+  return createUIResource({
+    uri,
+    content: { type: "externalUrl", iframeUrl },
+    encoding
+  });
+}
+__name(createExternalUrlResource, "createExternalUrlResource");
+function createRawHtmlResource(uri, htmlString, encoding = "text") {
+  return createUIResource({
+    uri,
+    content: { type: "rawHtml", htmlString },
+    encoding
+  });
+}
+__name(createRawHtmlResource, "createRawHtmlResource");
+function createRemoteDomResource(uri, script, framework = "react", encoding = "text") {
+  return createUIResource({
+    uri,
+    content: { type: "remoteDom", script, framework },
+    encoding
+  });
+}
+__name(createRemoteDomResource, "createRemoteDomResource");
+function createUIResourceFromDefinition(definition, params, config) {
+  const uri = `ui://widget/${definition.name}`;
+  const encoding = definition.encoding || "text";
+  switch (definition.type) {
+    case "externalUrl": {
+      const widgetUrl = buildWidgetUrl(definition.widget, params, config);
+      return createExternalUrlResource(uri, widgetUrl, encoding);
+    }
+    case "rawHtml": {
+      return createRawHtmlResource(uri, definition.htmlContent, encoding);
+    }
+    case "remoteDom": {
+      const framework = definition.framework || "react";
+      return createRemoteDomResource(uri, definition.script, framework, encoding);
+    }
+    default: {
+      const _exhaustive = definition;
+      throw new Error(`Unknown UI resource type: ${_exhaustive.type}`);
+    }
+  }
+}
+__name(createUIResourceFromDefinition, "createUIResourceFromDefinition");
+
 // src/server/mcp-server.ts
 var McpServer = class {
   static {
@@ -71,7 +136,7 @@ var McpServer = class {
     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");
+      res.header("Access-Control-Allow-Headers", "Content-Type, Accept, Authorization, mcp-protocol-version, mcp-session-id, X-Proxy-Token, X-Target-URL");
       next();
     });
     this.app.use(requestLogger);
@@ -302,12 +367,196 @@ var McpServer = class {
     );
     return this;
   }
+  /**
+   * Register a UI widget as both a tool and a resource
+   *
+   * Creates a unified interface for MCP-UI compatible widgets that can be accessed
+   * either as tools (with parameters) or as resources (static access). The tool
+   * allows dynamic parameter passing while the resource provides discoverable access.
+   *
+   * @param definition - Configuration for the UI widget
+   * @param definition.name - Unique identifier for the resource
+   * @param definition.widget - Widget name (matches directory in dist/resources/mcp-use/widgets)
+   * @param definition.title - Human-readable title for the widget
+   * @param definition.description - Description of the widget's functionality
+   * @param definition.props - Widget properties configuration with types and defaults
+   * @param definition.size - Preferred iframe size [width, height] (e.g., ['800px', '600px'])
+   * @param definition.annotations - Resource annotations for discovery
+   * @returns The server instance for method chaining
+   *
+   * @example
+   * ```typescript
+   * server.uiResource({
+   *   name: 'kanban-board',
+   *   widget: 'kanban-board',
+   *   title: 'Kanban Board',
+   *   description: 'Interactive task management board',
+   *   props: {
+   *     initialTasks: {
+   *       type: 'array',
+   *       description: 'Initial tasks to display',
+   *       required: false
+   *     },
+   *     theme: {
+   *       type: 'string',
+   *       default: 'light'
+   *     }
+   *   },
+   *   size: ['900px', '600px']
+   * })
+   * ```
+   */
+  uiResource(definition) {
+    const toolName = definition.type === "externalUrl" ? `ui_${definition.widget}` : `ui_${definition.name}`;
+    const displayName = definition.title || definition.name;
+    let resourceUri;
+    let mimeType;
+    switch (definition.type) {
+      case "externalUrl":
+        resourceUri = `ui://widget/${definition.widget}`;
+        mimeType = "text/uri-list";
+        break;
+      case "rawHtml":
+        resourceUri = `ui://widget/${definition.name}`;
+        mimeType = "text/html";
+        break;
+      case "remoteDom":
+        resourceUri = `ui://widget/${definition.name}`;
+        mimeType = "application/vnd.mcp-ui.remote-dom+javascript";
+        break;
+      default:
+        throw new Error(`Unsupported UI resource type. Must be one of: externalUrl, rawHtml, remoteDom`);
+    }
+    this.resource({
+      name: definition.name,
+      uri: resourceUri,
+      title: definition.title,
+      description: definition.description,
+      mimeType,
+      annotations: definition.annotations,
+      fn: /* @__PURE__ */ __name(async () => {
+        const params = definition.type === "externalUrl" ? this.applyDefaultProps(definition.props) : {};
+        const uiResource = this.createWidgetUIResource(definition, params);
+        return {
+          contents: [uiResource.resource]
+        };
+      }, "fn")
+    });
+    this.tool({
+      name: toolName,
+      description: definition.description || `Display ${displayName}`,
+      inputs: this.convertPropsToInputs(definition.props),
+      fn: /* @__PURE__ */ __name(async (params) => {
+        const uiResource = this.createWidgetUIResource(definition, params);
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Displaying ${displayName}`,
+              description: `Show MCP-UI widget for ${displayName}`
+            },
+            uiResource
+          ]
+        };
+      }, "fn")
+    });
+    return this;
+  }
+  /**
+   * Create a UIResource object for a widget with the given parameters
+   *
+   * This method is shared between tool and resource handlers to avoid duplication.
+   * It creates a consistent UIResource structure that can be rendered by MCP-UI
+   * compatible clients.
+   *
+   * @private
+   * @param definition - UIResource definition
+   * @param params - Parameters to pass to the widget via URL
+   * @returns UIResource object compatible with MCP-UI
+   */
+  createWidgetUIResource(definition, params) {
+    const urlConfig = {
+      baseUrl: "http://localhost",
+      port: this.serverPort || 3001
+    };
+    return createUIResourceFromDefinition(definition, params, urlConfig);
+  }
+  /**
+   * Build a complete URL for a widget including query parameters
+   *
+   * Constructs the full URL to access a widget's iframe, encoding any provided
+   * parameters as query string parameters. Complex objects are JSON-stringified
+   * for transmission.
+   *
+   * @private
+   * @param widget - Widget name/identifier
+   * @param params - Parameters to encode in the URL
+   * @returns Complete URL with encoded parameters
+   */
+  buildWidgetUrl(widget, params) {
+    const baseUrl = `http://localhost:${this.serverPort}/mcp-use/widgets/${widget}`;
+    if (Object.keys(params).length === 0) {
+      return baseUrl;
+    }
+    const queryParams = new URLSearchParams();
+    for (const [key, value] of Object.entries(params)) {
+      if (value !== void 0 && value !== null) {
+        if (typeof value === "object") {
+          queryParams.append(key, JSON.stringify(value));
+        } else {
+          queryParams.append(key, String(value));
+        }
+      }
+    }
+    return `${baseUrl}?${queryParams.toString()}`;
+  }
+  /**
+   * Convert widget props definition to tool input schema
+   *
+   * Transforms the widget props configuration into the format expected by
+   * the tool registration system, mapping types and handling defaults.
+   *
+   * @private
+   * @param props - Widget props configuration
+   * @returns Array of InputDefinition objects for tool registration
+   */
+  convertPropsToInputs(props) {
+    if (!props) return [];
+    return Object.entries(props).map(([name, prop]) => ({
+      name,
+      type: prop.type,
+      description: prop.description,
+      required: prop.required,
+      default: prop.default
+    }));
+  }
+  /**
+   * Apply default values to widget props
+   *
+   * Extracts default values from the props configuration to use when
+   * the resource is accessed without parameters.
+   *
+   * @private
+   * @param props - Widget props configuration
+   * @returns Object with default values for each prop
+   */
+  applyDefaultProps(props) {
+    if (!props) return {};
+    const defaults = {};
+    for (const [key, prop] of Object.entries(props)) {
+      if (prop.default !== void 0) {
+        defaults[key] = prop.default;
+      }
+    }
+    return defaults;
+  }
   /**
    * 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.
+   * Each request gets its own transport instance to prevent state conflicts between
+   * concurrent client connections.
    * 
    * This method is called automatically when the server starts listening and ensures
    * that MCP clients can communicate with the server over HTTP.
@@ -324,20 +573,39 @@ var McpServer = class {
   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, express.json(), async (req, res) => {
-      await httpTransport.handleRequest(req, res, req.body);
+      const transport = new StreamableHTTPServerTransport({
+        sessionIdGenerator: void 0,
+        enableJsonResponse: true
+      });
+      res.on("close", () => {
+        transport.close();
+      });
+      await this.server.connect(transport);
+      await transport.handleRequest(req, res, req.body);
+    });
+    this.app.get(endpoint, async (req, res) => {
+      const transport = new StreamableHTTPServerTransport({
+        sessionIdGenerator: void 0,
+        enableJsonResponse: true
+      });
+      res.on("close", () => {
+        transport.close();
+      });
+      await this.server.connect(transport);
+      await transport.handleRequest(req, res);
     });
     this.app.delete(endpoint, async (req, res) => {
-      await httpTransport.handleRequest(req, res);
+      const transport = new StreamableHTTPServerTransport({
+        sessionIdGenerator: void 0,
+        enableJsonResponse: true
+      });
+      res.on("close", () => {
+        transport.close();
+      });
+      await this.server.connect(transport);
+      await transport.handleRequest(req, res);
     });
     this.mcpMounted = true;
     console.log(`[MCP] Server mounted at ${endpoint}`);
@@ -639,5 +907,10 @@ function createMCPServer(name, config = {}) {
 }
 __name(createMCPServer, "createMCPServer");
 export {
-  createMCPServer
+  buildWidgetUrl,
+  createExternalUrlResource,
+  createMCPServer,
+  createRawHtmlResource,
+  createRemoteDomResource,
+  createUIResourceFromDefinition
 };

package/dist/src/server/mcp-server.d.ts

@@ -1,4 +1,4 @@
-import type { PromptDefinition, ResourceDefinition, ResourceTemplateDefinition, ServerConfig, ToolDefinition } from './types.js';
+import type { PromptDefinition, ResourceDefinition, ResourceTemplateDefinition, ServerConfig, ToolDefinition, UIResourceDefinition } from './types/index.js';
 import { type Express } from 'express';
 export declare class McpServer {
     private server;
@@ -157,12 +157,101 @@ export declare class McpServer {
      * ```
      */
     prompt(promptDefinition: PromptDefinition): this;
+    /**
+     * Register a UI widget as both a tool and a resource
+     *
+     * Creates a unified interface for MCP-UI compatible widgets that can be accessed
+     * either as tools (with parameters) or as resources (static access). The tool
+     * allows dynamic parameter passing while the resource provides discoverable access.
+     *
+     * @param definition - Configuration for the UI widget
+     * @param definition.name - Unique identifier for the resource
+     * @param definition.widget - Widget name (matches directory in dist/resources/mcp-use/widgets)
+     * @param definition.title - Human-readable title for the widget
+     * @param definition.description - Description of the widget's functionality
+     * @param definition.props - Widget properties configuration with types and defaults
+     * @param definition.size - Preferred iframe size [width, height] (e.g., ['800px', '600px'])
+     * @param definition.annotations - Resource annotations for discovery
+     * @returns The server instance for method chaining
+     *
+     * @example
+     * ```typescript
+     * server.uiResource({
+     *   name: 'kanban-board',
+     *   widget: 'kanban-board',
+     *   title: 'Kanban Board',
+     *   description: 'Interactive task management board',
+     *   props: {
+     *     initialTasks: {
+     *       type: 'array',
+     *       description: 'Initial tasks to display',
+     *       required: false
+     *     },
+     *     theme: {
+     *       type: 'string',
+     *       default: 'light'
+     *     }
+     *   },
+     *   size: ['900px', '600px']
+     * })
+     * ```
+     */
+    uiResource(definition: UIResourceDefinition): this;
+    /**
+     * Create a UIResource object for a widget with the given parameters
+     *
+     * This method is shared between tool and resource handlers to avoid duplication.
+     * It creates a consistent UIResource structure that can be rendered by MCP-UI
+     * compatible clients.
+     *
+     * @private
+     * @param definition - UIResource definition
+     * @param params - Parameters to pass to the widget via URL
+     * @returns UIResource object compatible with MCP-UI
+     */
+    private createWidgetUIResource;
+    /**
+     * Build a complete URL for a widget including query parameters
+     *
+     * Constructs the full URL to access a widget's iframe, encoding any provided
+     * parameters as query string parameters. Complex objects are JSON-stringified
+     * for transmission.
+     *
+     * @private
+     * @param widget - Widget name/identifier
+     * @param params - Parameters to encode in the URL
+     * @returns Complete URL with encoded parameters
+     */
+    private buildWidgetUrl;
+    /**
+     * Convert widget props definition to tool input schema
+     *
+     * Transforms the widget props configuration into the format expected by
+     * the tool registration system, mapping types and handling defaults.
+     *
+     * @private
+     * @param props - Widget props configuration
+     * @returns Array of InputDefinition objects for tool registration
+     */
+    private convertPropsToInputs;
+    /**
+     * Apply default values to widget props
+     *
+     * Extracts default values from the props configuration to use when
+     * the resource is accessed without parameters.
+     *
+     * @private
+     * @param props - Widget props configuration
+     * @returns Object with default values for each prop
+     */
+    private applyDefaultProps;
     /**
      * 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.
+     * Each request gets its own transport instance to prevent state conflicts between
+     * concurrent client connections.
      *
      * This method is called automatically when the server starts listening and ensures
      * that MCP clients can communicate with the server over HTTP.

package/dist/src/server/mcp-server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mcp-server.d.ts","sourceRoot":"","sources":["../../../src/server/mcp-server.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,gBAAgB,EAChB,kBAAkB,EAClB,0BAA0B,EAC1B,YAAY,EACZ,cAAc,EACf,MAAM,YAAY,CAAA;AAGnB,OAAgB,EAAE,KAAK,OAAO,EAAE,MAAM,SAAS,CAAA;AAK/C,qBAAa,SAAS;IACpB,OAAO,CAAC,MAAM,CAAmB;IACjC,OAAO,CAAC,MAAM,CAAc;IAC5B,OAAO,CAAC,GAAG,CAAS;IACpB,OAAO,CAAC,UAAU,CAAQ;IAC1B,OAAO,CAAC,gBAAgB,CAAQ;IAChC,OAAO,CAAC,UAAU,CAAC,CAAQ;IAE3B;;;;;;;;;OASG;gBACS,MAAM,EAAE,YAAY;IAsChC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAsCG;IACH,QAAQ,CAAC,kBAAkB,EAAE,kBAAkB,GAAG,IAAI;IAkBtD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACH,gBAAgB,CAAC,0BAA0B,EAAE,0BAA0B,GAAG,IAAI;IA4C9E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,IAAI,CAAC,cAAc,EAAE,cAAc,GAAG,IAAI;IAa1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiCG;IACH,MAAM,CAAC,gBAAgB,EAAE,gBAAgB,GAAG,IAAI;IAahD;;;;;;;;;;;;;;;;;;OAkBG;YACW,QAAQ;IAkCtB;;;;;;;;;;;;;;;;;;;;OAoBG;IACG,MAAM,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAa1C;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,OAAO,CAAC,cAAc;IAqBtB;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,OAAO,CAAC,iBAAiB;IAsCzB;;;;;;;;;;;;;;;OAeG;IACH,OAAO,CAAC,iBAAiB;IAWzB;;;;;;;;;;;;;;;;;;OAkBG;IACH,OAAO,CAAC,qBAAqB;IAmC7B;;;;;;;;;;;;;;;;;;OAkBG;IACH,OAAO,CAAC,sBAAsB;IAmC9B;;;;;;;;;;;;;;;OAeG;IACH,OAAO,CAAC,qBAAqB;IAK7B;;;;;;;;;;;;;;;OAeG;IACH,OAAO,CAAC,gBAAgB;CAyBzB;AAED,MAAM,MAAM,iBAAiB,GAAG,IAAI,CAAC,SAAS,EAAE,MAAM,OAAO,CAAC,GAAG,OAAO,CAAA;AAExE;;GAEG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,GAAE,OAAO,CAAC,YAAY,CAAM,GAAG,iBAAiB,CAOnG"}
+{"version":3,"file":"mcp-server.d.ts","sourceRoot":"","sources":["../../../src/server/mcp-server.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,gBAAgB,EAChB,kBAAkB,EAClB,0BAA0B,EAC1B,YAAY,EACZ,cAAc,EACd,oBAAoB,EAIrB,MAAM,kBAAkB,CAAA;AAGzB,OAAgB,EAAE,KAAK,OAAO,EAAE,MAAM,SAAS,CAAA;AAM/C,qBAAa,SAAS;IACpB,OAAO,CAAC,MAAM,CAAmB;IACjC,OAAO,CAAC,MAAM,CAAc;IAC5B,OAAO,CAAC,GAAG,CAAS;IACpB,OAAO,CAAC,UAAU,CAAQ;IAC1B,OAAO,CAAC,gBAAgB,CAAQ;IAChC,OAAO,CAAC,UAAU,CAAC,CAAQ;IAE3B;;;;;;;;;OASG;gBACS,MAAM,EAAE,YAAY;IAsChC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAsCG;IACH,QAAQ,CAAC,kBAAkB,EAAE,kBAAkB,GAAG,IAAI;IAkBtD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACH,gBAAgB,CAAC,0BAA0B,EAAE,0BAA0B,GAAG,IAAI;IA4C9E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,IAAI,CAAC,cAAc,EAAE,cAAc,GAAG,IAAI;IAa1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiCG;IACH,MAAM,CAAC,gBAAgB,EAAE,gBAAgB,GAAG,IAAI;IAahD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAsCG;IACH,UAAU,CAAC,UAAU,EAAE,oBAAoB,GAAG,IAAI;IAyElD;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,sBAAsB;IAY9B;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,cAAc;IAsBtB;;;;;;;;;OASG;IACH,OAAO,CAAC,oBAAoB;IAY5B;;;;;;;;;OASG;IACH,OAAO,CAAC,iBAAiB;IAYzB;;;;;;;;;;;;;;;;;;;OAmBG;YACW,QAAQ;IAyDtB;;;;;;;;;;;;;;;;;;;;OAoBG;IACG,MAAM,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAa1C;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,OAAO,CAAC,cAAc;IAqBtB;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,OAAO,CAAC,iBAAiB;IAsCzB;;;;;;;;;;;;;;;OAeG;IACH,OAAO,CAAC,iBAAiB;IAWzB;;;;;;;;;;;;;;;;;;OAkBG;IACH,OAAO,CAAC,qBAAqB;IAmC7B;;;;;;;;;;;;;;;;;;OAkBG;IACH,OAAO,CAAC,sBAAsB;IAmC9B;;;;;;;;;;;;;;;OAeG;IACH,OAAO,CAAC,qBAAqB;IAK7B;;;;;;;;;;;;;;;OAeG;IACH,OAAO,CAAC,gBAAgB;CAyBzB;AAED,MAAM,MAAM,iBAAiB,GAAG,IAAI,CAAC,SAAS,EAAE,MAAM,OAAO,CAAC,GAAG,OAAO,CAAA;AAExE;;GAEG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,GAAE,OAAO,CAAC,YAAY,CAAM,GAAG,iBAAiB,CAOnG"}

package/dist/src/server/types/common.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Common type definitions shared across different MCP components
+ */
+export interface ServerConfig {
+    name: string;
+    version: string;
+    description?: string;
+}
+export interface InputDefinition {
+    name: string;
+    type: 'string' | 'number' | 'boolean' | 'object' | 'array';
+    description?: string;
+    required?: boolean;
+    default?: any;
+}
+/**
+ * Annotations provide hints to clients about how to use or display resources
+ */
+export interface ResourceAnnotations {
+    /** Intended audience(s) for this resource */
+    audience?: ('user' | 'assistant')[];
+    /** Priority from 0.0 (least important) to 1.0 (most important) */
+    priority?: number;
+    /** ISO 8601 formatted timestamp of last modification */
+    lastModified?: string;
+}
+//# sourceMappingURL=common.d.ts.map

package/dist/src/server/types/common.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../../../src/server/types/common.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;IACf,WAAW,CAAC,EAAE,MAAM,CAAA;CACrB;AAED,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,QAAQ,GAAG,QAAQ,GAAG,SAAS,GAAG,QAAQ,GAAG,OAAO,CAAA;IAC1D,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,OAAO,CAAC,EAAE,GAAG,CAAA;CACd;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,6CAA6C;IAC7C,QAAQ,CAAC,EAAE,CAAC,MAAM,GAAG,WAAW,CAAC,EAAE,CAAA;IACnC,kEAAkE;IAClE,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,wDAAwD;IACxD,YAAY,CAAC,EAAE,MAAM,CAAA;CACtB"}

package/dist/src/server/types/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Centralized type exports for MCP server
+ */
+export { ServerConfig, InputDefinition, ResourceAnnotations } from './common.js';
+export { ResourceHandler, ResourceTemplateHandler, ResourceTemplateConfig, ResourceTemplateDefinition, ResourceDefinition, UIResourceContent, WidgetProps, UIEncoding, RemoteDomFramework, UIResourceDefinition, ExternalUrlUIResource, RawHtmlUIResource, RemoteDomUIResource, WidgetConfig, WidgetManifest, DiscoverWidgetsOptions } from './resource.js';
+export { ToolHandler, ToolDefinition } from './tool.js';
+export { PromptHandler, PromptDefinition } from './prompt.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/server/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/server/types/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,EACL,YAAY,EACZ,eAAe,EACf,mBAAmB,EACpB,MAAM,aAAa,CAAA;AAGpB,OAAO,EACL,eAAe,EACf,uBAAuB,EACvB,sBAAsB,EACtB,0BAA0B,EAC1B,kBAAkB,EAElB,iBAAiB,EACjB,WAAW,EACX,UAAU,EACV,kBAAkB,EAClB,oBAAoB,EACpB,qBAAqB,EACrB,iBAAiB,EACjB,mBAAmB,EACnB,YAAY,EACZ,cAAc,EACd,sBAAsB,EACvB,MAAM,eAAe,CAAA;AAGtB,OAAO,EACL,WAAW,EACX,cAAc,EACf,MAAM,WAAW,CAAA;AAGlB,OAAO,EACL,aAAa,EACb,gBAAgB,EACjB,MAAM,aAAa,CAAA"}

package/dist/src/server/types/prompt.d.ts

@@ -0,0 +1,14 @@
+import type { GetPromptResult } from '@modelcontextprotocol/sdk/types.js';
+import type { InputDefinition } from './common.js';
+export type PromptHandler = (params: Record<string, any>) => Promise<GetPromptResult>;
+export interface PromptDefinition {
+    /** Unique identifier for the prompt */
+    name: string;
+    /** Description of what the prompt does */
+    description?: string;
+    /** Argument definitions */
+    args?: InputDefinition[];
+    /** Async function that generates the prompt */
+    fn: PromptHandler;
+}
+//# sourceMappingURL=prompt.d.ts.map

package/dist/src/server/types/prompt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompt.d.ts","sourceRoot":"","sources":["../../../../src/server/types/prompt.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oCAAoC,CAAA;AACzE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAElD,MAAM,MAAM,aAAa,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,KAAK,OAAO,CAAC,eAAe,CAAC,CAAA;AAErF,MAAM,WAAW,gBAAgB;IAC/B,uCAAuC;IACvC,IAAI,EAAE,MAAM,CAAA;IACZ,0CAA0C;IAC1C,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,2BAA2B;IAC3B,IAAI,CAAC,EAAE,eAAe,EAAE,CAAA;IACxB,+CAA+C;IAC/C,EAAE,EAAE,aAAa,CAAA;CAClB"}

package/dist/src/server/types/resource.d.ts

@@ -0,0 +1,155 @@
+import type { ReadResourceResult } from '@modelcontextprotocol/sdk/types.js';
+import type { ResourceAnnotations } from './common.js';
+export type UIResourceContent = {
+    type: 'resource';
+    resource: {
+        uri: string;
+        mimeType: string;
+    } & ({
+        text: string;
+        blob?: never;
+    } | {
+        blob: string;
+        text?: never;
+    });
+};
+export type ResourceHandler = () => Promise<ReadResourceResult>;
+export type ResourceTemplateHandler = (uri: URL, params: Record<string, any>) => Promise<ReadResourceResult>;
+/**
+ * Configuration for a resource template
+ */
+export interface ResourceTemplateConfig {
+    /** URI template with {param} placeholders (e.g., "user://{userId}/profile") */
+    uriTemplate: string;
+    /** Name of the resource */
+    name?: string;
+    /** MIME type of the resource content */
+    mimeType?: string;
+    /** Description of the resource */
+    description?: string;
+}
+export interface ResourceTemplateDefinition {
+    name: string;
+    resourceTemplate: ResourceTemplateConfig;
+    title?: string;
+    description?: string;
+    annotations?: ResourceAnnotations;
+    fn: ResourceTemplateHandler;
+}
+export interface ResourceDefinition {
+    /** Unique identifier for the resource */
+    name: string;
+    /** URI pattern for accessing the resource (e.g., 'config://app-settings') */
+    uri: string;
+    /** Optional title for the resource */
+    title?: string;
+    /** Optional description of the resource */
+    description?: string;
+    /** MIME type of the resource content (required) */
+    mimeType: string;
+    /** Optional annotations for the resource */
+    annotations?: ResourceAnnotations;
+    /** Async function that returns the resource content */
+    fn: ResourceHandler;
+}
+/**
+ * UIResource-specific types
+ */
+export interface WidgetProps {
+    [key: string]: {
+        type: 'string' | 'number' | 'boolean' | 'object' | 'array';
+        required?: boolean;
+        default?: any;
+        description?: string;
+    };
+}
+/**
+ * Encoding options for UI resources
+ */
+export type UIEncoding = 'text' | 'blob';
+/**
+ * Framework options for Remote DOM resources
+ */
+export type RemoteDomFramework = 'react' | 'webcomponents';
+/**
+ * Base properties shared by all UI resource types
+ */
+interface BaseUIResourceDefinition {
+    /** Unique identifier for the resource */
+    name: string;
+    /** Human-readable title */
+    title?: string;
+    /** Description of what the widget does */
+    description?: string;
+    /** Widget properties/parameters configuration */
+    props?: WidgetProps;
+    /** Preferred frame size [width, height] (e.g., ['800px', '600px']) */
+    size?: [string, string];
+    /** Resource annotations for discovery and presentation */
+    annotations?: ResourceAnnotations;
+    /** Encoding for the resource content (defaults to 'text') */
+    encoding?: UIEncoding;
+}
+/**
+ * External URL UI resource - serves widget via iframe
+ */
+export interface ExternalUrlUIResource extends BaseUIResourceDefinition {
+    type: 'externalUrl';
+    /** Widget identifier (e.g., 'kanban-board', 'chart') */
+    widget: string;
+}
+/**
+ * Raw HTML UI resource - direct HTML content
+ */
+export interface RawHtmlUIResource extends BaseUIResourceDefinition {
+    type: 'rawHtml';
+    /** HTML content to render */
+    htmlContent: string;
+}
+/**
+ * Remote DOM UI resource - scripted UI components
+ */
+export interface RemoteDomUIResource extends BaseUIResourceDefinition {
+    type: 'remoteDom';
+    /** JavaScript code for remote DOM manipulation */
+    script: string;
+    /** Framework for remote DOM (defaults to 'react') */
+    framework?: RemoteDomFramework;
+}
+/**
+ * Discriminated union of all UI resource types
+ */
+export type UIResourceDefinition = ExternalUrlUIResource | RawHtmlUIResource | RemoteDomUIResource;
+export interface WidgetConfig {
+    /** Widget directory name */
+    name: string;
+    /** Absolute path to widget directory */
+    path: string;
+    /** Widget manifest if present */
+    manifest?: WidgetManifest;
+    /** Main component file name */
+    component?: string;
+}
+export interface WidgetManifest {
+    name: string;
+    title?: string;
+    description?: string;
+    version?: string;
+    props?: WidgetProps;
+    size?: [string, string];
+    assets?: {
+        main?: string;
+        scripts?: string[];
+        styles?: string[];
+    };
+}
+export interface DiscoverWidgetsOptions {
+    /** Path to widgets directory (defaults to dist/resources/mcp-use/widgets) */
+    path?: string;
+    /** Automatically register widgets without manifests */
+    autoRegister?: boolean;
+    /** Filter widgets by name pattern */
+    filter?: string | RegExp;
+}
+export {};
+//# sourceMappingURL=resource.d.ts.map