mcp-use 1.2.5-dev.3 → 1.2.5-dev.5

package/dist/src/server/connect-adapter.d.ts

@@ -0,0 +1,31 @@
+import type { MiddlewareHandler } from "hono";
+/**
+ * Detects if a middleware is Express/Connect style or Hono style
+ *
+ * Express/Connect middleware: (req, res, next) => void or (err, req, res, next) => void
+ * Hono middleware: (c, next) => Promise<Response | void> or (c, next) => Response | void
+ *
+ * @param middleware - The middleware function to check
+ * @returns true if it's Express/Connect middleware, false if it's Hono middleware
+ */
+export declare function isExpressMiddleware(middleware: any): boolean;
+/**
+ * Automatically adapts middleware to work with Hono
+ * Detects if the middleware is Express/Connect style and adapts it accordingly
+ * If it's already Hono-compatible middleware, returns it as-is
+ *
+ * @param middleware - The middleware function (Express/Connect or Hono)
+ * @param middlewarePath - The path pattern the middleware is mounted at (optional, only used for Express/Connect middleware)
+ * @returns A Hono middleware function
+ */
+export declare function adaptMiddleware(middleware: any, middlewarePath?: string): Promise<MiddlewareHandler>;
+/**
+ * Adapts Connect/Express middleware to work with Hono
+ * Based on @hono/connect approach using node-mocks-http
+ *
+ * @param connectMiddleware - The Connect middleware handler
+ * @param middlewarePath - The path pattern the middleware is mounted at (e.g., "/mcp-use/widgets/*")
+ * @returns A Hono middleware function
+ */
+export declare function adaptConnectMiddleware(connectMiddleware: any, middlewarePath: string): Promise<MiddlewareHandler>;
+//# sourceMappingURL=connect-adapter.d.ts.map

package/dist/src/server/connect-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connect-adapter.d.ts","sourceRoot":"","sources":["../../../src/server/connect-adapter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAW,iBAAiB,EAAQ,MAAM,MAAM,CAAC;AAE7D;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,GAAG,GAAG,OAAO,CA0C5D;AAED;;;;;;;;GAQG;AACH,wBAAsB,eAAe,CACnC,UAAU,EAAE,GAAG,EACf,cAAc,GAAE,MAAY,GAC3B,OAAO,CAAC,iBAAiB,CAAC,CAQ5B;AAED;;;;;;;GAOG;AACH,wBAAsB,sBAAsB,CAC1C,iBAAiB,EAAE,GAAG,EACtB,cAAc,EAAE,MAAM,GACrB,OAAO,CAAC,iBAAiB,CAAC,CAqJ5B"}

package/dist/src/server/index.cjs

@@ -31,12 +31,15 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/server/index.ts
 var server_exports = {};
 __export(server_exports, {
+  adaptConnectMiddleware: () => adaptConnectMiddleware,
+  adaptMiddleware: () => adaptMiddleware,
   buildWidgetUrl: () => buildWidgetUrl,
   createExternalUrlResource: () => createExternalUrlResource,
   createMCPServer: () => createMCPServer,
   createRawHtmlResource: () => createRawHtmlResource,
   createRemoteDomResource: () => createRemoteDomResource,
-  createUIResourceFromDefinition: () => createUIResourceFromDefinition
+  createUIResourceFromDefinition: () => createUIResourceFromDefinition,
+  isExpressMiddleware: () => isExpressMiddleware
 });
 module.exports = __toCommonJS(server_exports);
 
@@ -153,6 +156,149 @@ function createUIResourceFromDefinition(definition, params, config) {
 }
 __name(createUIResourceFromDefinition, "createUIResourceFromDefinition");
 
