mcp-use 2.0.0-beta.28 → 2.0.0-beta.30

package/dist/index.js

@@ -29,10 +29,8 @@ import {
   originValidationMiddleware,
   pathUnderBase,
   pathnameOf,
-  requireBearerAuth,
-  routeFetch,
-  toFrameworkHandler
-} from "./chunk-26JBVQUY.js";
+  requireBearerAuth
+} from "./chunk-QKJJ6DWK.js";
 import {
   getOAuthProviderOptions,
   resolveConfiguredOAuthResource,
@@ -48,6 +46,7 @@ import {
   ResourceTemplate,
   isInputRequiredResult as isInputRequiredResult2
 } from "@modelcontextprotocol/server";
+import { Hono } from "hono";
 
 // src/branding.ts
 var FAVICON_CACHE_CONTROL = "public, max-age=31536000, immutable";
@@ -87,10 +86,10 @@ function parseDataImage(source, field) {
   }
   try {
     if (parts.includes("base64")) {
-      const binary = atob(payload);
+      const binary2 = atob(payload);
       return {
         mimeType,
-        bytes: Uint8Array.from(binary, (character) => character.charCodeAt(0))
+        bytes: Uint8Array.from(binary2, (character) => character.charCodeAt(0))
       };
     }
     return {
@@ -323,6 +322,7 @@ import {
   inputRequired,
   inputResponse
 } from "@modelcontextprotocol/server";
+import { HonoRequest } from "hono/request";
 
 // src/views/capabilities.ts
 import {
@@ -436,8 +436,10 @@ function createElicit(inputResponses) {
   };
 }
 function toRequestContext(ctx) {
-  const request = ctx.http?.req;
-  return {
+  const rawRequest = ctx.http?.req;
+  const http = rawRequest === void 0 ? void 0 : getRequestBag(rawRequest).honoContext;
+  const request = http?.req ?? (rawRequest === void 0 ? void 0 : new HonoRequest(rawRequest));
+  const additions = {
     signal: ctx.mcpReq.signal,
     ...request !== void 0 && { request },
     ...ctx.mcpReq.inputResponses !== void 0 && {
@@ -471,12 +473,18 @@ function toRequestContext(ctx) {
       });
     }
   };
+  if (http !== void 0) {
+    return Object.assign(http, additions);
+  }
+  return {
+    ...additions,
+    ...request !== void 0 && { req: request }
+  };
 }
 function toAuthenticatedRequestContext(ctx) {
   const authInfo = ctx.http?.authInfo;
   requireOAuthAuthInfo(authInfo);
-  return {
-    ...toRequestContext(ctx),
+  return Object.assign(toRequestContext(ctx), {
     auth: {
       user: authInfo.extra.user,
       payload: authInfo.extra.payload,
@@ -487,7 +495,84 @@ function toAuthenticatedRequestContext(ctx) {
       expiresAt: authInfo.expiresAt,
       ...authInfo.resource !== void 0 && { resource: authInfo.resource }
     }
-  };
+  });
+}
+
+// src/response-conversion.ts
+function isReadResourceResult(result) {
+  return "contents" in result && Array.isArray(result.contents);
+}
+function isGetPromptResult(result) {
+  return "messages" in result && Array.isArray(result.messages);
+}
+function toResourceResult(result, uri) {
+  if (isReadResourceResult(result)) {
+    return result;
+  }
+  const mime = result._meta && typeof result._meta === "object" && typeof result._meta.mimeType === "string" ? result._meta.mimeType : void 0;
+  const contents = [];
+  for (const block of result.content ?? []) {
+    const mapped = contentBlockToResourceContents(block, uri, mime);
+    if (mapped !== void 0) {
+      contents.push(mapped);
+    }
+  }
+  if (contents.length === 0 && result.structuredContent !== void 0) {
+    contents.push({
+      uri,
+      mimeType: "application/json",
+      text: JSON.stringify(result.structuredContent)
+    });
+  }
+  if (contents.length === 0) {
+    contents.push({ uri, mimeType: "text/plain", text: "" });
+  }
+  return { contents };
+}
+function contentBlockToResourceContents(block, uri, mimeHint) {
+  if (block.type === "text") {
+    return {
+      uri,
+      mimeType: mimeHint ?? "text/plain",
+      text: block.text
+    };
+  }
+  if (block.type === "image" || block.type === "audio") {
+    return {
+      uri,
+      mimeType: block.mimeType,
+      blob: block.data
+    };
+  }
+  if (block.type === "resource") {
+    return { ...block.resource };
+  }
+  return void 0;
+}
+function toPromptResult(result) {
+  if (isGetPromptResult(result)) {
+    return result;
+  }
+  const messages = (result.content ?? []).map((content) => ({
+    role: "user",
+    content
+  }));
+  if (messages.length === 0 && result.structuredContent !== void 0) {
+    messages.push({
+      role: "user",
+      content: {
+        type: "text",
+        text: JSON.stringify(result.structuredContent)
+      }
+    });
+  }
+  if (messages.length === 0) {
+    messages.push({
+      role: "user",
+      content: { type: "text", text: "" }
+    });
+  }
+  return { messages };
 }
 
 // src/middleware/cors.ts
@@ -677,7 +762,10 @@ function composeMiddleware(entries, method, innerFn) {
         return innerFn();
       }
       const entry = matching[i];
-      return entry.handler(ctx, () => dispatch(i + 1));
+      return entry.handler(
+        ctx,
+        () => dispatch(i + 1)
+      );
     };
     return dispatch(0);
   };
@@ -687,6 +775,7 @@ function freezeMiddlewareContext(ctx) {
     method: ctx.method,
     params: Object.freeze({ ...ctx.params }),
     ...ctx.request !== void 0 && { request: ctx.request },
+    ...ctx.req !== void 0 && { req: ctx.req },
     ...ctx.session !== void 0 && {
       session: Object.freeze({ ...ctx.session })
     },
@@ -758,10 +847,10 @@ function dispatchMcpEvents(events, method, phase, ctx, result) {
     }
     try {
       entry.handler(frozen, result);
-    } catch (error) {
+    } catch (error2) {
       console.error(
         `[mcp-use] MCP event listener for "${entry.pattern}" (${phase}) threw:`,
-        error
+        error2
       );
     }
   }
@@ -791,7 +880,7 @@ function colorsEnabled() {
   return process.stdout?.isTTY === true;
 }
 function ansi(open, close) {
-  return (text) => colorsEnabled() ? `\x1B[${open}m${text}\x1B[${close}m` : text;
+  return (text2) => colorsEnabled() ? `\x1B[${open}m${text2}\x1B[${close}m` : text2;
 }
 var bold = ansi(1, 22);
 var dim = ansi(2, 22);
@@ -849,13 +938,13 @@ function formatDetail(message) {
 }
 var INLINE_JSON_MAX_LENGTH = 80;
 function inlineJson(value) {
-  let text;
+  let text2;
   try {
-    text = JSON.stringify(value) ?? String(value);
+    text2 = JSON.stringify(value) ?? String(value);
   } catch {
-    text = String(value);
+    text2 = String(value);
   }
-  return text.length > INLINE_JSON_MAX_LENGTH ? `${text.slice(0, INLINE_JSON_MAX_LENGTH)}...` : text;
+  return text2.length > INLINE_JSON_MAX_LENGTH ? `${text2.slice(0, INLINE_JSON_MAX_LENGTH)}...` : text2;
 }
 function formatClientIdentity(message) {
   const meta = message.params?._meta;
@@ -866,8 +955,8 @@ function formatClientIdentity(message) {
   }
   return formatClientInfo(info);
 }
-function sanitize(text) {
-  return text.replace(/[\u0000-\u001F\u007F-\u009F]+/g, " ");
+function sanitize(text2) {
+  return text2.replace(/[\u0000-\u001F\u007F-\u009F]+/g, " ");
 }
 function methodStyle(method) {
   if (method.startsWith("tools/")) return cyan;
@@ -893,13 +982,13 @@ function redactHeaders(headers) {
 }
 async function extractResponseOutcome(res) {
   if (!res.body) return { errorMessage: null };
-  let text;
+  let text2;
   try {
-    text = await res.clone().text();
+    text2 = await res.clone().text();
   } catch {
     return { errorMessage: null };
   }
-  if (!text) return { errorMessage: null };
+  if (!text2) return { errorMessage: null };
   const isSse = (res.headers.get("content-type") ?? "").includes(
     "text/event-stream"
   );
@@ -911,14 +1000,14 @@ async function extractResponseOutcome(res) {
     }
   };
   if (isSse) {
-    for (const line of text.split(/\r?\n/)) {
+    for (const line of text2.split(/\r?\n/)) {
       if (line.startsWith("data:")) {
         const data = line.slice(5).trim();
         if (data) tryParse(data);
       }
     }
   } else {
-    tryParse(text);
+    tryParse(text2);
   }
   let result;
   for (const payload of payloads) {
@@ -1002,17 +1091,17 @@ ${cyan("=".repeat(80))}`);
     console.log(`${yellow("Response Body:")} (no body)`);
   } else {
     try {
-      const text = await response.clone().text();
-      if (text.length === 0) {
+      const text2 = await response.clone().text();
+      if (text2.length === 0) {
         console.log(`${yellow("Response Body:")} (empty)`);
       } else {
         console.log(yellow("Response Body:"));
         try {
-          console.log(formatForDump(JSON.parse(text)));
+          console.log(formatForDump(JSON.parse(text2)));
         } catch {
           console.log(
-            text.length > DUMP_BODY_MAX_LENGTH ? `${text.slice(0, DUMP_BODY_MAX_LENGTH)}
-... (truncated, ${text.length - DUMP_BODY_MAX_LENGTH} more characters)` : text
+            text2.length > DUMP_BODY_MAX_LENGTH ? `${text2.slice(0, DUMP_BODY_MAX_LENGTH)}
+... (truncated, ${text2.length - DUMP_BODY_MAX_LENGTH} more characters)` : text2
           );
         }
       }
@@ -1024,11 +1113,11 @@ ${cyan("=".repeat(80))}`);
 `);
 }
 function styleStatus(status) {
-  const text = String(status);
-  if (status >= 500) return magenta(text);
-  if (status >= 400) return red(text);
-  if (status >= 300) return yellow(text);
-  return green(text);
+  const text2 = String(status);
+  if (status >= 500) return magenta(text2);
+  if (status >= 400) return red(text2);
+  if (status >= 300) return yellow(text2);
+  return green(text2);
 }
 function isNoisyRequest(httpMethod, pathname) {
   if (httpMethod !== "GET" && httpMethod !== "HEAD") return false;
@@ -1198,8 +1287,8 @@ function resolvePublicBase(assetsBase, basePath) {
 function escapeInlineScript(code) {
   return code.replaceAll(/<\/script/gi, "<\\/script").replaceAll("<!--", "\\x3C!--");
 }
-function escapeInlineStyle(css) {
-  return css.replaceAll(/<\/style/gi, "<\\/style");
+function escapeInlineStyle(css2) {
+  return css2.replaceAll(/<\/style/gi, "<\\/style");
 }
 function escapeHtml(value) {
   return value.replaceAll("&", "&amp;").replaceAll('"', "&quot;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
@@ -1520,6 +1609,16 @@ function omitToolSchemaDialects(tools) {
     ...tool.outputSchema === void 0 ? {} : { outputSchema: omitRootSchemaDialect(tool.outputSchema) }
   }));
 }
+function registerFetchMiddleware(app, middleware) {
+  app.use("*", async (context, next) => {
+    const response = await middleware(context.req.raw, async () => {
+      await next();
+      return context.res;
+    });
+    context.res = response;
+    return response;
+  });
+}
 var MCPServer = class _MCPServer {
   #config;
   #branding;
@@ -1540,7 +1639,9 @@ var MCPServer = class _MCPServer {
   /** Project root for filesystem-backed view bundle and public routes. */
   #viewsProjectRoot = process.cwd();
   #fetchHandler;
+  #httpApp;
   #handler;
+  #eventBus;
   #httpServer;
   #oauthResource;
   #oauthResourceResolved = false;
@@ -1555,6 +1656,30 @@ var MCPServer = class _MCPServer {
   #proxyOperations = /* @__PURE__ */ new Set();
   /** Whether terminal shutdown has begun. */
   #closed = false;
+  /** Hono application that owns HTTP middleware and routes. */
+  app;
+  /** Register a typed `GET` route on {@link MCPServer.app}. */
+  get;
+  /** Register a typed `POST` route on {@link MCPServer.app}. */
+  post;
+  /** Register a typed `PUT` route on {@link MCPServer.app}. */
+  put;
+  /** Register a typed `PATCH` route on {@link MCPServer.app}. */
+  patch;
+  /** Register a typed `DELETE` route on {@link MCPServer.app}. */
+  delete;
+  /** Register a typed route for every HTTP method on {@link MCPServer.app}. */
+  all;
+  /**
+   * Canonical Web-standard handler for edge runtimes and framework mounting.
+   *
+   * @example
+   * ```ts
+   * export default server;
+   * // or: export const POST = server.fetch;
+   * ```
+   */
+  fetch;
   /**
    * Create an MCP server from a parsed, bundled OpenAPI document.
    *
@@ -1589,22 +1714,37 @@ var MCPServer = class _MCPServer {
    * is both the MCP route and the path of the OAuth protected-resource
    * identity, so any explicit OAuth resource URL must use that exact path.
    * Nothing binds or listens until {@link MCPServer.listen} or
-   * {@link MCPServer.getHandler} is called.
+   * the first request reaches {@link MCPServer.fetch}.
    */
   constructor(config) {
     assertServerConfig(config);
     this.#config = config;
     this.#branding = normalizeServerBranding(config);
+    this.app = new Hono();
+    this.app.use("*", async (context, next) => {
+      getRequestBag(context.req.raw).honoContext = context;
+      await next();
+    });
+    this.get = this.app.get.bind(this.app);
+    this.post = this.app.post.bind(this.app);
+    this.put = this.app.put.bind(this.app);
+    this.patch = this.app.patch.bind(this.app);
+    this.delete = this.app.delete.bind(this.app);
+    this.all = this.app.all.bind(this.app);
+    this.fetch = async (request, env, executionCtx) => {
+      this.#ensureMounted("handler");
+      return this.#httpApp.fetch(request, env, executionCtx);
+    };
     if (config.oauth !== void 0) {
       const mcpUrl = typeof process === "undefined" ? void 0 : process.env["MCP_URL"];
-      const resource = resolveConfiguredOAuthResource({
+      const resource2 = resolveConfiguredOAuthResource({
         provider: config.oauth,
         basePath: this.#basePath(),
         ...mcpUrl !== void 0 && { mcpUrl }
       });
-      this.#oauthResource = resource;
-      this.#oauthResourceResolved = resource !== void 0;
-      this.#oauthResourceConfigurationAbsent = resource === void 0;
+      this.#oauthResource = resource2;
+      this.#oauthResourceResolved = resource2 !== void 0;
+      this.#oauthResourceConfigurationAbsent = resource2 === void 0;
     }
   }
   /**
@@ -1643,11 +1783,19 @@ var MCPServer = class _MCPServer {
   get branding() {
     return this.#branding;
   }
+  /** @deprecated Use {@link MCPServer.fetch} directly. */
+  getHandler() {
+    return this.fetch;
+  }
   /**
    * Register a tool. Input is validated against `inputSchema` before the callback
    * runs; results carrying `structuredContent` are type-checked against
    * `outputSchema` at the callback's return position.
    *
+   * Assign static registrations to exported constants so `mcp-env.d.ts` can
+   * expose their {@link ToolRef} types to views:
+   * `export const search = server.tool(...)`.
+   *
    * @returns A {@link ToolRef} carrying the tool name and phantom types for
    * inference-based view typing.
    */
@@ -1745,7 +1893,7 @@ var MCPServer = class _MCPServer {
   async proxy(input) {
     this.#assertOpen("proxy()");
     const operation = (async () => {
-      const { isProxyConnection, mountProxyConnection, mountProxyServers } = await import("./mcp-proxy-QYZQ6LNV.js");
+      const { isProxyConnection, mountProxyConnection, mountProxyServers } = await import("./mcp-proxy-JK7IC5CR.js");
       if (isProxyConnection(input)) {
         await mountProxyConnection(this.#proxyHost(), input);
         return;
@@ -1759,70 +1907,20 @@ var MCPServer = class _MCPServer {
       this.#proxyOperations.delete(operation);
     }
   }
-  /**
-   * Web-standard request handler for the whole app (MCP endpoint included) —
-   * usable directly on serverless/edge runtimes or in tests.
-   *
-   * The handler never binds a socket, so no Host/Origin validation applies
-   * by default: DNS rebinding targets locally bound servers, and platform
-   * edges (Vercel, Cloudflare, …) only route hostnames assigned to the
-   * deployment. Set `allowedHosts`/`allowedOrigins` to opt into validation
-   * (additive — localhost-class values stay allowed).
-   *
-   * Pass the same `bus` to multiple server instances when their handlers
-   * replace one another while existing `subscriptions/listen` streams remain
-   * open. The bus is fixed when this instance first mounts.
-   *
-   * @param options - Optional handler wiring.
-   *
-   * @example
-   * ```ts
-   * const handler = server.getHandler();
-   * export default { fetch: handler };
-   * ```
-   */
-  getHandler(options = {}) {
-    this.#assertOpen("getHandler()");
-    const { fetch } = this.#ensureMounted("handler", void 0, options.bus);
-    return toFrameworkHandler(fetch);
-  }
-  /**
-   * Node `(req, res) => void` handler for composing with an existing
-   * `http.Server`. Uses the same internal `toNodeHandler` bridge as
-   * {@link MCPServer.listen}; MCPServer users do not need to import
-   * `mcp-use/node`.
-   *
-   * @example
-   * ```ts
-   * import { createServer } from "node:http";
-   * const httpServer = createServer(await server.getNodeHandler());
-   * httpServer.listen(3000);
-   * ```
-   */
-  async getNodeHandler() {
-    const { fetch } = this.#ensureMounted("handler");
-    const { toNodeHandler } = await import("./node-bridge.js");
-    return toNodeHandler({ fetch });
-  }
-  /**
-   * Register MCP operation middleware that intercepts JSON-RPC dispatch.
-   *
-   * Patterns use an `mcp:` prefix (for example `mcp:tools/call`, `mcp:*`).
-   * Exact methods may transform their typed result. The global `mcp:*` pattern
-   * is pass-through middleware. Middleware runs in registration order; call
-   * `next()` to continue the chain.
-   *
-   * @example
-   * ```ts
-   * server.use("mcp:tools/call", async (ctx, next) => {
-   *   console.log(`Calling tool: ${ctx.params.name}`);
-   *   return next();
-   * });
-   * ```
-   */
-  use(pattern, handler) {
-    this.#assertNotStarted("middleware", pattern);
-    this.#mcpMiddlewares.push(createMcpMiddlewareEntry(pattern, handler));
+  use(patternOrHandler, ...handlers) {
+    if (typeof patternOrHandler === "string" && patternOrHandler.startsWith("mcp:")) {
+      this.#assertNotStarted("middleware", patternOrHandler);
+      const handler = handlers[0];
+      this.#mcpMiddlewares.push(
+        createMcpMiddlewareEntry(
+          patternOrHandler,
+          handler
+        )
+      );
+      return this;
+    }
+    const register = this.app.use;
+    register.call(this.app, patternOrHandler, ...handlers);
     return this;
   }
   /**
@@ -1845,6 +1943,20 @@ var MCPServer = class _MCPServer {
     this.#mcpEventListeners.push(createMcpEventListenerEntry(pattern, handler));
     return this;
   }
+  /**
+   * Attach the shared development event bus before the first request.
+   *
+   * @param bus - Bus retained across hot-reloaded server instances.
+   * @internal
+   */
+  __setEventBus(bus) {
+    this.#assertNotStarted("event bus", "shared");
+    this.#eventBus = bus;
+  }
+  /** Mount and validate the Hono/MCP application without serving a request. @internal */
+  __mount() {
+    this.#ensureMounted("handler");
+  }
   /**
    * Publish a tools-list change to v2 clients with active subscriptions.
    *
@@ -1908,7 +2020,7 @@ var MCPServer = class _MCPServer {
    * requests accepted before then are queued. Public/wildcard listeners must
    * configure the resource before calling this method.
    *
-   * @throws If called on a localhost-class bind after {@link MCPServer.getHandler}
+   * @throws If called on a localhost-class bind after {@link MCPServer.fetch}
    * already mounted the app without Host validation.
    */
   async listen(port = void 0, options = {}) {
@@ -1929,12 +2041,12 @@ var MCPServer = class _MCPServer {
       );
       void fetchReady.catch(() => void 0);
       let settled = false;
-      const rejectAndClose = (error) => {
+      const rejectAndClose = (error2) => {
         if (!settled) {
           settled = true;
-          reject(error);
+          reject(error2);
         }
-        rejectFetch?.(error);
+        rejectFetch?.(error2);
         void new Promise(
           (closeResolve) => server.close(() => closeResolve())
         ).catch(() => void 0).finally(() => {
@@ -1954,13 +2066,7 @@ var MCPServer = class _MCPServer {
         try {
           const address = server.address();
           const boundPort = typeof address === "object" && address !== null ? address.port : requestedPort;
-          const { fetch } = this.#ensureMounted(
-            "listen",
-            boundPort,
-            void 0,
-            options.routes,
-            host
-          );
+          const { fetch } = this.#ensureMounted("listen", boundPort, host);
           resolveFetch?.(fetch);
           if (!settled) {
             settled = true;
@@ -1969,8 +2075,8 @@ var MCPServer = class _MCPServer {
               url: `http://localhost:${boundPort}${this.#basePath()}`
             });
           }
-        } catch (error) {
-          rejectAndClose(error);
+        } catch (error2) {
+          rejectAndClose(error2);
         }
       });
       this.#httpServer = server;
