mcp-use 1.1.6 → 1.1.7

package/dist/src/server/index.js

@@ -9,6 +9,7 @@ import express from "express";
 import cors from "cors";
 import { existsSync, readdirSync } from "fs";
 import { join } from "path";
+import { readFileSync } from "fs";
 
 // src/server/logging.ts
 function requestLogger(req, res, next) {
@@ -47,13 +48,8 @@ function buildWidgetUrl(widget, props, config) {
     `/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);
-      }
-    });
+  if (props && Object.keys(props).length > 0) {
+    url.searchParams.set("props", JSON.stringify(props));
   }
   return url.toString();
 }
@@ -153,6 +149,8 @@ function createUIResourceFromDefinition(definition, params, config) {
 __name(createUIResourceFromDefinition, "createUIResourceFromDefinition");
 
 // src/server/mcp-server.ts
+import { createServer } from "vite";
+var TMP_MCP_USE_DIR = ".mcp-use";
 var McpServer = class {
   static {
     __name(this, "McpServer");
@@ -163,6 +161,8 @@ var McpServer = class {
   mcpMounted = false;
   inspectorMounted = false;
   serverPort;
+  serverHost;
+  serverBaseUrl;
   /**
    * Creates a new MCP server instance with Express integration
    *
@@ -175,6 +175,8 @@ var McpServer = class {
    */
   constructor(config) {
     this.config = config;
+    this.serverHost = config.host || "localhost";
+    this.serverBaseUrl = config.baseUrl;
     this.server = new OfficialMcpServer({
       name: config.name,
       version: config.version
@@ -187,7 +189,6 @@ var McpServer = class {
       allowedHeaders: ["Content-Type", "Accept", "Authorization", "mcp-protocol-version", "mcp-session-id", "X-Proxy-Token", "X-Target-URL"]
     }));
     this.app.use(requestLogger);
-    this.setupWidgetRoutes();
     return new Proxy(this, {
       get(target, prop) {
         if (prop in target) {
@@ -246,7 +247,8 @@ var McpServer = class {
         title: resourceDefinition.title,
         description: resourceDefinition.description,
         mimeType: resourceDefinition.mimeType,
-        annotations: resourceDefinition.annotations
+        annotations: resourceDefinition.annotations,
+        _meta: resourceDefinition._meta
       },
       async () => {
         return await resourceDefinition.readCallback();
@@ -365,7 +367,7 @@ var McpServer = class {
    * ```
    */
   tool(toolDefinition) {
-    const inputSchema = this.createToolInputSchema(toolDefinition.inputs || []);
+    const inputSchema = this.createParamsSchema(toolDefinition.inputs || []);
     this.server.registerTool(
       toolDefinition.name,
       {
@@ -416,7 +418,7 @@ var McpServer = class {
    * ```
    */
   prompt(promptDefinition) {
-    const argsSchema = this.createPromptArgsSchema(promptDefinition.args || []);
+    const argsSchema = this.createParamsSchema(promptDefinition.args || []);
     this.server.registerPrompt(
       promptDefinition.name,
       {
@@ -443,19 +445,22 @@ var McpServer = class {
    * - remoteDom: Legacy MCP-UI Remote DOM scripting
    * - appsSdk: OpenAI Apps SDK compatible widgets (text/html+skybridge)
    *
-   * @param definition - Configuration for the UI widget
+   * @param widgetNameOrDefinition - Widget name (string) for auto-loading schema, or full configuration object
    * @param definition.name - Unique identifier for the resource
    * @param definition.type - Type of UI resource (externalUrl, rawHtml, remoteDom, appsSdk)
    * @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.size - Preferred iframe size [width, height] (e.g., ['900px', '600px'])
    * @param definition.annotations - Resource annotations for discovery
    * @param definition.appsSdkMetadata - Apps SDK specific metadata (CSP, widget description, etc.)
    * @returns The server instance for method chaining
    *
    * @example
    * ```typescript
+   * // Simple usage - auto-loads from generated schema
+   * server.uiResource('display-weather')
+   * 
    * // Legacy MCP-UI widget
    * server.uiResource({
    *   type: 'externalUrl',
@@ -495,14 +500,6 @@ var McpServer = class {
    * ```
    */
   uiResource(definition) {
-    let toolName;
-    if (definition.type === "appsSdk") {
-      toolName = definition.name;
-    } else if (definition.type === "externalUrl") {
-      toolName = `ui_${definition.widget}`;
-    } else {
-      toolName = `ui_${definition.name}`;
-    }
     const displayName = definition.title || definition.name;
     let resourceUri;
     let mimeType;
@@ -532,6 +529,7 @@ var McpServer = class {
       title: definition.title,
       description: definition.description,
       mimeType,
+      _meta: definition._meta,
       annotations: definition.annotations,
       readCallback: /* @__PURE__ */ __name(async () => {
         const params = definition.type === "externalUrl" ? this.applyDefaultProps(definition.props) : {};
@@ -541,7 +539,28 @@ var McpServer = class {
         };
       }, "readCallback")
     });
-    const toolMetadata = {};
+    if (definition.type === "appsSdk") {
+      this.resourceTemplate({
+        name: `${definition.name}-dynamic`,
+        resourceTemplate: {
+          uriTemplate: `ui://widget/${definition.name}-{id}.html`,
+          name: definition.title || definition.name,
+          description: definition.description,
+          mimeType
+        },
+        _meta: definition._meta,
+        title: definition.title,
+        description: definition.description,
+        annotations: definition.annotations,
+        readCallback: /* @__PURE__ */ __name(async (uri, params) => {
+          const uiResource = this.createWidgetUIResource(definition, {});
+          return {
+            contents: [uiResource.resource]
+          };
+        }, "readCallback")
+      });
+    }
+    const toolMetadata = definition._meta || {};
     if (definition.type === "appsSdk" && definition.appsSdkMetadata) {
       toolMetadata["openai/outputTemplate"] = resourceUri;
       const toolMetadataFields = [
@@ -557,17 +576,19 @@ var McpServer = class {
       }
     }
     this.tool({
-      name: toolName,
+      name: definition.name,
       title: definition.title,
-      // For Apps SDK, use title as description to match OpenAI's pizzaz reference implementation
-      description: definition.type === "appsSdk" && definition.title ? definition.title : definition.description || `Display ${displayName}`,
+      description: definition.description,
       inputs: this.convertPropsToInputs(definition.props),
       _meta: Object.keys(toolMetadata).length > 0 ? toolMetadata : void 0,
       cb: /* @__PURE__ */ __name(async (params) => {
         const uiResource = this.createWidgetUIResource(definition, params);
         if (definition.type === "appsSdk") {
+          const randomId = Math.random().toString(36).substring(2, 15);
+          const uniqueUri = `ui://widget/${definition.name}-${randomId}.html`;
+          const uniqueToolMetadata = { ...toolMetadata, "openai/outputTemplate": uniqueUri };
           return {
-            _meta: toolMetadata,
+            _meta: uniqueToolMetadata,
             content: [
               {
                 type: "text",
@@ -605,9 +626,20 @@ var McpServer = class {
    * @returns UIResource object compatible with MCP-UI
    */
   createWidgetUIResource(definition, params) {
+    let configBaseUrl = `http://${this.serverHost}`;
+    let configPort = this.serverPort || 3001;
+    if (this.serverBaseUrl) {
+      try {
+        const url = new URL(this.serverBaseUrl);
+        configBaseUrl = `${url.protocol}//${url.hostname}`;
+        configPort = url.port || (url.protocol === "https:" ? 443 : 80);
+      } catch (e) {
+        console.warn("Failed to parse baseUrl, falling back to host:port", e);
+      }
+    }
     const urlConfig = {
-      baseUrl: "http://localhost",
-      port: this.serverPort || 3001
+      baseUrl: configBaseUrl,
+      port: configPort
     };
     return createUIResourceFromDefinition(definition, params, urlConfig);
   }
@@ -624,7 +656,7 @@ var McpServer = class {
    * @returns Complete URL with encoded parameters
    */
   buildWidgetUrl(widget, params) {
-    const baseUrl = `http://localhost:${this.serverPort}/mcp-use/widgets/${widget}`;
+    const baseUrl = `http://${this.serverHost}:${this.serverPort}/mcp-use/widgets/${widget}`;
     if (Object.keys(params).length === 0) {
       return baseUrl;
     }
@@ -680,6 +712,324 @@ var McpServer = class {
     }
     return defaults;
   }
+  /**
+   * Check if server is running in production mode
+   * 
+   * @private
+   * @returns true if in production mode, false otherwise
+   */
+  isProductionMode() {
+    return process.env.NODE_ENV === "production";
+  }
+  /**
+   * Read build manifest file
+   * 
+   * @private
+   * @returns Build manifest or null if not found
+   */
+  readBuildManifest() {
+    try {
+      const manifestPath = join(process.cwd(), "dist", ".mcp-use-manifest.json");
+      const content = readFileSync(manifestPath, "utf8");
+      return JSON.parse(content);
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Mount widget files - automatically chooses between dev and production mode
+   *
+   * In development mode: creates Vite dev servers with HMR support
+   * In production mode: serves pre-built static widgets
+   *
+   * @param options - Configuration options
+   * @param options.baseRoute - Base route for widgets (defaults to '/mcp-use/widgets')
+   * @param options.resourcesDir - Directory containing widget files (defaults to 'resources')
+   * @returns Promise that resolves when all widgets are mounted
+   */
+  async mountWidgets(options) {
+    if (this.isProductionMode()) {
+      await this.mountWidgetsProduction(options);
+    } else {
+      await this.mountWidgetsDev(options);
+    }
+  }
+  /**
+   * Mount individual widget files from resources/ directory in development mode
+   *
+   * Scans the resources/ directory for .tsx/.ts widget files and creates individual
+   * Vite dev servers for each widget with HMR support. Each widget is served at its
+   * own route: /mcp-use/widgets/{widget-name}
+   *
+   * @private
+   * @param options - Configuration options
+   * @param options.baseRoute - Base route for widgets (defaults to '/mcp-use/widgets')
+   * @param options.resourcesDir - Directory containing widget files (defaults to 'resources')
+   * @returns Promise that resolves when all widgets are mounted
+   */
+  async mountWidgetsDev(options) {
+    const { promises: fs } = await import("fs");
+    const baseRoute = options?.baseRoute || "/mcp-use/widgets";
+    const resourcesDir = options?.resourcesDir || "resources";
+    const srcDir = join(process.cwd(), resourcesDir);
+    try {
+      await fs.access(srcDir);
+    } catch (error) {
+      console.log(`[WIDGETS] No ${resourcesDir}/ directory found - skipping widget serving`);
+      return;
+    }
+    let entries = [];
+    try {
+      const files = await fs.readdir(srcDir);
+      entries = files.filter((f) => f.endsWith(".tsx") || f.endsWith(".ts")).map((f) => join(srcDir, f));
+    } catch (error) {
+      console.log(`[WIDGETS] No widgets found in ${resourcesDir}/ directory`);
+      return;
+    }
+    if (entries.length === 0) {
+      console.log(`[WIDGETS] No widgets found in ${resourcesDir}/ directory`);
+      return;
+    }
+    const tempDir = join(process.cwd(), TMP_MCP_USE_DIR);
+    await fs.mkdir(tempDir, { recursive: true }).catch(() => {
+    });
+    const react = (await import("@vitejs/plugin-react")).default;
+    const tailwindcss = (await import("@tailwindcss/vite")).default;
+    console.log(react, tailwindcss);
+    const widgets = entries.map((entry) => {
+      const baseName = entry.split("/").pop()?.replace(/\.tsx?$/, "") || "widget";
+      const widgetName = baseName;
+      return {
+        name: widgetName,
+        description: `Widget: ${widgetName}`,
+        entry
+      };
+    });
+    for (const widget of widgets) {
+      const widgetTempDir = join(tempDir, widget.name);
+      await fs.mkdir(widgetTempDir, { recursive: true });
+      const resourcesPath = join(process.cwd(), resourcesDir);
+      const { relative } = await import("path");
+      const relativeResourcesPath = relative(widgetTempDir, resourcesPath).replace(/\\/g, "/");
+      const cssContent = `@import "tailwindcss";
+
+/* Configure Tailwind to scan the resources directory */
+@source "${relativeResourcesPath}";
+`;
+      await fs.writeFile(join(widgetTempDir, "styles.css"), cssContent, "utf8");
+      const entryContent = `import React from 'react'
+import { createRoot } from 'react-dom/client'
+import './styles.css'
+import Component from '${widget.entry}'
+
+const container = document.getElementById('widget-root')
+if (container && Component) {
+  const root = createRoot(container)
+  root.render(<Component />)
+}
+`;
+      const htmlContent = `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width,initial-scale=1" />
+    <title>${widget.name} Widget</title>
+  </head>
+  <body>
+    <div id="widget-root"></div>
+    <script type="module" src="${baseRoute}/${widget.name}/entry.tsx"></script>
+  </body>
+</html>`;
+      await fs.writeFile(join(widgetTempDir, "entry.tsx"), entryContent, "utf8");
+      await fs.writeFile(join(widgetTempDir, "index.html"), htmlContent, "utf8");
+    }
+    const serverOrigin = this.serverBaseUrl || `http://${this.serverHost}:${this.serverPort}`;
+    console.log(`[WIDGETS] Serving ${entries.length} widget(s) with shared Vite dev server and HMR`);
+    const viteServer = await createServer({
+      root: tempDir,
+      base: baseRoute + "/",
+      plugins: [tailwindcss(), react()],
+      resolve: {
+        alias: {
+          "@": join(process.cwd(), resourcesDir)
+        }
+      },
+      server: {
+        middlewareMode: true,
+        origin: serverOrigin
+      }
+    });
+    this.app.use(baseRoute, (req, res, next) => {
+      const urlPath = req.url || "";
+      const [pathname, queryString] = urlPath.split("?");
+      const widgetMatch = pathname.match(/^\/([^/]+)/);
+      if (widgetMatch) {
+        const widgetName = widgetMatch[1];
+        const widget = widgets.find((w) => w.name === widgetName);
+        if (widget) {
+          if (pathname === `/${widgetName}` || pathname === `/${widgetName}/`) {
+            req.url = `/${widgetName}/index.html${queryString ? "?" + queryString : ""}`;
+          }
+        }
+      }
+      next();
+    });
+    this.app.use(baseRoute, viteServer.middlewares);
+    widgets.forEach((widget) => {
+      console.log(`[WIDGET] ${widget.name} mounted at ${baseRoute}/${widget.name}`);
+    });
+    for (const widget of widgets) {
+      const type = "appsSdk";
+      let widgetMetadata = {};
+      let props = {};
+      let description = widget.description;
+      try {
+        const mod = await viteServer.ssrLoadModule(widget.entry);
+        if (mod.widgetMetadata) {
+          widgetMetadata = mod.widgetMetadata;
+          description = widgetMetadata.description || widget.description;
+          if (widgetMetadata.inputs) {
+            try {
+              props = widgetMetadata.inputs.shape || {};
+            } catch (error) {
+              console.warn(`[WIDGET] Failed to extract props schema for ${widget.name}:`, error);
+            }
+          }
+        }
+      } catch (error) {
+        console.warn(`[WIDGET] Failed to load metadata for ${widget.name}:`, error);
+      }
+      let html = "";
+      try {
+        html = await readFileSync(join(tempDir, widget.name, "index.html"), "utf8");
+      } catch (error) {
+        console.error(`Failed to read html template for widget ${widget.name}`, error);
+      }
+      this.uiResource({
+        name: widget.name,
+        title: widget.name,
+        description,
+        type,
+        props,
+        _meta: {
+          "mcp-use/widget": {
+            name: widget.name,
+            description,
+            type,
+            props,
+            html,
+            dev: true
+          }
+        },
+        htmlTemplate: html,
+        appsSdkMetadata: {
+          "openai/widgetDescription": description,
+          "openai/toolInvocation/invoking": "Hand-tossing a map",
+          "openai/toolInvocation/invoked": "Served a fresh map",
+          "openai/widgetAccessible": true,
+          "openai/resultCanProduceWidget": true,
+          "openai/widgetCSP": {
+            connect_domains: [],
+            resource_domains: ["https://persistent.oaistatic.com"]
+          }
+        }
+      });
+    }
+  }
+  /**
+   * Mount pre-built widgets from dist/resources/widgets/ directory in production mode
+   *
+   * Serves static widget bundles that were built using the build command.
+   * Sets up Express routes to serve the HTML and asset files, then registers
+   * tools and resources for each widget.
+   *
+   * @private
+   * @param options - Configuration options
+   * @param options.baseRoute - Base route for widgets (defaults to '/mcp-use/widgets')
+   * @returns Promise that resolves when all widgets are mounted
+   */
+  async mountWidgetsProduction(options) {
+    const baseRoute = options?.baseRoute || "/mcp-use/widgets";
+    const widgetsDir = join(process.cwd(), "dist", "resources", "widgets");
+    if (!existsSync(widgetsDir)) {
+      console.log("[WIDGETS] No dist/resources/widgets/ directory found - skipping widget serving");
+      return;
+    }
+    this.setupWidgetRoutes();
+    const widgets = readdirSync(widgetsDir).filter((name) => {
+      const widgetPath = join(widgetsDir, name);
+      const indexPath = join(widgetPath, "index.html");
+      return existsSync(indexPath);
+    });
+    if (widgets.length === 0) {
+      console.log("[WIDGETS] No built widgets found in dist/resources/widgets/");
+      return;
+    }
+    console.log(`[WIDGETS] Serving ${widgets.length} pre-built widget(s) from dist/resources/widgets/`);
+    for (const widgetName of widgets) {
+      const widgetPath = join(widgetsDir, widgetName);
+      const indexPath = join(widgetPath, "index.html");
+      const metadataPath = join(widgetPath, "metadata.json");
+      let html = "";
+      try {
+        html = readFileSync(indexPath, "utf8");
+      } catch (error) {
+        console.error(`[WIDGET] Failed to read ${widgetName}/index.html:`, error);
+        continue;
+      }
+      let metadata = {};
+      let props = {};
+      let description = `Widget: ${widgetName}`;
+      try {
+        const metadataContent = readFileSync(metadataPath, "utf8");
+        metadata = JSON.parse(metadataContent);
+        if (metadata.description) {
+          description = metadata.description;
+        }
+        if (metadata.inputs) {
+          props = metadata.inputs;
+        }
+      } catch (error) {
+        console.log(`[WIDGET] No metadata found for ${widgetName}, using defaults`);
+      }
+      this.uiResource({
+        name: widgetName,
+        title: widgetName,
+        description,
+        type: "appsSdk",
+        props,
+        _meta: {
+          "mcp-use/widget": {
+            name: widgetName,
+            description,
+            type: "appsSdk",
+            props,
+            html,
+            dev: false
+          }
+        },
+        htmlTemplate: html,
+        appsSdkMetadata: {
+          "openai/widgetDescription": description,
+          "openai/toolInvocation/invoking": `Loading ${widgetName}...`,
+          "openai/toolInvocation/invoked": `${widgetName} ready`,
+          "openai/widgetAccessible": true,
+          "openai/resultCanProduceWidget": true,
+          "openai/widgetCSP": {
+            connect_domains: [],
+            resource_domains: [
+              "https://*.oaistatic.com",
+              "https://*.unsplash.com",
+              "https://*.oaiusercontent.com",
+              // always also add the base url of the server
+              ...this.serverBaseUrl ? [this.serverBaseUrl] : []
+            ]
+          }
+        }
+      });
+      console.log(`[WIDGET] ${widgetName} mounted at ${baseRoute}/${widgetName}`);
+    }
+  }
   /**
    * Mount MCP server endpoints at /mcp
    *
@@ -756,18 +1106,25 @@ var McpServer = class {
    * @example
    * ```typescript
    * await server.listen(8080)
-   * // Server now running at http://localhost:8080
+   * // Server now running at http://localhost:8080 (or configured host)
    * // MCP endpoints: http://localhost:8080/mcp
    * // Inspector UI: http://localhost:8080/inspector
    * ```
    */
   async listen(port) {
+    this.serverPort = port || (process.env.PORT ? parseInt(process.env.PORT, 10) : 3001);
+    if (process.env.HOST) {
+      this.serverHost = process.env.HOST;
+    }
+    await this.mountWidgets({
+      baseRoute: "/mcp-use/widgets",
+      resourcesDir: "resources"
+    });
     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`);
+      console.log(`[SERVER] Listening on http://${this.serverHost}:${this.serverPort}`);
+      console.log(`[MCP] Endpoints: http://${this.serverHost}:${this.serverPort}/mcp`);
     });
   }
   /**
@@ -794,10 +1151,17 @@ var McpServer = class {
    */
   mountInspector() {
     if (this.inspectorMounted) return;
+    if (this.isProductionMode()) {
+      const manifest = this.readBuildManifest();
+      if (!manifest?.includeInspector) {
+        console.log("[INSPECTOR] Skipped in production (use --with-inspector flag during build)");
+        return;
+      }
+    }
     import("@mcp-use/inspector").then(({ mountInspector }) => {
       mountInspector(this.app);
       this.inspectorMounted = true;
-      console.log(`[INSPECTOR] UI available at http://localhost:${this.serverPort}/inspector`);
+      console.log(`[INSPECTOR] UI available at http://${this.serverHost}:${this.serverPort}/inspector`);
     }).catch(() => {
     });
   }
@@ -805,7 +1169,7 @@ var McpServer = class {
    * 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
+   * Widgets are served from the dist/resources/widgets directory and can
    * be accessed via HTTP endpoints for embedding in web applications.
    *
    * Routes created:
@@ -826,12 +1190,12 @@ var McpServer = class {
     this.app.get("/mcp-use/widgets/:widget/assets/*", (req, res, next) => {
       const widget = req.params.widget;
       const assetFile = req.params[0];
-      const assetPath = join(process.cwd(), "dist", "resources", "mcp-use", "widgets", widget, "assets", assetFile);
+      const assetPath = join(process.cwd(), "dist", "resources", "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 = join(process.cwd(), "dist", "resources", "mcp-use", "widgets");
+      const widgetsDir = join(process.cwd(), "dist", "resources", "widgets");
       try {
         const widgets = readdirSync(widgetsDir);
         for (const widget of widgets) {
@@ -846,7 +1210,7 @@ var McpServer = class {
       }
     });
     this.app.get("/mcp-use/widgets/:widget", (req, res, next) => {
-      const filePath = join(process.cwd(), "dist", "resources", "mcp-use", "widgets", req.params.widget, "index.html");
+      const filePath = join(process.cwd(), "dist", "resources", "widgets", req.params.widget, "index.html");
       res.sendFile(filePath, (err) => err ? next() : void 0);
     });
   }
@@ -886,14 +1250,14 @@ var McpServer = class {
    *
    * @example
    * ```typescript
-   * const schema = this.createToolInputSchema([
-   *   { name: 'query', type: 'string', required: true },
+   * const schema = this.createParamsSchema([
+   *   { name: 'query', type: 'string', required: true, description: 'Search query' },
    *   { name: 'limit', type: 'number', required: false }
    * ])
-   * // Returns: { query: z.string(), limit: z.number().optional() }
+   * // Returns: { query: z.string().describe('Search query'), limit: z.number().optional() }
    * ```
    */
-  createToolInputSchema(inputs) {
+  createParamsSchema(inputs) {
     const schema = {};
     inputs.forEach((input) => {
       let zodType;
@@ -1033,7 +1397,9 @@ function createMCPServer(name, config = {}) {
   const instance = new McpServer({
     name,
     version: config.version || "1.0.0",
-    description: config.description
+    description: config.description,
+    host: config.host,
+    baseUrl: config.baseUrl
   });
   return instance;
 }