+// src/server/connect-adapter.ts
+function isExpressMiddleware(middleware) {
+  if (!middleware || typeof middleware !== "function") {
+    return false;
+  }
+  const paramCount = middleware.length;
+  if (paramCount === 3 || paramCount === 4) {
+    return true;
+  }
+  if (paramCount === 2) {
+    const fnString = middleware.toString();
+    const expressPatterns = [
+      /\bres\.(send|json|status|end|redirect|render|sendFile|download)\b/,
+      /\breq\.(body|params|query|cookies|session)\b/,
+      /\breq\.get\s*\(/,
+      /\bres\.set\s*\(/
+    ];
+    const hasExpressPattern = expressPatterns.some(
+      (pattern) => pattern.test(fnString)
+    );
+    if (hasExpressPattern) {
+      return true;
+    }
+    return false;
+  }
+  return false;
+}
+__name(isExpressMiddleware, "isExpressMiddleware");
+async function adaptMiddleware(middleware, middlewarePath = "*") {
+  if (isExpressMiddleware(middleware)) {
+    return adaptConnectMiddleware(middleware, middlewarePath);
+  }
+  return middleware;
+}
+__name(adaptMiddleware, "adaptMiddleware");
+async function adaptConnectMiddleware(connectMiddleware, middlewarePath) {
+  let createRequest;
+  let createResponse;
+  try {
+    const httpMocks = await import("node-mocks-http");
+    createRequest = httpMocks.createRequest;
+    createResponse = httpMocks.createResponse;
+  } catch (error) {
+    console.error(
+      "[WIDGETS] node-mocks-http not available. Install connect and node-mocks-http for Vite middleware support."
+    );
+    throw error;
+  }
+  let normalizedPath = middlewarePath;
+  if (normalizedPath.endsWith("*")) {
+    normalizedPath = normalizedPath.slice(0, -1);
+  }
+  if (normalizedPath.endsWith("/")) {
+    normalizedPath = normalizedPath.slice(0, -1);
+  }
+  const honoMiddleware = /* @__PURE__ */ __name(async (c, next) => {
+    const request = c.req.raw;
+    const parsedURL = new URL(request.url, "http://localhost");
+    const query = {};
+    for (const [key, value] of parsedURL.searchParams.entries()) {
+      query[key] = value;
+    }
+    let middlewarePathname = parsedURL.pathname;
+    if (normalizedPath && middlewarePathname.startsWith(normalizedPath)) {
+      middlewarePathname = middlewarePathname.substring(normalizedPath.length);
+      if (middlewarePathname === "") {
+        middlewarePathname = "/";
+      } else if (!middlewarePathname.startsWith("/")) {
+        middlewarePathname = "/" + middlewarePathname;
+      }
+    }
+    const mockRequest = createRequest({
+      method: request.method.toUpperCase(),
+      url: middlewarePathname + parsedURL.search,
+      headers: Object.fromEntries(request.headers.entries()),
+      query,
+      ...request.body && { body: request.body }
+    });
+    const mockResponse = createResponse();
+    let responseResolved = false;
+    const res = await new Promise((resolve) => {
+      const originalEnd = mockResponse.end.bind(mockResponse);
+      mockResponse.end = (...args) => {
+        const result = originalEnd(...args);
+        if (!responseResolved && mockResponse.writableEnded) {
+          responseResolved = true;
+          const statusCode = mockResponse.statusCode;
+          const noBodyStatuses = [204, 304];
+          const responseBody = noBodyStatuses.includes(statusCode) ? null : mockResponse._getData() || mockResponse._getBuffer() || null;
+          const connectResponse = new Response(responseBody, {
+            status: statusCode,
+            statusText: mockResponse.statusMessage,
+            headers: mockResponse.getHeaders()
+          });
+          resolve(connectResponse);
+        }
+        return result;
+      };
+      connectMiddleware(mockRequest, mockResponse, () => {
+        if (!responseResolved && !mockResponse.writableEnded) {
+          responseResolved = true;
+          const statusCode = mockResponse.statusCode;
+          const noBodyStatuses = [204, 304];
+          const responseBody = noBodyStatuses.includes(statusCode) ? null : mockResponse._getData() || mockResponse._getBuffer() || null;
+          const preparedHeaders = c.newResponse(null, 204, {}).headers;
+          for (const key of [...preparedHeaders.keys()]) {
+            if (preparedHeaders.has(key)) {
+              c.header(key, void 0);
+            }
+            if (c.res && c.res.headers.has(key)) {
+              c.res.headers.delete(key);
+            }
+          }
+          const connectHeaders = mockResponse.getHeaders();
+          for (const [key, value] of Object.entries(connectHeaders)) {
+            if (value !== void 0) {
+              c.header(
+                key,
+                Array.isArray(value) ? value.join(", ") : String(value)
+              );
+            }
+          }
+          c.status(statusCode);
+          if (noBodyStatuses.includes(statusCode)) {
+            resolve(c.newResponse(null, statusCode));
+          } else if (responseBody) {
+            resolve(c.body(responseBody));
+          } else {
+            resolve(void 0);
+          }
+        }
+      });
+    });
+    if (res) {
+      c.res = res;
+      return res;
+    }
+    await next();
+  }, "honoMiddleware");
+  return honoMiddleware;
+}
+__name(adaptConnectMiddleware, "adaptConnectMiddleware");
+
 // src/server/logging.ts
 async function requestLogger(c, next) {
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().substring(11, 23);
@@ -161,7 +307,8 @@ async function requestLogger(c, next) {
   let body = null;
   if (method === "POST" && url.includes("/mcp")) {
     try {
-      body = await c.req.json().catch(() => null);
+      const clonedRequest = c.req.raw.clone();
+      body = await clonedRequest.json().catch(() => null);
     } catch {
     }
   }
@@ -219,7 +366,10 @@ var fsHelpers = {
     }
     const { readFileSync } = await import("fs");
     const buffer = readFileSync(path);
-    return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
+    return buffer.buffer.slice(
+      buffer.byteOffset,
+      buffer.byteOffset + buffer.byteLength
+    );
   },
   async existsSync(path) {
     if (isDeno) {
@@ -314,6 +464,52 @@ var McpServer = class {
     this.app.use("*", requestLogger);
     return new Proxy(this, {
       get(target, prop) {
+        if (prop === "use") {
+          return (...args) => {
+            const hasPath = typeof args[0] === "string";
+            const path = hasPath ? args[0] : "*";
+            const handlers = hasPath ? args.slice(1) : args;
+            const adaptedHandlers = handlers.map((handler) => {
+              if (isExpressMiddleware(handler)) {
+                return { __isExpressMiddleware: true, handler, path };
+              }
+              return handler;
+            });
+            const hasExpressMiddleware = adaptedHandlers.some(
+              (h) => h.__isExpressMiddleware
+            );
+            if (hasExpressMiddleware) {
+              Promise.all(
+                adaptedHandlers.map(async (h) => {
+                  if (h.__isExpressMiddleware) {
+                    const adapted = await adaptConnectMiddleware(
+                      h.handler,
+                      h.path
+                    );
+                    if (hasPath) {
+                      target.app.use(path, adapted);
+                    } else {
+                      target.app.use(adapted);
+                    }
+                  } else {
+                    if (hasPath) {
+                      target.app.use(path, h);
+                    } else {
+                      target.app.use(h);
+                    }
+                  }
+                })
+              ).catch((err) => {
+                console.error(
+                  "[MIDDLEWARE] Failed to adapt Express middleware:",
+                  err
+                );
+              });
+              return target;
+            }
+            return target.app.use(...args);
+          };
+        }
         if (prop in target) {
           return target[prop];
         }
@@ -880,13 +1076,11 @@ var McpServer = class {
    * @returns Promise that resolves when all widgets are mounted
    */
   async mountWidgets(options) {
-    if (this.isProductionMode()) {
+    if (this.isProductionMode() || isDeno) {
+      console.log("[WIDGETS] Mounting widgets in production mode");
       await this.mountWidgetsProduction(options);
     } else {
-      if (isDeno) {
-        console.log("[WIDGETS] Skipping dev mode widget mounting in Deno runtime (use production build)");
-        return;
-      }
+      console.log("[WIDGETS] Mounting widgets in development mode");
       await this.mountWidgetsDev(options);
     }
   }
@@ -937,13 +1131,21 @@ var McpServer = class {
     try {
       const viteModule = await new Function('return import("vite")')();
       createServer = viteModule.createServer;
-      const reactModule = await new Function('return import("@vitejs/plugin-react")')();
+      const reactModule = await new Function(
+        'return import("@vitejs/plugin-react")'
+      )();
       react = reactModule.default;
-      const tailwindModule = await new Function('return import("@tailwindcss/vite")')();
+      const tailwindModule = await new Function(
+        'return import("@tailwindcss/vite")'
+      )();
       tailwindcss = tailwindModule.default;
     } catch (error) {
-      console.error("[WIDGETS] Dev dependencies not available. Install vite, @vitejs/plugin-react, and @tailwindcss/vite for widget development.");
-      console.error("[WIDGETS] For production, use 'mcp-use build' to pre-build widgets.");
+      console.error(
+        "[WIDGETS] Dev dependencies not available. Install vite, @vitejs/plugin-react, and @tailwindcss/vite for widget development."
+      );
+      console.error(
+        "[WIDGETS] For production, use 'mcp-use build' to pre-build widgets."
+      );
       return;
     }
     const widgets = entries.map((entry) => {
@@ -959,16 +1161,17 @@ var McpServer = class {
       const widgetTempDir = pathHelpers.join(tempDir, widget.name);
       await fs.mkdir(widgetTempDir, { recursive: true });
       const resourcesPath = pathHelpers.join(getCwd(), resourcesDir);
-      const relativeResourcesPath = pathHelpers.relative(
-        widgetTempDir,
-        resourcesPath
-      ).replace(/\\/g, "/");
+      const relativeResourcesPath = pathHelpers.relative(widgetTempDir, resourcesPath).replace(/\\/g, "/");
       const cssContent = `@import "tailwindcss";
 
 /* Configure Tailwind to scan the resources directory */
 @source "${relativeResourcesPath}";
 `;
-      await fs.writeFile(pathHelpers.join(widgetTempDir, "styles.css"), cssContent, "utf8");
+      await fs.writeFile(
+        pathHelpers.join(widgetTempDir, "styles.css"),
+        cssContent,
+        "utf8"
+      );
       const entryContent = `import React from 'react'
 import { createRoot } from 'react-dom/client'
 import './styles.css'
@@ -1021,67 +1224,6 @@ if (container && Component) {
         origin: serverOrigin
       }
     });
-    const adaptExpressMiddleware = /* @__PURE__ */ __name((middleware) => {
-      return async (c, next) => {
-        const req = c.req.raw;
-        let handled = false;
-        const responseBody = [];
-        let statusCode = 200;
-        const headers = {};
-        const res = {
-          statusCode: 200,
-          status: /* @__PURE__ */ __name((code) => {
-            statusCode = code;
-            res.statusCode = code;
-            return res;
-          }, "status"),
-          setHeader: /* @__PURE__ */ __name((name, value) => {
-            headers[name] = value;
-          }, "setHeader"),
-          getHeader: /* @__PURE__ */ __name((name) => headers[name], "getHeader"),
-          write: /* @__PURE__ */ __name((chunk) => {
-            responseBody.push(typeof chunk === "string" ? new TextEncoder().encode(chunk) : chunk);
-          }, "write"),
-          end: /* @__PURE__ */ __name((chunk) => {
-            if (chunk) {
-              responseBody.push(typeof chunk === "string" ? new TextEncoder().encode(chunk) : chunk);
-            }
-            handled = true;
-          }, "end"),
-          on: /* @__PURE__ */ __name(() => {
-          }, "on"),
-          once: /* @__PURE__ */ __name(() => {
-          }, "once"),
-          removeListener: /* @__PURE__ */ __name(() => {
-          }, "removeListener")
-        };
-        const expressReq = {
-          ...req,
-          url: new URL(req.url).pathname + new URL(req.url).search,
-          originalUrl: req.url,
-          baseUrl: "",
-          path: new URL(req.url).pathname,
-          query: Object.fromEntries(new URL(req.url).searchParams),
-          params: {},
-          body: {},
-          headers: Object.fromEntries(req.headers.entries())
-        };
-        await new Promise((resolve, reject) => {
-          middleware(expressReq, res, (err) => {
-            if (err) reject(err);
-            else resolve();
-          });
-        });
-        if (handled) {
-          const body = Buffer.concat(responseBody);
-          return new Response(body, {
-            status: statusCode,
-            headers
-          });
-        }
-        return next();
-      };
-    }, "adaptExpressMiddleware");
     this.app.use(`${baseRoute}/*`, async (c, next) => {
       const url = new URL(c.req.url);
       const pathname = url.pathname;
@@ -1109,7 +1251,11 @@ if (container && Component) {
       }
       await next();
     });
-    this.app.use(`${baseRoute}/*`, adaptExpressMiddleware(viteServer.middlewares));
+    const viteMiddleware = await adaptConnectMiddleware(
+      viteServer.middlewares,
+      `${baseRoute}/*`
+    );
+    this.app.use(`${baseRoute}/*`, viteMiddleware);
     widgets.forEach((widget) => {
       console.log(
         `[WIDGET] ${widget.name} mounted at ${baseRoute}/${widget.name}`
@@ -1249,26 +1395,46 @@ if (container && Component) {
    */
   async mountWidgetsProduction(options) {
     const baseRoute = options?.baseRoute || "/mcp-use/widgets";
-    const widgetsDir = pathHelpers.join(getCwd(), "dist", "resources", "widgets");
-    if (!await fsHelpers.existsSync(widgetsDir)) {
+    const widgetsDir = pathHelpers.join(
+      getCwd(),
+      "dist",
+      "resources",
+      "widgets"
+    );
+    console.log("widgetsDir", widgetsDir);
+    this.setupWidgetRoutes();
+    const manifestPath = pathHelpers.join(getCwd(), "dist", ".mcp-use-manifest.json");
+    let widgets = [];
+    try {
+      const manifestContent = await fsHelpers.readFileSync(manifestPath, "utf8");
+      const manifest = JSON.parse(manifestContent);
+      if (manifest.widgets && Array.isArray(manifest.widgets)) {
+        widgets = manifest.widgets;
+        console.log(`[WIDGETS] Loaded ${widgets.length} widget(s) from manifest`);
+      } else {
+        console.log("[WIDGETS] No widgets array found in manifest");
+      }
+    } catch (error) {
       console.log(
-        "[WIDGETS] No dist/resources/widgets/ directory found - skipping widget serving"
+        "[WIDGETS] Could not read manifest file, falling back to directory listing:",
+        error
       );
-      return;
-    }
-    this.setupWidgetRoutes();
-    const allEntries = await fsHelpers.readdirSync(widgetsDir);
-    const widgets = [];
-    for (const name of allEntries) {
-      const widgetPath = pathHelpers.join(widgetsDir, name);
-      const indexPath = pathHelpers.join(widgetPath, "index.html");
-      if (await fsHelpers.existsSync(indexPath)) {
-        widgets.push(name);
+      try {
+        const allEntries = await fsHelpers.readdirSync(widgetsDir);
+        for (const name of allEntries) {
+          const widgetPath = pathHelpers.join(widgetsDir, name);
+          const indexPath = pathHelpers.join(widgetPath, "index.html");
+          if (await fsHelpers.existsSync(indexPath)) {
+            widgets.push(name);
+          }
+        }
+      } catch (dirError) {
+        console.log("[WIDGETS] Directory listing also failed:", dirError);
       }
     }
     if (widgets.length === 0) {
       console.log(
-        "[WIDGETS] No built widgets found in dist/resources/widgets/"
+        "[WIDGETS] No built widgets found"
       );
       return;
     }
@@ -1329,7 +1495,10 @@ if (container && Component) {
       let props = {};
       let description = `Widget: ${widgetName}`;
       try {
-        const metadataContent = await fsHelpers.readFileSync(metadataPath, "utf8");
+        const metadataContent = await fsHelpers.readFileSync(
+          metadataPath,
+          "utf8"
+        );
         metadata = JSON.parse(metadataContent);
         if (metadata.description) {
           description = metadata.description;
@@ -1497,23 +1666,27 @@ if (container && Component) {
           }
         }, "send")
       };
-      return { expressReq, expressRes, getResponse: /* @__PURE__ */ __name(() => {
-        if (ended) {
-          if (responseBody.length > 0) {
-            const body = isDeno ? Buffer.concat(responseBody) : Buffer.concat(responseBody);
-            return new Response(body, {
-              status: statusCode,
-              headers
-            });
-          } else {
-            return new Response(null, {
-              status: statusCode,
-              headers
-            });
+      return {
+        expressReq,
+        expressRes,
+        getResponse: /* @__PURE__ */ __name(() => {
+          if (ended) {
+            if (responseBody.length > 0) {
+              const body = isDeno ? Buffer.concat(responseBody) : Buffer.concat(responseBody);
+              return new Response(body, {
+                status: statusCode,
+                headers
+              });
+            } else {
+              return new Response(null, {
+                status: statusCode,
+                headers
+              });
+            }
           }
-        }
-        return null;
-      }, "getResponse") };
+          return null;
+        }, "getResponse")
+      };
     }, "createExpressLikeObjects");
     this.app.post(endpoint, async (c) => {
       const { expressReq, expressRes, getResponse } = createExpressLikeObjects(c);
@@ -1654,14 +1827,16 @@ if (container && Component) {
    * Unlike `listen()`, this method does not start a server - it only prepares the
    * routes and returns the handler function that can be used with external servers.
    *
+   * @param options - Optional configuration for the handler
+   * @param options.provider - Platform provider (e.g., 'supabase') to handle platform-specific path rewriting
    * @returns Promise that resolves to the fetch handler function
    *
    * @example
    * ```typescript
-   * // For Supabase Edge Functions
+   * // For Supabase Edge Functions (handles path rewriting automatically)
    * const server = createMCPServer('my-server');
    * server.tool({ ... });
-   * const handler = await server.getHandler();
+   * const handler = await server.getHandler({ provider: 'supabase' });
    * Deno.serve(handler);
    * ```
    *
@@ -1674,14 +1849,46 @@ if (container && Component) {
    * export default { fetch: handler };
    * ```
    */
-  async getHandler() {
+  async getHandler(options) {
+    console.log("[MCP] Mounting widgets");
     await this.mountWidgets({
       baseRoute: "/mcp-use/widgets",
       resourcesDir: "resources"
     });
+    console.log("[MCP] Mounted widgets");
     await this.mountMcp();
+    console.log("[MCP] Mounted MCP");
+    console.log("[MCP] Mounting inspector");
     await this.mountInspector();
+    console.log("[MCP] Mounted inspector");
     const fetchHandler = this.app.fetch.bind(this.app);
+    if (options?.provider === "supabase") {
+      return async (req) => {
+        const url = new URL(req.url);
+        const pathname = url.pathname;
+        let newPathname = pathname;
+        const functionsMatch = pathname.match(
+          /^\/functions\/v1\/[^/]+(\/.*)?$/
+        );
+        if (functionsMatch) {
+          newPathname = functionsMatch[1] || "/";
+        } else {
+          const functionNameMatch = pathname.match(/^\/([^/]+)(\/.*)?$/);
+          if (functionNameMatch && functionNameMatch[2]) {
+            newPathname = functionNameMatch[2] || "/";
+          }
+        }
+        const newUrl = new URL(newPathname + url.search, url.origin);
+        const newReq = new Request(newUrl, {
+          method: req.method,
+          headers: req.headers,
+          body: req.body,
+          redirect: req.redirect
+        });
+        const result = await fetchHandler(newReq);
+        return result;
+      };
+    }
     return async (req) => {
       const result = await fetchHandler(req);
       return result;
@@ -1781,11 +1988,21 @@ if (container && Component) {
     });
     this.app.get("/mcp-use/widgets/assets/*", async (c) => {
       const assetFile = c.req.path.split("/assets/")[1];
-      const widgetsDir = pathHelpers.join(getCwd(), "dist", "resources", "widgets");
+      const widgetsDir = pathHelpers.join(
+        getCwd(),
+        "dist",
+        "resources",
+        "widgets"
+      );
       try {
         const widgets = await fsHelpers.readdirSync(widgetsDir);
         for (const widget of widgets) {
-          const assetPath = pathHelpers.join(widgetsDir, widget, "assets", assetFile);
+          const assetPath = pathHelpers.join(
+            widgetsDir,
+            widget,
+            "assets",
+            assetFile
+          );
           if (await fsHelpers.existsSync(assetPath)) {
             const content = await fsHelpers.readFile(assetPath);
             const ext = assetFile.split(".").pop()?.toLowerCase();

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

@@ -1,5 +1,6 @@
 export { createMCPServer, type McpServerInstance } from "./mcp-server.js";
 export * from "./types/index.js";
 export { buildWidgetUrl, createExternalUrlResource, createRawHtmlResource, createRemoteDomResource, createUIResourceFromDefinition, type UrlConfig, } from "./adapters/mcp-ui-adapter.js";
-export type { InputDefinition, PromptDefinition, PromptCallback, ResourceDefinition, ReadResourceCallback, ReadResourceTemplateCallback, ServerConfig, ToolDefinition, ToolCallback, UIResourceDefinition, ExternalUrlUIResource, RawHtmlUIResource, RemoteDomUIResource, WidgetProps, WidgetConfig, WidgetManifest, DiscoverWidgetsOptions, } from "./types/index.js";
+export { adaptConnectMiddleware, adaptMiddleware, isExpressMiddleware, } from "./connect-adapter.js";
+export type { DiscoverWidgetsOptions, ExternalUrlUIResource, InputDefinition, PromptCallback, PromptDefinition, RawHtmlUIResource, ReadResourceCallback, ReadResourceTemplateCallback, RemoteDomUIResource, ResourceDefinition, ServerConfig, ToolCallback, ToolDefinition, UIResourceDefinition, WidgetConfig, WidgetManifest, WidgetProps, } from "./types/index.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/server/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,KAAK,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAE1E,cAAc,kBAAkB,CAAC;AAGjC,OAAO,EACL,cAAc,EACd,yBAAyB,EACzB,qBAAqB,EACrB,uBAAuB,EACvB,8BAA8B,EAC9B,KAAK,SAAS,GACf,MAAM,8BAA8B,CAAC;AAEtC,YAAY,EACV,eAAe,EACf,gBAAgB,EAChB,cAAc,EACd,kBAAkB,EAClB,oBAAoB,EACpB,4BAA4B,EAC5B,YAAY,EACZ,cAAc,EACd,YAAY,EAEZ,oBAAoB,EACpB,qBAAqB,EACrB,iBAAiB,EACjB,mBAAmB,EACnB,WAAW,EACX,YAAY,EACZ,cAAc,EACd,sBAAsB,GACvB,MAAM,kBAAkB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/server/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,KAAK,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAE1E,cAAc,kBAAkB,CAAC;AAGjC,OAAO,EACL,cAAc,EACd,yBAAyB,EACzB,qBAAqB,EACrB,uBAAuB,EACvB,8BAA8B,EAC9B,KAAK,SAAS,GACf,MAAM,8BAA8B,CAAC;AAGtC,OAAO,EACL,sBAAsB,EACtB,eAAe,EACf,mBAAmB,GACpB,MAAM,sBAAsB,CAAC;AAE9B,YAAY,EACV,sBAAsB,EACtB,qBAAqB,EACrB,eAAe,EACf,cAAc,EACd,gBAAgB,EAChB,iBAAiB,EACjB,oBAAoB,EACpB,4BAA4B,EAC5B,mBAAmB,EACnB,kBAAkB,EAClB,YAAY,EACZ,YAAY,EACZ,cAAc,EAEd,oBAAoB,EACpB,YAAY,EACZ,cAAc,EACd,WAAW,GACZ,MAAM,kBAAkB,CAAC"}