@@ -1980,7 +2086,7 @@ var MCPServer = class _MCPServer {
    * Abort in-flight MCP exchanges and stop the HTTP listener.
    *
    * A closed server is done for good — the underlying MCP handler stays
-   * closed, so `listen()`/`getHandler()` cannot revive it. Create a new
+   * closed, so `listen()`/`fetch()` cannot revive it. Create a new
    * instance to serve again.
    */
   async close() {
@@ -1996,8 +2102,8 @@ var MCPServer = class _MCPServer {
     }
     try {
       await this.#handler?.close();
-    } catch (error) {
-      errors.push(error);
+    } catch (error2) {
+      errors.push(error2);
     }
     const httpServer = this.#httpServer;
     if (httpServer !== void 0) {
@@ -2006,8 +2112,8 @@ var MCPServer = class _MCPServer {
           httpServer.close((err) => err ? reject(err) : resolve());
         });
         this.#httpServer = void 0;
-      } catch (error) {
-        errors.push(error);
+      } catch (error2) {
+        errors.push(error2);
       }
     }
     if (errors.length > 0) {
@@ -2042,7 +2148,7 @@ var MCPServer = class _MCPServer {
       return this.#oauthResource;
     }
     throw new Error(
-      "OAuth requires an explicit resource or MCP_URL when using getHandler() or listening on a non-local host"
+      "OAuth requires an explicit resource or MCP_URL when using server.fetch or listening on a non-local host"
     );
   }
   #assertListenOAuthConfiguration(host) {
