mcp-use 1.2.5-dev.4 → 1.3.0-canary.0

package/dist/src/server/index.js

@@ -118,6 +118,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);
@@ -126,7 +269,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 {
     }
   }
@@ -184,7 +328,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) {
@@ -279,6 +426,47 @@ var McpServer = class {
     this.app.use("*", requestLogger);
     return new Proxy(this, {
       get(target, prop) {
+        if (prop === "use") {
+          return async (...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) {
+              await 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);
+                    }
+                  }
+                })
+              );
+              return target;
+            }
+            return target.app.use(...args);
+          };
+        }
         if (prop in target) {
           return target[prop];
         }
@@ -823,9 +1011,9 @@ var McpServer = class {
   async readBuildManifest() {
     try {
       const manifestPath = pathHelpers.join(
-        getCwd(),
+        isDeno ? "." : getCwd(),
         "dist",
-        ".mcp-use-manifest.json"
+        "mcp-use.json"
       );
       const content = await fsHelpers.readFileSync(manifestPath, "utf8");
       return JSON.parse(content);
@@ -845,13 +1033,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);
     }
   }
@@ -902,13 +1088,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) => {
@@ -924,16 +1118,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'
@@ -986,67 +1181,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;
@@ -1074,7 +1208,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}`
@@ -1107,7 +1245,6 @@ if (container && Component) {
           error
         );
       }
-      console.log("[WIDGET dev] Metadata:", metadata);
       let html = "";
       try {
         html = await fsHelpers.readFileSync(
@@ -1214,27 +1351,57 @@ 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(
+      isDeno ? "." : getCwd(),
+      "dist",
+      "resources",
+      "widgets"
+    );
+    console.log("widgetsDir", widgetsDir);
+    this.setupWidgetRoutes();
+    const manifestPath = "./dist/mcp-use.json";
+    let widgets = [];
+    let widgetsMetadata = {};
+    try {
+      const manifestContent = await fsHelpers.readFileSync(
+        manifestPath,
+        "utf8"
+      );
+      const manifest = JSON.parse(manifestContent);
+      if (manifest.widgets && typeof manifest.widgets === "object" && !Array.isArray(manifest.widgets)) {
+        widgets = Object.keys(manifest.widgets);
+        widgetsMetadata = manifest.widgets;
+        console.log(
+          `[WIDGETS] Loaded ${widgets.length} widget(s) from manifest`
+        );
+      } else if (manifest.widgets && Array.isArray(manifest.widgets)) {
+        widgets = manifest.widgets;
+        console.log(
+          `[WIDGETS] Loaded ${widgets.length} widget(s) from manifest (legacy format)`
+        );
+      } else {
+        console.log("[WIDGETS] No widgets 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/"
-      );
+      console.log("[WIDGETS] No built widgets found");
       return;
     }
     console.log(
@@ -1243,7 +1410,6 @@ if (container && Component) {
     for (const widgetName of widgets) {
       const widgetPath = pathHelpers.join(widgetsDir, widgetName);
       const indexPath = pathHelpers.join(widgetPath, "index.html");
-      const metadataPath = pathHelpers.join(widgetPath, "metadata.json");
       let html = "";
       try {
         html = await fsHelpers.readFileSync(indexPath, "utf8");
@@ -1290,22 +1456,14 @@ if (container && Component) {
         );
         continue;
       }
-      let metadata = {};
+      const metadata = widgetsMetadata[widgetName] || {};
       let props = {};
       let description = `Widget: ${widgetName}`;
-      try {
-        const metadataContent = await fsHelpers.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`
-        );
+      if (metadata.description) {
+        description = metadata.description;
+      }
+      if (metadata.inputs) {
+        props = metadata.inputs;
       }
       this.uiResource({
         name: widgetName,
@@ -1462,23 +1620,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);
@@ -1579,16 +1741,53 @@ if (container && Component) {
     await this.mountMcp();
     await this.mountInspector();
     if (isDeno) {
+      const corsHeaders = {
+        "Access-Control-Allow-Origin": "*",
+        "Access-Control-Allow-Headers": "authorization, x-client-info, apikey, content-type"
+      };
       globalThis.Deno.serve(
         { port: this.serverPort, hostname: this.serverHost },
-        this.app.fetch
-      );
-      console.log(
-        `[SERVER] Listening on http://${this.serverHost}:${this.serverPort}`
-      );
-      console.log(
-        `[MCP] Endpoints: http://${this.serverHost}:${this.serverPort}/mcp`
+        async (req) => {
+          if (req.method === "OPTIONS") {
+            return new Response("ok", { headers: corsHeaders });
+          }
+          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] || "/";
+            }
+          }
+          let finalReq = req;
+          if (newPathname !== pathname) {
+            const newUrl = new URL(newPathname + url.search, url.origin);
+            finalReq = new Request(newUrl, {
+              method: req.method,
+              headers: req.headers,
+              body: req.body,
+              redirect: req.redirect
+            });
+          }
+          const response = await this.app.fetch(finalReq);
+          const newHeaders = new Headers(response.headers);
+          Object.entries(corsHeaders).forEach(([key, value]) => {
+            newHeaders.set(key, value);
+          });
+          return new Response(response.body, {
+            status: response.status,
+            statusText: response.statusText,
+            headers: newHeaders
+          });
+        }
       );
+      console.log(`[SERVER] Listening`);
     } else {
       const { serve } = await import("@hono/node-server");
       serve(
@@ -1642,19 +1841,26 @@ if (container && Component) {
    * ```
    */
   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\/[^/]+(\/.*)?$/);
+        const functionsMatch = pathname.match(
+          /^\/functions\/v1\/[^/]+(\/.*)?$/
+        );
         if (functionsMatch) {
           newPathname = functionsMatch[1] || "/";
         } else {
@@ -1773,11 +1979,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();
@@ -2015,10 +2231,13 @@ function createMCPServer(name, config = {}) {
 }
 __name(createMCPServer, "createMCPServer");
 export {
+  adaptConnectMiddleware,
+  adaptMiddleware,
   buildWidgetUrl,
   createExternalUrlResource,
   createMCPServer,
   createRawHtmlResource,
   createRemoteDomResource,
-  createUIResourceFromDefinition
+  createUIResourceFromDefinition,
+  isExpressMiddleware
 };

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

@@ -1 +1 @@
-{"version":3,"file":"logging.d.ts","sourceRoot":"","sources":["../../../src/server/logging.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAE1C;;;;;;;;;;;GAWG;AACH,wBAAsB,aAAa,CAAC,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAuCzE"}
+{"version":3,"file":"logging.d.ts","sourceRoot":"","sources":["../../../src/server/logging.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAE1C;;;;;;;;;;;GAWG;AACH,wBAAsB,aAAa,CAAC,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CA2CzE"}

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

@@ -416,7 +416,7 @@ export declare class McpServer {
      * ```
      */
     getHandler(options?: {
-        provider?: 'supabase' | 'cloudflare' | 'deno-deploy';
+        provider?: "supabase" | "cloudflare" | "deno-deploy";
     }): Promise<(req: Request) => Promise<Response>>;
     /**
      * Mount MCP Inspector UI at /inspector
@@ -557,7 +557,7 @@ export declare class McpServer {
 }
 export type McpServerInstance = Omit<McpServer, keyof HonoType> & HonoType & {
     getHandler: (options?: {
-        provider?: 'supabase' | 'cloudflare' | 'deno-deploy';
+        provider?: "supabase" | "cloudflare" | "deno-deploy";
     }) => Promise<(req: Request) => Promise<Response>>;
 };
 /**