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

package/dist/server.d.ts

@@ -1,9 +1,8 @@
 import { type ServerEventBus } from "@modelcontextprotocol/server";
+import { Hono, type Env, type MiddlewareHandler } from "hono";
 import { type ServerBranding } from "./branding.js";
 import { type ServerConfig } from "./config.js";
-import { type FetchHandler, type FrameworkHandler } from "./fetch-app.js";
 import { type McpEventListenerFnFor, type McpEventPattern, type McpMiddlewareFnFor, type McpMiddlewarePattern } from "./middleware/mcp-middleware.js";
-import type { NodeRequestHandler } from "./node-bridge.js";
 import type { FromOpenAPIOptions } from "./openapi/types.js";
 import type { InferPromptInput, PromptCallback, PromptDefinition } from "./prompts.js";
 import type { InferTemplateParams, ResourceCallback, ResourceDefinition, ResourceTemplateCallback, ResourceTemplateDefinition } from "./resources.js";
@@ -11,26 +10,11 @@ import type { ProxyConnection, ProxyServerConfig } from "./mcp-proxy.js";
 import type { InferToolInput, InferToolName, InferToolOutput, ToolCallback, ToolDefinition, ToolRef } from "./tools.js";
 import { registerViews, type ViewsManifest } from "./views/index.js";
 type HasOAuth<TUser> = [TUser] extends [never] ? false : true;
-/**
- * Optional Node-listener routes registered while the framework mounts its
- * production Fetch handler, before requests are accepted.
- *
- * This lets CLI-owned integrations add narrowly scoped routes while retaining
- * `listen()`'s host validation and OAuth resource initialization.
- */
+/** Options accepted by {@link MCPServer.listen}. */
 export interface ListenOptions {
-    /** Additional routes protected by the server's normal middleware stack. */
-    routes?: readonly ListenRoute[];
     /** Explicit bind host; takes precedence over `HOST` and configured `host`. */
     host?: string;
 }
-/** An additional route owned by a caller of {@link MCPServer.listen}. */
-export interface ListenRoute {
-    /** Whether this route handles a request. */
-    match: (request: Request) => boolean;
-    /** Handler invoked when {@link match} returns `true`. */
-    handler: FetchHandler;
-}
 /**
  * MCP server with declarative tool/resource/prompt registration, served
  * statelessly over a composed fetch handler.
@@ -52,8 +36,32 @@ export interface ListenRoute {
  * await server.listen(3000);
  * ```
  */
-export declare class MCPServer<TUser = never> {
+export declare class MCPServer<TUser = never, TEnv extends Env = Env> {
     #private;
+    /** Hono application that owns HTTP middleware and routes. */
+    readonly app: Hono<TEnv>;
+    /** Register a typed `GET` route on {@link MCPServer.app}. */
+    readonly get: Hono<TEnv>["get"];
+    /** Register a typed `POST` route on {@link MCPServer.app}. */
+    readonly post: Hono<TEnv>["post"];
+    /** Register a typed `PUT` route on {@link MCPServer.app}. */
+    readonly put: Hono<TEnv>["put"];
+    /** Register a typed `PATCH` route on {@link MCPServer.app}. */
+    readonly patch: Hono<TEnv>["patch"];
+    /** Register a typed `DELETE` route on {@link MCPServer.app}. */
+    readonly delete: Hono<TEnv>["delete"];
+    /** Register a typed route for every HTTP method on {@link MCPServer.app}. */
+    readonly all: Hono<TEnv>["all"];
+    /**
+     * Canonical Web-standard handler for edge runtimes and framework mounting.
+     *
+     * @example
+     * ```ts
+     * export default server;
+     * // or: export const POST = server.fetch;
+     * ```
+     */
+    readonly fetch: (...args: Parameters<Hono<TEnv>["fetch"]>) => Promise<Response>;
     /**
      * Create an MCP server from a parsed, bundled OpenAPI document.
      *
@@ -81,7 +89,7 @@ export declare class MCPServer<TUser = never> {
      * 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: ServerConfig<TUser>);
     /**
@@ -112,15 +120,21 @@ export declare class MCPServer<TUser = never> {
      * ```
      */
     get branding(): ServerBranding;
+    /** @deprecated Use {@link MCPServer.fetch} directly. */
+    getHandler(): typeof 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.
      */
-    tool<const T extends ToolDefinition>(definition: T, callback: ToolCallback<InferToolInput<T>, InferToolOutput<T>, TUser, HasOAuth<TUser>>): ToolRef<InferToolName<T>, InferToolInput<T>, InferToolOutput<T>>;
+    tool<const T extends ToolDefinition>(definition: T, callback: ToolCallback<InferToolInput<T>, InferToolOutput<T>, TUser, HasOAuth<TUser>, TEnv>): ToolRef<InferToolName<T>, InferToolInput<T>, InferToolOutput<T>>;
     /**
      * Prime the views registry from build/dev registry data.
      *
@@ -154,7 +168,7 @@ export declare class MCPServer<TUser = never> {
         projectRoot?: string;
     }): void;
     /** Register a static resource readable at `definition.uri`. */
-    resource(definition: ResourceDefinition, callback: ResourceCallback<TUser, HasOAuth<TUser>>): this;
+    resource(definition: ResourceDefinition, callback: ResourceCallback<TUser, HasOAuth<TUser>, TEnv>): this;
     /**
      * Register a parameterized resource. Reads matching `uriTemplate` invoke
      * the callback with the extracted variables.
@@ -166,12 +180,12 @@ export declare class MCPServer<TUser = never> {
      */
     resourceTemplate<const TUriTemplate extends string>(definition: ResourceTemplateDefinition<TUriTemplate>, callback: ResourceTemplateCallback<InferTemplateParams<{
         uriTemplate: TUriTemplate;
-    }>, TUser, HasOAuth<TUser>>): this;
+    }>, TUser, HasOAuth<TUser>, TEnv>): this;
     /**
      * Register a prompt template. Schema fields wrapped with `completable()`
      * gain autocomplete via `completion/complete`.
      */