@@ -2061,7 +2167,7 @@ var MCPServer = class _MCPServer {
   #assertNotStarted(kind, name) {
     if (this.#handler !== void 0) {
       throw new Error(
-        `Cannot register ${kind} "${name}" after the server has started: registrations are replayed per request from the registry, so register everything before listen()/getHandler().`
+        `Cannot register ${kind} "${name}" after the server has started: registrations are replayed per request from the registry, so register everything before listen()/server.fetch.`
       );
     }
   }
@@ -2104,7 +2210,7 @@ var MCPServer = class _MCPServer {
    * Configured lists are additive to the localhost-class allowlists, so local
    * runs keep working when a deployment hostname is added. With nothing
    * configured, `listen()` on a localhost-class bind validates Host against the
-   * localhost lists (the DNS-rebinding threat model), while `getHandler()` —
+   * localhost lists (the DNS-rebinding threat model), while `server.fetch` —
    * which never binds — applies no validation. Origin validation is off unless
    * `allowedOrigins` is set explicitly (SDK-aligned: the handler is open by
    * default). When enabled, Origin is checked only on non-GET/HEAD requests.
@@ -2117,12 +2223,13 @@ var MCPServer = class _MCPServer {
     const origins = allowedOrigins !== void 0 ? [.../* @__PURE__ */ new Set([...localhostAllowedOrigins(), ...allowedOrigins])] : void 0;
     return { hosts, origins };
   }
-  #ensureMounted(mode, listenPort, bus, additionalRoutes = [], listenHost) {
+  #ensureMounted(mode, listenPort, listenHost) {
     this.#assertOpen();
     if (this.#fetchHandler === void 0 || this.#handler === void 0) {
       const { hosts, origins } = this.#validationPolicy(mode, listenHost);
       const basePath = this.#basePath();
       const nestedBasePath = basePath === "/" ? "" : basePath;
+      const httpApp = new Hono();
       const middlewares = [
         jsonBodyMiddleware(),
         requestLogger(this.#config.logging)
@@ -2146,35 +2253,38 @@ var MCPServer = class _MCPServer {
         }
       }
       this.#validateViewBindingsAtMount();
-      const resource = this.#resolveOAuthResource(mode, listenPort, listenHost);
-      if (resource !== void 0) {
+      const resource2 = this.#resolveOAuthResource(mode, listenPort, listenHost);
+      if (resource2 !== void 0) {
         const provider = this.#config.oauth;
-        middlewares.push(oauthMetadata(provider, resource));
+        middlewares.push(oauthMetadata(provider, resource2));
+      }
+      for (const middleware of middlewares) {
+        registerFetchMiddleware(httpApp, middleware);
       }
       const { handler, fetch: mcpFetch } = createMcpMount(
         (ctx) => this.#buildSdkServer(ctx),
         {
           path: basePath,
-          ...(this.#config.legacy !== void 0 || bus !== void 0) && {
+          ...(this.#config.legacy !== void 0 || this.#eventBus !== void 0) && {
             handler: {
               ...this.#config.legacy !== void 0 && {
                 legacy: this.#config.legacy
               },
-              ...bus !== void 0 && { bus }
+              ...this.#eventBus !== void 0 && { bus: this.#eventBus }
             }
           },
-          ...resource !== void 0 && {
+          ...resource2 !== void 0 && {
             authInfo: (request) => authInfoFromRequest(request)
           }
         }
       );
       let protectWithBearer = async (_request, next) => next();
-      if (resource !== void 0) {
+      if (resource2 !== void 0) {
         const provider = this.#config.oauth;
         const providerOptions = getOAuthProviderOptions(provider);
         const gate = requireBearerAuth({
-          verifier: wrapOAuthTokenVerifier(provider, resource),
-          resourceMetadataUrl: getOAuthProtectedResourceMetadataUrl(resource),
+          verifier: wrapOAuthTokenVerifier(provider, resource2),
+          resourceMetadataUrl: getOAuthProtectedResourceMetadataUrl(resource2),
           ...providerOptions.requiredScopes !== void 0 && {
             requiredScopes: providerOptions.requiredScopes
           }
@@ -2206,12 +2316,11 @@ var MCPServer = class _MCPServer {
             this.#resources.values()
           );
         };
-        if (resource !== void 0 && this.#config.publicLandingPage !== true) {
+        if (resource2 !== void 0 && this.#config.publicLandingPage !== true) {
           return protectWithBearer(request, respond);
         }
         return respond();
       };
-      const routes = [...additionalRoutes];
       const brandingDevMode = this.#viewsPrimed ? this.#viewsDevMode : process.env["NODE_ENV"] !== "production";
       const faviconHandler = createFaviconHandler(this.#branding, {
         dev: brandingDevMode,
@@ -2219,10 +2328,10 @@ var MCPServer = class _MCPServer {
         deferCors: deferViewCors
       });
       if (faviconHandler !== void 0) {
-        routes.push({
-          match: (request) => new URL(request.url).pathname === "/favicon.ico",
-          handler: faviconHandler
-        });
+        this.app.all(
+          "/favicon.ico",
+          (context) => faviconHandler(context.req.raw)
+        );
       }
       const viewHandler = createViewPublicHandler(basePath, this.#views, {
         dev: this.#viewsPrimed ? this.#viewsDevMode : brandingDevMode,
@@ -2231,12 +2340,11 @@ var MCPServer = class _MCPServer {
         deferCors: deferViewCors
       });
       if (viewHandler !== void 0) {
-        routes.push({
-          match: (request) => request.method === "GET" || request.method === "HEAD" ? new URL(request.url).pathname.startsWith(
-            `${nestedBasePath}/_mcp-use/public/`
-          ) : false,
-          handler: viewHandler
-        });
+        this.app.on(
+          ["GET", "HEAD"],
+          `${nestedBasePath}/_mcp-use/public/*`,
+          (context) => viewHandler(context.req.raw)
+        );
       }
       if (!this.#viewsDevMode) {
         const viewAssetsHandler = createViewAssetsHandler(
@@ -2245,29 +2353,22 @@ var MCPServer = class _MCPServer {
           { projectRoot: this.#viewsProjectRoot, deferCors: deferViewCors }
         );
         if (viewAssetsHandler !== void 0) {
-          routes.push({
-            match: (request) => request.method === "GET" || request.method === "HEAD" ? new URL(request.url).pathname.startsWith(
-              `${nestedBasePath}/_mcp-use/views/`
-            ) : false,
-            handler: viewAssetsHandler
-          });
+          this.app.on(
+            ["GET", "HEAD"],
+            `${nestedBasePath}/_mcp-use/views/*`,
+            (context) => viewAssetsHandler(context.req.raw)
+          );
         }
       }
-      routes.push({
-        match: (request) => matchesPath(request, basePath),
-        handler: endpointHandler
-      });
-      const terminal = routeFetch(routes);
-      this.#fetchHandler = composeFetch(terminal, ...middlewares);
+      this.app.all(basePath, (context) => endpointHandler(context.req.raw));
+      httpApp.route("/", this.app);
+      this.#httpApp = httpApp;
+      this.#fetchHandler = async (request) => httpApp.fetch(request);
       this.#handler = handler;
       this.#hostValidated = hosts !== void 0;
-    } else if (bus !== void 0 && this.#handler.bus !== bus) {
-      throw new Error(
-        "Cannot change the MCP event bus after the server has started."
-      );
     } else if (mode === "listen" && !this.#hostValidated && this.#validationPolicy("listen", listenHost).hosts !== void 0) {
       throw new Error(
-        "Cannot listen() on a localhost bind after getHandler(): the app is already mounted without Host validation (getHandler() expects a platform edge in front). Call listen() first, or set allowedHosts."
+        "Cannot listen() on a localhost bind after server.fetch mounted the app without Host validation (server.fetch expects a platform edge in front). Call listen() first, or set allowedHosts."
       );
     }
     return { fetch: this.#fetchHandler, handler: this.#handler };
@@ -2382,16 +2483,16 @@ var MCPServer = class _MCPServer {
     return server;
   }
   #createMiddlewareContext(method, params, ctx) {
-    return {
+    const requestContext = toRequestContext(ctx);
+    return Object.assign(requestContext, {
       method,
       params,
-      ...ctx.http?.req !== void 0 && { request: ctx.http.req },
       ...ctx.sessionId !== void 0 && {
         session: { sessionId: ctx.sessionId }
       },
       ...ctx.http?.authInfo !== void 0 && { auth: ctx.http.authInfo },
       state: /* @__PURE__ */ new Map()
-    };
+    });
   }
   #runMcpHook(method, ctx, innerFn) {
     return runMcpOperation(
@@ -2554,7 +2655,7 @@ var MCPServer = class _MCPServer {
           ...metaOptions.hmrWs === true ? { hmrWs: true } : {}
         } : metaOptions.hmrWs === true ? { hmrWs: true } : {};
         const assetsBase = req !== void 0 ? resolveAssetsBase(req) : metaOptions.request !== void 0 ? resolveAssetsBase(metaOptions.request) : "";
-        const html = synthesizeViewDocument(
+        const html2 = synthesizeViewDocument(
           entry,
           assetsBase,
           basePath,
@@ -2565,7 +2666,7 @@ var MCPServer = class _MCPServer {
             {
               uri: readUri.href,
               mimeType: resourceConfig.mimeType,
-              text: html,
+              text: html2,
               _meta: buildResourceUiMeta(authorFacts, readOptions)
             }
           ]
@@ -2601,12 +2702,11 @@ var MCPServer = class _MCPServer {
           },
           ctx
         );
-        const innerFn = async () => callback(uri, this.#toRequestContext(ctx));
-        return await this.#runMcpHook(
-          "resources/read",
-          mwCtx,
-          innerFn
+        const innerFn = async () => toResourceResult(
+          await callback(uri, this.#toRequestContext(ctx)),
+          uri.href
         );
+        return await this.#runMcpHook("resources/read", mwCtx, innerFn);
       }
     );
   }
@@ -2642,16 +2742,15 @@ var MCPServer = class _MCPServer {
           },
           ctx
         );
-        const innerFn = async () => callback(
-          uri,
-          variables,
-          this.#toRequestContext(ctx)
-        );
-        return await this.#runMcpHook(
-          "resources/read",
-          mwCtx,
-          innerFn
+        const innerFn = async () => toResourceResult(
+          await callback(
+            uri,
+            variables,
+            this.#toRequestContext(ctx)
+          ),
+          uri.href
         );
+        return await this.#runMcpHook("resources/read", mwCtx, innerFn);
       }
     );
   }
@@ -2692,7 +2791,9 @@ var MCPServer = class _MCPServer {
       );
       const innerFn = async () => {
         const effectiveArgs = mwCtx.params.arguments ?? {};
-        return callback(effectiveArgs, this.#toRequestContext(ctx));
+        return toPromptResult(
+          await callback(effectiveArgs, this.#toRequestContext(ctx))
+        );
       };
       return await this.#runMcpHook("prompts/get", mwCtx, innerFn);
     };
@@ -2727,9 +2828,186 @@ import {
   inputResponse as inputResponse2,
   isInputRequiredResult as isInputRequiredResult3
 } from "@modelcontextprotocol/server";
+
+// src/response-helpers.ts
+function text(content) {
+  return {
+    content: [{ type: "text", text: content }],
+    _meta: { mimeType: "text/plain" }
+  };
+}
+function markdown(content) {
+  return {
+    content: [{ type: "text", text: content }],
+    _meta: { mimeType: "text/markdown" }
+  };
+}
+function html(content) {
+  return {
+    content: [{ type: "text", text: content }],
+    _meta: { mimeType: "text/html" }
+  };
+}
+function xml(content) {
+  return {
+    content: [{ type: "text", text: content }],
+    _meta: { mimeType: "text/xml" }
+  };
+}
+function css(content) {
+  return {
+    content: [{ type: "text", text: content }],
+    _meta: { mimeType: "text/css" }
+  };
+}
+function javascript(content) {
+  return {
+    content: [{ type: "text", text: content }],
+    _meta: { mimeType: "text/javascript" }
+  };
+}
+function image(data, mimeType = "image/png") {
+  return {
+    content: [{ type: "image", data, mimeType }],
+    _meta: { mimeType, isImage: true }
+  };
+}
+function audio(data, mimeType = "audio/wav") {
+  return {
+    content: [{ type: "audio", data, mimeType }],
+    _meta: { mimeType, isAudio: true }
+  };
+}
+function binary(base64Data, mimeType) {
+  return {
+    content: [{ type: "text", text: base64Data }],
+    _meta: { mimeType, isBinary: true }
+  };
+}
+function resource(uri, mimeTypeOrContent, text2) {
+  if (typeof mimeTypeOrContent === "object" && mimeTypeOrContent !== null && "content" in mimeTypeOrContent) {
+    const contentResult = mimeTypeOrContent;
+    let extractedText;
+    let extractedMimeType;
+    if (contentResult._meta && typeof contentResult._meta === "object") {
+      const meta = contentResult._meta;
+      if (typeof meta.mimeType === "string") {
+        extractedMimeType = meta.mimeType;
+      }
+    }
+    const first = contentResult.content?.[0];
+    if (first?.type === "text" && "text" in first) {
+      extractedText = first.text;
+    }
+    return {
+      content: [
+        {
+          type: "resource",
+          resource: {
+            uri,
+            ...extractedMimeType !== void 0 && {
+              mimeType: extractedMimeType
+            },
+            text: extractedText ?? ""
+          }
+        }
+      ]
+    };
+  }
+  const mimeType = mimeTypeOrContent;
+  return {
+    content: [
+      {
+        type: "resource",
+        resource: {
+          uri,
+          ...mimeType !== void 0 && mimeType !== "" && { mimeType },
+          text: text2 ?? ""
+        }
+      }
+    ]
+  };
+}
+function error(message) {
+  return {
+    isError: true,
+    content: [{ type: "text", text: message }]
+  };
+}
+function object(data) {
+  if (Array.isArray(data)) {
+    return array(data);
+  }
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(data, null, 2)
+      }
+    ],
+    structuredContent: data,
+    _meta: { mimeType: "application/json" }
+  };
+}
+function array(data) {
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(data, null, 2)
+      }
+    ],
+    structuredContent: data
+  };
+}
+function widget(config) {
+  const props = config.props ?? config.data ?? {};
+  const { output, message, metadata } = config;
+  const finalContent = message ? [{ type: "text", text: message }] : Array.isArray(output?.content) && output.content.length > 0 ? output.content : [{ type: "text", text: "" }];
+  const result = {
+    content: finalContent
+  };
+  if (metadata !== void 0 && Object.keys(metadata).length > 0) {
+    result._meta = metadata;
+  }
+  if (output?.structuredContent !== void 0) {
+    result.structuredContent = output.structuredContent;
+  } else if (Object.keys(props).length > 0) {
+    result.structuredContent = props;
+  }
+  return result;
+}
+function mix(...results) {
+  const withStructured = results.filter(
+    (result) => result.structuredContent !== void 0
+  );
+  const structuredContent = withStructured.length > 0 ? withStructured.map((result) => result.structuredContent).reduce(
+    (acc, value) => ({
+      ...acc,
+      ...typeof value === "object" && value !== null ? value : {}
+    }),
+    {}
+  ) : void 0;
+  const withMeta = results.filter((result) => result._meta !== void 0);
+  const _meta = withMeta.length > 0 ? withMeta.map((result) => result._meta).reduce(
+    (acc, value) => ({
+      ...acc,
+      ...value !== void 0 ? value : {}
+    }),
+    {}
+  ) : void 0;
+  return {
+    content: results.flatMap((result) => result.content),
+    ...structuredContent !== void 0 && Object.keys(structuredContent).length > 0 && { structuredContent },
+    ..._meta !== void 0 && Object.keys(_meta).length > 0 && { _meta }
+  };
+}
 export {
   MCPServer,
   acceptedContent,
+  array,
+  audio,
+  binary,
   completable,
   composeFetch,
   composeMiddleware,
@@ -2737,19 +3015,29 @@ export {
   createMcpMiddlewareEntry,
   createMcpMount,
   createRequestStateCodec,
+  css,
+  error,
   getRequestBag,
   hostValidationMiddleware,
+  html,
+  image,
   inputRequired2 as inputRequired,
   inputResponse2 as inputResponse,
   isInputRequiredResult3 as isInputRequiredResult,
+  javascript,
   jsonBodyMiddleware,
+  markdown,
   matchesPath,
   matchesPathPrefix,
   matchesPattern,
+  mix,
+  object,
   originValidationMiddleware,
   pathnameOf,
   registerViews,
   requestLogger,
-  routeFetch,
-  toFrameworkHandler
+  resource,
+  text,
+  widget,
+  xml
 };