-    prompt<T extends PromptDefinition>(definition: T, callback: PromptCallback<InferPromptInput<T>, TUser, HasOAuth<TUser>>): this;
+    prompt<T extends PromptDefinition>(definition: T, callback: PromptCallback<InferPromptInput<T>, TUser, HasOAuth<TUser>, TEnv>): this;
     /**
      * Compose upstream MCP servers into this server.
      *
@@ -217,61 +231,32 @@ export declare class MCPServer<TUser = never> {
      */
     proxy(connection: ProxyConnection): Promise<void>;
     /**
-     * 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).
+     * Register HTTP middleware or typed MCP operation middleware.
      *
-     * 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.
+     * MCP patterns always use an `mcp:` prefix (for example
+     * `mcp:tools/call`, `mcp:*`). Every other overload is Hono middleware and
+     * may target all routes or a path pattern.
      *
-     * @param options - Optional handler wiring.
-     *
-     * @example
-     * ```ts
-     * const handler = server.getHandler();
-     * export default { fetch: handler };
-     * ```
-     */
-    getHandler(options?: {
-        bus?: ServerEventBus;
-    }): FrameworkHandler;
-    /**
-     * 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);
-     * ```
-     */
-    getNodeHandler(): Promise<NodeRequestHandler>;
-    /**
-     * 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("/api/*", async (c, next) => {
+     *   c.set("requestId", crypto.randomUUID());
+     *   await next();
+     * });
+     *
      * server.use("mcp:tools/call", async (ctx, next) => {
      *   console.log(`Calling tool: ${ctx.params.name}`);
      *   return next();
      * });
      * ```
      */
-    use<P extends McpMiddlewarePattern>(pattern: P, handler: McpMiddlewareFnFor<P>): this;
+    use<P extends McpMiddlewarePattern>(pattern: P, handler: McpMiddlewareFnFor<P, TEnv>): this;
+    use(handler: MiddlewareHandler<TEnv>): this;
+    use(path: `/${string}` | "*", ...handlers: MiddlewareHandler<TEnv>[]): this;
     /**
      * Register a read-only MCP observer. Unlike {@link MCPServer.use}, listeners
      * cannot block, override, or mutate params. Throwing is logged and does not
@@ -287,7 +272,16 @@ export declare class MCPServer<TUser = never> {
      * });
      * ```
      */
-    on<P extends McpEventPattern>(pattern: P, handler: McpEventListenerFnFor<P>): this;
+    on<P extends McpEventPattern>(pattern: P, handler: McpEventListenerFnFor<P, TEnv>): this;
+    /**
+     * Attach the shared development event bus before the first request.
+     *
+     * @param bus - Bus retained across hot-reloaded server instances.
+     * @internal
+     */
+    __setEventBus(bus: ServerEventBus): void;
+    /** Mount and validate the Hono/MCP application without serving a request. @internal */
+    __mount(): void;
     /**
      * Publish a tools-list change to v2 clients with active subscriptions.
      *
@@ -343,7 +337,7 @@ export declare class MCPServer<TUser = never> {
      * 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.
      */
     listen(port?: number | undefined, options?: ListenOptions): Promise<{
@@ -354,7 +348,7 @@ export declare class MCPServer<TUser = never> {
      * 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.
      */
     close(): Promise<void>;

package/dist/tools.d.ts

@@ -1,4 +1,5 @@
 import type { CallToolResult, InputRequiredResult, MetaObject, StandardSchemaWithJSON, ToolAnnotations } from "@modelcontextprotocol/server";
+import type { Env } from "hono";
 import type { McpUiResourceCsp } from "@modelcontextprotocol/ext-apps";
 import type { RequestContext } from "./context.js";
 import type { UiPermissions } from "./views/types.js";
@@ -116,9 +117,9 @@ export interface ToolRef<Name extends string = string, Input = Record<string, un
 }
 /**
  * Result a tool callback may return, keyed by the tool's inferred output
- * type. Completed calls use the SDK's raw {@link CallToolResult}; interactive
- * calls may return an {@link InputRequiredResult}. There is no
- * framework-specific result layer.
+ * type. Prefer the SDK's raw {@link CallToolResult}; interactive calls may
+ * return an {@link InputRequiredResult}. Deprecated response helpers
+ * (`text`, `object`, …) return the same envelope and remain accepted.
  *
  * Without an `outputSchema` (`TOutput = never`) any `CallToolResult` is
  * accepted. With one, the result must carry `structuredContent` matching the
@@ -173,4 +174,4 @@ export type InferToolName<T> = T extends {
  * an `outputSchema` must return matching `structuredContent` or an `isError`
  * result; tools without one accept any {@link CallToolResult}.
  */
-export type ToolCallback<TInput = Record<string, unknown>, TOutput = never, TUser = never, HasOAuth extends boolean = false> = (params: TInput, ctx: RequestContext<TUser, HasOAuth>) => ToolResult<TOutput> | Promise<ToolResult<TOutput>>;
+export type ToolCallback<TInput = Record<string, unknown>, TOutput = never, TUser = never, HasOAuth extends boolean = false, TEnv extends Env = Env> = (params: TInput, ctx: RequestContext<TUser, HasOAuth, TEnv>) => ToolResult<TOutput> | Promise<ToolResult<TOutput>>;

package/dist/views/routes.d.ts

@@ -23,7 +23,7 @@ export declare function createViewAssetsHandler(basePath: string, views: Readonl
  * cross-origin sandboxed view iframes.
  *
  * Node filesystem modules load only on the first public-asset request so the
- * library entry stays edge-safe for `getHandler()`-only deployments.
+ * library entry stays edge-safe for `server.fetch` deployments.
  *
  * @param basePath - MCP mount prefix (e.g. `/mcp`).
  * @param views - Primed view registry; empty skips mounting.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mcp-use",
   "type": "module",
-  "version": "2.0.0-beta.28",
+  "version": "2.0.0-beta.30",
   "description": "MCP framework and CLI built on the official v2 SDK",
   "author": "mcp-use, Inc.",
   "license": "MIT",
@@ -87,9 +87,10 @@
     "@modelcontextprotocol/core": "https://pkg.pr.new/@modelcontextprotocol/core@f60b40179b0f090f6d64248be1312245a160b5ee",
     "@modelcontextprotocol/ext-apps": "https://pkg.pr.new/@modelcontextprotocol/ext-apps@432d42bb02a569078ab31ab6458428df6027809d",
     "@modelcontextprotocol/server": "https://pkg.pr.new/@modelcontextprotocol/server@f60b40179b0f090f6d64248be1312245a160b5ee",
+    "hono": "^4.12.27",
     "jose": "^6.1.3",
-    "@mcp-use/cli": "4.0.0-beta.4",
-    "@mcp-use/inspector": "20.0.0-beta.20"
+    "@mcp-use/cli": "4.0.0-beta.6",
+    "@mcp-use/inspector": "20.0.0-beta.22"
   },
   "peerDependencies": {
     "@mcp-use/client": "^2.0.0-alpha.0",
@@ -123,7 +124,7 @@
     "vitest": "^4.1.9",
     "zod": "^4.4.3",
     "@mcp-use/client": "2.0.0-beta.11",
-    "mcp-use": "2.0.0-beta.28"
+    "mcp-use": "2.0.0-beta.30"
   },
   "publishConfig": {
     "access": "public"