mcp-use 2.0.0-beta.4 → 2.0.0-beta.41

package/dist/internal/resource-completion.js

@@ -0,0 +1 @@
+import{normalizeCompletions}from"../chunk-OJF6B5EU.js";export{normalizeCompletions};

package/dist/internal/usage.js

@@ -0,0 +1 @@
+import{flushUsage,recordUsage}from"../chunk-YBGMCISI.js";export{flushUsage,recordUsage};

package/dist/landing-handler-TG6LVQBI.js

@@ -0,0 +1 @@
+import{generateLandingPage}from"./chunk-GX6PGIEO.js";import{resolveServerOrigin}from"./chunk-PSKSL567.js";function createLandingPageResponse(request,basePath,config,branding,tools,prompts,resources){let origin=resolveServerOrigin(request),url=new URL(basePath,`${origin}/`).href,html=generateLandingPage({...config,url,...branding.favicon!==void 0&&{iconUrl:new URL("/favicon.ico",`${origin}/`).href,...branding.faviconMimeType!==void 0&&{iconType:branding.faviconMimeType}},tools:Array.from(tools,entry=>entry.definition),prompts:Array.from(prompts,entry=>entry.definition),resources:Array.from(resources,entry=>entry.definition)});return new Response(request.method==="HEAD"?null:html,{status:200,headers:{"cache-control":"no-store","content-type":"text/html; charset=utf-8","x-content-type-options":"nosniff"}})}export{createLandingPageResponse};

package/dist/landing-handler.d.ts

@@ -0,0 +1,23 @@
+import { type LandingPageOptions, type LandingPagePrompt, type LandingPageResource, type LandingPageTool } from "./landing.js";
+import type { ServerBranding } from "./branding.js";
+/**
+ * Render a landing-page response without loading the renderer on MCP requests.
+ *
+ * @param request - Classified HTML GET or HEAD request.
+ * @param basePath - Exact MCP endpoint path.
+ * @param config - Server identity and description.
+ * @param branding - Normalized browser and MCP identity branding.
+ * @param tools - Frozen tool registry values.
+ * @param prompts - Frozen prompt registry values.
+ * @param resources - Frozen static-resource registry values.
+ * @returns HTML response, with an empty body for HEAD.
+ *
+ * @internal
+ */
+export declare function createLandingPageResponse(request: Request, basePath: string, config: Pick<LandingPageOptions, "name" | "title" | "version" | "description">, branding: Pick<ServerBranding, "favicon" | "faviconMimeType">, tools: Iterable<{
+    definition: LandingPageTool;
+}>, prompts: Iterable<{
+    definition: LandingPagePrompt;
+}>, resources: Iterable<{
+    definition: LandingPageResource;
+}>): Response;

package/dist/landing.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Landing page generator for MCP server endpoints
+ *
+ * Generates SEO-friendly HTML with connection instructions for MCP servers
+ * from Claude Code, Cursor, VS Code, ChatGPT, and Manufact Inspector (hosted).
+ */
+/** A tool shown in the landing page's primitives list. */
+export interface LandingPageTool {
+    /** Protocol-facing tool name. */
+    name: string;
+    /** Optional human-readable tool title. */
+    title?: string;
+    /** Optional tool description. */
+    description?: string;
+}
+/** A prompt shown in the landing page's primitives list. */
+export interface LandingPagePrompt {
+    /** Protocol-facing prompt name. */
+    name: string;
+    /** Optional human-readable prompt title. */
+    title?: string;
+    /** Optional prompt description. */
+    description?: string;
+}
+/** A static resource shown in the landing page's primitives list. */
+export interface LandingPageResource {
+    /** Resource URI. */
+    uri: string;
+    /** Optional protocol-facing resource name. */
+    name?: string;
+    /** Optional human-readable resource title. */
+    title?: string;
+    /** Optional resource description. */
+    description?: string;
+}
+/** Inputs used to render the v1-compatible MCP server landing page. */
+export interface LandingPageOptions {
+    /** Protocol-facing server name. */
+    name: string;
+    /** Optional human-readable server title used as the page heading. */
+    title?: string;
+    /** Server version shown beside the heading. */
+    version: string;
+    /** Absolute public URL of the MCP endpoint. */
+    url: string;
+    /** Optional server description. */
+    description?: string;
+    /** Optional tools shown in the primitives list. */
+    tools?: readonly LandingPageTool[];
+    /** Optional prompts shown in the primitives list. */
+    prompts?: readonly LandingPagePrompt[];
+    /** Optional static resources shown in the primitives list. */
+    resources?: readonly LandingPageResource[];
+    /** Optional absolute URL for the icon displayed above the server heading. */
+    iconUrl?: string;
+    /** MIME type for the favicon link tag when known. */
+    iconType?: string;
+}
+/**
+ * Generates an HTML landing page with connection instructions
+ * for Claude Code, Cursor, VS Code, ChatGPT, and Manufact Inspector.
+ *
+ * @param options - Server identity, endpoint, icon, and primitive metadata.
+ * @returns HTML landing page with connection instructions
+ */
+export declare function generateLandingPage(options: LandingPageOptions): string;

package/dist/landing.js

@@ -0,0 +1 @@
+import{generateLandingPage}from"./chunk-GX6PGIEO.js";export{generateLandingPage};

package/dist/listen-address.d.ts

@@ -0,0 +1,8 @@
+/** Default bind address for Node listeners. */
+export declare const DEFAULT_LISTEN_HOST = "127.0.0.1";
+/** Default TCP port for Node listeners. */
+export declare const DEFAULT_LISTEN_PORT = 3000;
+/** Resolve an explicit value, then `HOST`, then configured value, then default. */
+export declare function resolveListenHost(explicitHost: string | undefined, configuredHost: string | undefined, env?: Readonly<Record<string, string | undefined>>): string;
+/** Resolve an explicit value, then `PORT`, then configured value, then default. */
+export declare function resolveListenPort(explicitPort: number | undefined, configuredPort: number | undefined, env?: Readonly<Record<string, string | undefined>>): number;

package/dist/logging.d.ts

@@ -28,4 +28,3 @@ export declare function resolveLogLevel(configured?: LogLevel): LogLevel;
  * `config.logging.enabled` is `false`.
  */
 export declare function requestLogger(options?: LoggingOptions): FetchMiddleware;
-//# sourceMappingURL=logging.d.ts.map

package/dist/mcp-proxy-NETCUGUD.js

@@ -0,0 +1,2 @@
+var PROXY_CLIENT_INSTALL_HINT=["[mcp-use] server.proxy() requires the optional @mcp-use/client package.","Install it in your project:","","  npm install @mcp-use/client"].join(`
+`);function passthroughJsonSchema(schema){return{"~standard":{version:1,vendor:"mcp-use-proxy",validate(value){return{value}},jsonSchema:{input:()=>schema,output:()=>schema}}}}function promptArgsToJsonSchema(args){let properties=Object.create(null),required=[];for(let arg of args??[])properties[arg.name]={type:"string",...arg.description!==void 0&&{description:arg.description}},arg.required===!0&&required.push(arg.name);return{type:"object",properties,...required.length>0&&{required}}}function prefixedName(namespace,name){return`${namespace}_${name}`}function proxiedResourceUri(namespace,uri){return`mcp-use-proxy:///${encodeURIComponent(namespace)}/${encodeURIComponent(uri)}`}function isConnection(value){if(value===null||typeof value!="object")return!1;let candidate=value;return typeof candidate.listTools=="function"&&typeof candidate.callTool=="function"&&typeof candidate.readResource=="function"&&typeof candidate.listPrompts=="function"&&typeof candidate.getPrompt=="function"}function isClientPackageMissing(error){if(!(error instanceof Error))return!1;let code=error.code;return(code==="ERR_MODULE_NOT_FOUND"||code==="MODULE_NOT_FOUND")&&error.message.includes("@mcp-use/client")}function proxyDiagnostic(message,error){if(error===void 0){console.error(`[mcp-use] ${message}`);return}let detail=error instanceof Error?error.message:String(error);console.error(`[mcp-use] ${message}: ${detail}`)}function proxyClientInstallError(error){return isClientPackageMissing(error)?new Error(PROXY_CLIENT_INSTALL_HINT,{cause:error}):void 0}async function loadProxyClient(importer=()=>import("@mcp-use/client")){try{return await importer()}catch(error){let installError=proxyClientInstallError(error);throw installError!==void 0?installError:error}}function supports(connection,capability){return connection.supports?.(capability)!==!1}async function introspect(namespace,connection){let tools=[];if(supports(connection,"tools"))try{tools=await connection.listTools()}catch(error){proxyDiagnostic(`Failed to introspect tools from upstream MCP server "${namespace}"`,error)}let resources=[];if(supports(connection,"resources"))try{connection.listAllResources!==void 0?resources=(await connection.listAllResources()).resources:connection.listResources!==void 0&&(resources=(await connection.listResources()).resources)}catch(error){proxyDiagnostic(`Failed to introspect resources from upstream MCP server "${namespace}"`,error)}let prompts=[];if(supports(connection,"prompts"))try{prompts=(await connection.listPrompts()).prompts}catch(error){proxyDiagnostic(`Failed to introspect prompts from upstream MCP server "${namespace}"`,error)}return{namespace,connection,tools,resources,prompts}}function mountPlan(host,plan){host.trackNamespace?.({tools:plan.tools.length,resources:plan.resources.length,prompts:plan.prompts.length});for(let tool of plan.tools){let name=prefixedName(plan.namespace,tool.name);if(host.hasTool(name)){proxyDiagnostic(`Skipping proxied tool "${name}" from upstream "${plan.namespace}" because that name is already registered`);continue}let definition={name,...tool.title!==void 0&&{title:tool.title},...tool.description!==void 0&&{description:tool.description},...tool.annotations!==void 0&&{annotations:tool.annotations},...tool.inputSchema!==void 0&&{inputSchema:passthroughJsonSchema(tool.inputSchema)},...tool.outputSchema!==void 0&&{outputSchema:passthroughJsonSchema(tool.outputSchema)}},upstreamName=tool.name,callback=async(params,ctx)=>{let progressForwarding=Promise.resolve();try{return await plan.connection.callTool(upstreamName,params,{signal:ctx.signal,onprogress:progress=>{progressForwarding=progressForwarding.then(async()=>{try{await ctx.reportProgress(progress.progress,progress.total,progress.message)}catch(error){proxyDiagnostic(`Failed to forward progress for proxied tool "${definition.name}"`,error)}})}})}finally{await progressForwarding}};host.registerTool(definition,callback)}for(let resource of plan.resources){let name=prefixedName(plan.namespace,resource.name);if(host.hasResource(name)){proxyDiagnostic(`Skipping proxied resource "${name}" from upstream "${plan.namespace}" because that name is already registered`);continue}let upstreamUri=resource.uri;host.registerResource({name,uri:proxiedResourceUri(plan.namespace,upstreamUri),...resource.title!==void 0&&{title:resource.title},...resource.description!==void 0&&{description:resource.description},...resource.mimeType!==void 0&&{mimeType:resource.mimeType}},async(_uri,ctx)=>plan.connection.readResource(upstreamUri,{signal:ctx.signal}))}for(let prompt of plan.prompts){let name=prefixedName(plan.namespace,prompt.name);if(host.hasPrompt(name)){proxyDiagnostic(`Skipping proxied prompt "${name}" from upstream "${plan.namespace}" because that name is already registered`);continue}let upstreamName=prompt.name;host.registerPrompt({name,...prompt.title!==void 0&&{title:prompt.title},...prompt.description!==void 0&&{description:prompt.description},schema:passthroughJsonSchema(promptArgsToJsonSchema(prompt.arguments))},async params=>plan.connection.getPrompt(upstreamName,params))}}async function mountProxyConnection(host,connection){if(host.isStarted())throw new Error("Cannot call proxy() after the server has started: register upstream servers before listen()/server.fetch.");let namespace=connection.info.server.name,plan=await introspect(namespace,connection);mountPlan(host,plan)}function toClientConfig(config){return{url:config.url,...config.headers!==void 0&&{headers:config.headers},...config.authToken!==void 0&&{authToken:config.authToken},...config.timeout!==void 0&&{timeout:config.timeout},...config.fetch!==void 0&&{fetch:config.fetch},...config.protocolNegotiation!==void 0&&{protocolNegotiation:config.protocolNegotiation},oauth:!1}}async function mountProxyServers(host,servers){if(host.isStarted())throw new Error("Cannot call proxy() after the server has started: register upstream servers before listen()/server.fetch.");let{MCPClient}=await loadProxyClient(),clientServers=Object.fromEntries(Object.entries(servers).map(([name,config])=>[name,toClientConfig(config)])),owner=new MCPClient({mcpServers:clientServers});try{let plans=[];for(let namespace of Object.keys(clientServers)){let connection;try{connection=await owner.connect(namespace)}catch(error){proxyDiagnostic(`Failed to connect to upstream MCP server "${namespace}"`,error);continue}plans.push(await introspect(namespace,connection))}for(let plan of plans)mountPlan(host,plan);host.trackOwner(owner)}catch(error){throw await owner.close().catch(()=>{}),error}}function isProxyConnection(value){return isConnection(value)}export{isProxyConnection,mountProxyConnection,mountProxyServers,proxyClientInstallError};

package/dist/mcp-proxy.d.ts

@@ -0,0 +1,158 @@
+import type { CallToolResult, GetPromptResult, InputRequiredResult, PromptArgument, ReadResourceResult, ToolAnnotations } from "@modelcontextprotocol/server";
+import type { PromptCallback, PromptDefinition } from "./prompts.js";
+import type { ResourceCallback, ResourceDefinition } from "./resources.js";
+import type { ToolCallback, ToolDefinition } from "./tools.js";
+/** HTTP connection settings accepted by {@link MCPServer.proxy}. */
+export interface ProxyHttpConfig {
+    /** Upstream MCP endpoint URL. */
+    url: string;
+    /** Extra headers sent on every upstream request. */
+    headers?: Record<string, string>;
+    /** Bearer token sent to the upstream server. */
+    authToken?: string;
+    /** Connection timeout in milliseconds. */
+    timeout?: number;
+    /** Fetch implementation used for upstream HTTP requests. */
+    fetch?: typeof fetch;
+    /** Protocol negotiation mode forwarded to `@mcp-use/client`. */
+    protocolNegotiation?: "auto" | "legacy" | {
+        pin: string;
+    };
+}
+/** Connection settings for one upstream server. */
+export type ProxyServerConfig = ProxyHttpConfig;
+/** Progress payload received while a proxied tool is running. */
+export interface ProxyProgress {
+    /** Completed work units. */
+    progress: number;
+    /** Total work units, when known. */
+    total?: number | undefined;
+    /** Human-readable progress detail. */
+    message?: string | undefined;
+}
+/** Request controls used when forwarding calls to an upstream connection. */
+export interface ProxyRequestOptions {
+    /** Aborts the upstream request when the downstream request is cancelled. */
+    signal?: AbortSignal;
+    /** Receives upstream progress notifications. */
+    onprogress?: (progress: ProxyProgress) => void;
+}
+/** Structural connection contract accepted by the low-level proxy overload. */
+export interface ProxyConnection {
+    /** Negotiated metadata used to derive the automatic capability namespace. */
+    readonly info: {
+        server: {
+            name: string;
+        };
+    };
+    /** Whether the upstream advertised a named MCP capability. */
+    supports?(capability: string): boolean;
+    /** List upstream tools. */
+    listTools(): Promise<ProxyTool[]>;
+    /** Forward a tool call. */
+    callTool(name: string, args?: Record<string, unknown>, options?: ProxyRequestOptions): Promise<CallToolResult | InputRequiredResult>;
+    /** List upstream resources, including pagination when supported. */
+    listAllResources?(): Promise<{
+        resources: ProxyResource[];
+    }>;
+    /** List one page of upstream resources. */
+    listResources?(): Promise<{
+        resources: ProxyResource[];
+    }>;
+    /** Read an upstream resource. */
+    readResource(uri: string, options?: ProxyRequestOptions): Promise<ReadResourceResult>;
+    /** List upstream prompts. */
+    listPrompts(): Promise<{
+        prompts: ProxyPrompt[];
+    }>;
+    /** Render an upstream prompt. */
+    getPrompt(name: string, args: Record<string, unknown>): Promise<GetPromptResult>;
+}
+/** Tool metadata consumed while introspecting an upstream connection. */
+export interface ProxyTool {
+    /** Upstream tool name. */
+    name: string;
+    /** Human-readable tool title. */
+    title?: string | undefined;
+    /** LLM-facing tool description. */
+    description?: string | undefined;
+    /** Upstream input JSON Schema. */
+    inputSchema?: Record<string, unknown> | undefined;
+    /** Upstream output JSON Schema. */
+    outputSchema?: Record<string, unknown> | undefined;
+    /** Upstream behavioral hints. */
+    annotations?: ToolAnnotations | undefined;
+}
+/** Resource metadata consumed while introspecting an upstream connection. */
+export interface ProxyResource {
+    /** Upstream resource name. */
+    name: string;
+    /** Original upstream resource URI. */
+    uri: string;
+    /** Human-readable resource title. */
+    title?: string | undefined;
+    /** Human-readable resource description. */
+    description?: string | undefined;
+    /** Resource media type. */
+    mimeType?: string | undefined;
+}
+/** Prompt metadata consumed while introspecting an upstream connection. */
+export interface ProxyPrompt {
+    /** Upstream prompt name. */
+    name: string;
+    /** Human-readable prompt title. */
+    title?: string | undefined;
+    /** Human-readable prompt description. */
+    description?: string | undefined;
+    /** String arguments accepted by the prompt. */
+    arguments?: PromptArgument[] | undefined;
+}
+/** Registration surface used while mounting proxied capabilities. @internal */
+export interface ProxyMountHost {
+    /** Whether the parent server has mounted its handler. */
+    isStarted(): boolean;
+    /** Whether a tool name is already registered. */
+    hasTool(name: string): boolean;
+    /** Whether a resource name is already registered. */
+    hasResource(name: string): boolean;
+    /** Whether a prompt name is already registered. */
+    hasPrompt(name: string): boolean;
+    /** Register a proxied tool. */
+    registerTool(definition: ToolDefinition, callback: ToolCallback): void;
+    /** Register a proxied resource. */
+    registerResource(definition: ResourceDefinition, callback: ResourceCallback): void;
+    /** Register a proxied prompt. */
+    registerPrompt(definition: PromptDefinition, callback: PromptCallback): void;
+    /** Track a proxy client owned by the parent server. */
+    trackOwner(owner: {
+        close(): Promise<void>;
+    }): void;
+    /** Record one successfully introspected upstream namespace. */
+    trackNamespace?(counts: {
+        tools: number;
+        resources: number;
+        prompts: number;
+    }): void;
+}
+/** Convert a missing optional-client import into the proxy install error. @internal */
+export declare function proxyClientInstallError(error: unknown): Error | undefined;
+/**
+ * Mount one existing upstream connection on a parent server.
+ *
+ * @param host - Parent server registration surface.
+ * @param connection - Ready `@mcp-use/client` v2 connection.
+ * @internal
+ */
+export declare function mountProxyConnection(host: ProxyMountHost, connection: ProxyConnection): Promise<void>;
+/**
+ * Connect and mount namespace-keyed upstream servers through
+ * `@mcp-use/client` v2.
+ *
+ * @param host - Parent server registration surface.
+ * @param servers - Namespace-keyed upstream client configuration.
+ *
+ * @internal
+ */
+export declare function mountProxyServers(host: ProxyMountHost, servers: Record<string, ProxyServerConfig>): Promise<void>;
+/** Determine whether a proxy argument is an existing connection. @internal */
+export declare function isProxyConnection(value: unknown): value is ProxyConnection;

package/dist/middleware/cors.d.ts

@@ -0,0 +1,10 @@
+import type { CorsOptions } from "../config.js";
+import type { FetchMiddleware } from "../fetch-app.js";
+/**
+ * Fetch middleware that adds CORS headers to every response.
+ *
+ * @internal Wired from {@link MCPServer} when `ServerConfig.cors` is set.
+ */
+export declare function corsFetchMiddleware(options: CorsOptions): FetchMiddleware;
+/** Whether global CORS middleware owns response headers for view assets. */
+export declare function isGlobalCorsEnabled(cors: CorsOptions | undefined): boolean;

package/dist/middleware/mcp-middleware.d.ts

@@ -0,0 +1,183 @@
+import type { AuthInfo, HandlerResultTypeMap, RequestTypeMap, ResultTypeMap } from "@modelcontextprotocol/server";
+import type { Context, Env, HonoRequest } from "hono";
+declare const MCP_MIDDLEWARE_METHODS: readonly ["tools/call", "tools/list", "resources/read", "resources/list", "prompts/get", "prompts/list"];
+/** MCP methods currently intercepted by {@link MCPServer.use}. */
+export type McpMiddlewareMethod = (typeof MCP_MIDDLEWARE_METHODS)[number];
+/** Params exposed by the SDK for a particular MCP request method. */
+export type McpMiddlewareParams<M extends McpMiddlewareMethod> = RequestTypeMap[M] extends {
+    params?: infer P;
+} ? NonNullable<P> : Record<string, never>;
+/**
+ * Method-specific params and middleware result types.
+ *
+ * List middleware intentionally operates on item arrays rather than protocol
+ * result envelopes. The server wrapper preserves the envelope around the
+ * transformed array.
+ */
+export interface McpMiddlewareOperationMap {
+    "tools/call": {
+        params: McpMiddlewareParams<"tools/call">;
+        result: HandlerResultTypeMap["tools/call"];
+    };
+    "tools/list": {
+        params: McpMiddlewareParams<"tools/list">;
+        result: ResultTypeMap["tools/list"]["tools"];
+    };
+    "resources/read": {
+        params: McpMiddlewareParams<"resources/read">;
+        result: HandlerResultTypeMap["resources/read"];
+    };
+    "resources/list": {
+        params: McpMiddlewareParams<"resources/list">;
+        result: ResultTypeMap["resources/list"]["resources"];
+    };
+    "prompts/get": {
+        params: McpMiddlewareParams<"prompts/get">;
+        result: HandlerResultTypeMap["prompts/get"];
+    };
+    "prompts/list": {
+        params: McpMiddlewareParams<"prompts/list">;
+        result: ResultTypeMap["prompts/list"]["prompts"];
+    };
+}
+/** Result exposed to middleware for a particular MCP method. */
+export type McpMiddlewareResult<M extends McpMiddlewareMethod> = McpMiddlewareOperationMap[M]["result"];
+/**
+ * Rebuild an SDK request with the params currently held by middleware.
+ *
+ * Middleware may replace `ctx.params`, so forwarding the request object that
+ * was captured before the chain ran would silently discard that replacement.
+ * @internal
+ */
+export declare function withMcpMiddlewareParams<M extends McpMiddlewareMethod>(request: unknown, params: McpMiddlewareOperationMap[M]["params"]): RequestTypeMap[M];
+type MiddlewareContextCommon<TEnv extends Env = Env> = Omit<Context<TEnv>, "req"> & {
+    /** Hono request for the originating HTTP exchange. */
+    request?: HonoRequest;
+    /**
+     * Deprecated v1-compatible alias for {@link MiddlewareContext.request}.
+     *
+     * @deprecated Use `request` instead.
+     */
+    req?: HonoRequest;
+    /** Session info when the underlying transport provides a session ID. */
+    session?: {
+        sessionId: string;
+    };
+    /** OAuth info extracted from the validated access token. */
+    auth?: AuthInfo;
+    /** Shared state for middleware participating in this request. */
+    state: Map<string, unknown>;
+};
+/**
+ * Context passed to MCP middleware.
+ *
+ * The conditional form preserves the correlation between `method` and
+ * `params` when more than one method is represented.
+ */
+export type MiddlewareContext<M extends McpMiddlewareMethod = McpMiddlewareMethod, TEnv extends Env = Env> = M extends McpMiddlewareMethod ? MiddlewareContextCommon<TEnv> & {
+    method: M;
+    params: McpMiddlewareOperationMap[M]["params"];
+} : never;
+/** Preferred explicit name for the method-correlated middleware context. */
+export type McpMiddlewareContext<M extends McpMiddlewareMethod = McpMiddlewareMethod, TEnv extends Env = Env> = MiddlewareContext<M, TEnv>;
+/** Context with narrowed params for `tools/call`. */
+export type ToolsCallMiddlewareContext = MiddlewareContext<"tools/call">;
+/** Context with narrowed params for `tools/list`. */
+export type ToolsListMiddlewareContext = MiddlewareContext<"tools/list">;
+/** Context with narrowed params for `resources/read`. */
+export type ResourcesReadMiddlewareContext = MiddlewareContext<"resources/read">;
+/** Context with narrowed params for `resources/list`. */
+export type ResourcesListMiddlewareContext = MiddlewareContext<"resources/list">;
+/** Context with narrowed params for `prompts/get`. */
+export type PromptsGetMiddlewareContext = MiddlewareContext<"prompts/get">;
+/** Context with narrowed params for `prompts/list`. */
+export type PromptsListMiddlewareContext = MiddlewareContext<"prompts/list">;
+/** Map retained for compatibility and convenient indexed lookup. */
+export type McpMiddlewarePatternMap<TEnv extends Env = Env> = {
+    [M in McpMiddlewareMethod]: MiddlewareContext<M, TEnv>;
+};
+/** Continue the middleware chain with the result type for method `M`. */
+export type McpMiddlewareNext<M extends McpMiddlewareMethod> = () => Promise<McpMiddlewareResult<M>>;
+/** Middleware for one exact MCP method. */
+export type McpExactMiddlewareFn<M extends McpMiddlewareMethod, TEnv extends Env = Env> = (ctx: MiddlewareContext<M, TEnv>, next: McpMiddlewareNext<M>) => Promise<McpMiddlewareResult<M>>;
+/**
+ * Type-preserving middleware over every wrapped MCP method.
+ *
+ * The global wildcard cannot inspect or replace a method-specific result. Its `next`
+ * resolves after downstream middleware, and the composer propagates that
+ * downstream result unchanged. It must call `next()` or throw.
+ */
+export type McpMiddlewareFn<Methods extends McpMiddlewareMethod = McpMiddlewareMethod, TEnv extends Env = Env> = (ctx: MiddlewareContext<Methods, TEnv>, next: () => Promise<void>) => Promise<void>;
+/** Exact MCP middleware methods plus the global pass-through wildcard. */
+export type McpMiddlewarePatternBody = McpMiddlewareMethod | "*";
+/** Canonical `mcp:` middleware patterns. */
+export type McpMiddlewarePattern = `mcp:${McpMiddlewarePatternBody}`;
+/** Observer patterns additionally support grouping related MCP methods. */
+export type McpEventPatternBody = McpMiddlewarePatternBody | "tools/*" | "resources/*" | "prompts/*";
+type McpEventBasePattern = `mcp:${McpEventPatternBody}`;
+type StripMcpPrefix<P extends string> = P extends `mcp:${infer Body}` ? Body : P;
+/** Methods selected by an MCP middleware or observer pattern. */
+export type McpMiddlewareMethodsForPattern<P extends string> = StripMcpPrefix<P> extends infer Body ? Body extends McpMiddlewareMethod ? Body : Body extends "tools/*" ? Extract<McpMiddlewareMethod, `tools/${string}`> : Body extends "resources/*" ? Extract<McpMiddlewareMethod, `resources/${string}`> : Body extends "prompts/*" ? Extract<McpMiddlewareMethod, `prompts/${string}`> : Body extends "*" ? McpMiddlewareMethod : never : never;
+/** Infer an exact or type-preserving wildcard handler from pattern `P`. */
+export type McpMiddlewareFnFor<P extends McpMiddlewarePattern, TEnv extends Env = Env> = StripMcpPrefix<P> extends infer Body ? Body extends McpMiddlewareMethod ? McpExactMiddlewareFn<Body, TEnv> : McpMiddlewareFn<McpMiddlewareMethodsForPattern<P>, TEnv> : never;
+/**
+ * Type-erased middleware adapter stored after registration.
+ *
+ * Exact handlers and the global wildcard are adapted to this common callable
+ * shape before insertion, following the SDK's request-handler storage model.
+ * @internal
+ */
+export interface McpMiddlewareEntry {
+    pattern: string;
+    handler: (ctx: MiddlewareContext, next: () => Promise<unknown>) => Promise<unknown>;
+}
+/**
+ * Adapt a public method-correlated handler for type-erased internal storage.
+ *
+ * The overload retains the public pattern/handler correlation. The broad
+ * implementation signature is the deliberate erasure boundary, like the
+ * official SDK's `setRequestHandler` implementation.
+ */
+export declare function createMcpMiddlewareEntry<P extends McpMiddlewarePattern, TEnv extends Env = Env>(pattern: P, handler: McpMiddlewareFnFor<P, TEnv>): McpMiddlewareEntry;
+/** Phase for MCP observer event listeners registered via `server.on()`. */
+export type McpEventPhase = "before" | "complete";
+/** Read-only observer context correlated by MCP method. */
+export type ReadonlyMiddlewareContext<M extends McpMiddlewareMethod = McpMiddlewareMethod, TEnv extends Env = Env> = M extends McpMiddlewareMethod ? Omit<MiddlewareContext<M, TEnv>, "params" | "state"> & {
+    readonly params: Readonly<McpMiddlewareOperationMap[M]["params"]>;
+    readonly state: ReadonlyMap<string, unknown>;
+} : never;
+/** Read-only observer invoked before an MCP handler runs. */
+export type McpEventListenerFn<Methods extends McpMiddlewareMethod = McpMiddlewareMethod, TEnv extends Env = Env> = <M extends Methods>(ctx: ReadonlyMiddlewareContext<M, TEnv>) => void;
+/** Read-only observer invoked after an MCP handler completes. */
+export type McpCompleteEventListenerFn<Methods extends McpMiddlewareMethod = McpMiddlewareMethod, TEnv extends Env = Env> = <M extends Methods>(ctx: ReadonlyMiddlewareContext<M, TEnv>, result: McpMiddlewareResult<M>) => void;
+type McpExactEventListenerFn<M extends McpMiddlewareMethod, TEnv extends Env = Env> = (ctx: ReadonlyMiddlewareContext<M, TEnv>) => void;
+type McpExactCompleteEventListenerFn<M extends McpMiddlewareMethod, TEnv extends Env = Env> = (ctx: ReadonlyMiddlewareContext<M, TEnv>, result: McpMiddlewareResult<M>) => void;
+/** MCP observer pattern, optionally targeting the completion phase. */
+export type McpEventPattern = McpEventBasePattern | `${McpEventBasePattern}:complete`;
+type StripCompleteSuffix<P extends string> = P extends `${infer Body}:complete` ? Body : P;
+/** Infer a typed before/complete observer from event pattern `P`. */
+export type McpEventListenerFnFor<P extends McpEventPattern, TEnv extends Env = Env> = StripCompleteSuffix<StripMcpPrefix<P>> extends infer Body ? Body extends McpMiddlewareMethod ? P extends `${string}:complete` ? McpExactCompleteEventListenerFn<Body, TEnv> : McpExactEventListenerFn<Body, TEnv> : P extends `${string}:complete` ? McpCompleteEventListenerFn<McpMiddlewareMethodsForPattern<StripCompleteSuffix<P>>, TEnv> : McpEventListenerFn<McpMiddlewareMethodsForPattern<StripCompleteSuffix<P>>, TEnv> : never;
+/** Internal type-erased observer entry. @internal */
+export interface McpEventListenerEntry {
+    pattern: string;
+    phase: McpEventPhase;
+    handler: (ctx: ReadonlyMiddlewareContext, result?: unknown) => void;
+}
+/** Adapt a public method-correlated observer for type-erased storage. */
+export declare function createMcpEventListenerEntry<P extends McpEventPattern, TEnv extends Env = Env>(pattern: P, handler: McpEventListenerFnFor<P, TEnv>): McpEventListenerEntry;
+/** Test whether a registered middleware or observer pattern matches a method. */
+export declare function matchesPattern(pattern: string, method: string): boolean;
+/** Compose matching middleware in FIFO registration order. */
+export declare function composeMiddleware<M extends McpMiddlewareMethod, TEnv extends Env = Env>(entries: McpMiddlewareEntry[], method: M, innerFn: () => Promise<McpMiddlewareResult<M>>): (ctx: MiddlewareContext<M, TEnv>) => Promise<McpMiddlewareResult<M>>;
+/** Build a read-only snapshot of middleware context for observer events. */
+export declare function freezeMiddlewareContext<M extends McpMiddlewareMethod, TEnv extends Env = Env>(ctx: MiddlewareContext<M, TEnv>): ReadonlyMiddlewareContext<M, TEnv>;
+/** Run before/complete observers around a method-correlated middleware chain. */
+export declare function runMcpOperation<M extends McpMiddlewareMethod, TEnv extends Env = Env>(middlewares: McpMiddlewareEntry[], events: McpEventListenerEntry[], method: M, ctx: MiddlewareContext<M, TEnv>, innerFn: () => Promise<McpMiddlewareResult<M>>): Promise<McpMiddlewareResult<M>>;
+/** Strip `mcp:` prefix and optional `:complete` suffix from event patterns. */
+export declare function parseMcpPattern(raw: string): {
+    pattern: string;
+    phase: McpEventPhase;
+};
+/** Normalize middleware pattern strings by stripping the `mcp:` prefix. */
+export declare function normalizeMcpMiddlewarePattern(raw: string): string;
+export {};

package/dist/mount-mcp.d.ts

@@ -44,8 +44,3 @@ export interface McpMount {
  * ```
  */
 export declare function createMcpMount(factory: McpServerFactory, options?: MountMcpOptions): McpMount;
-/**
- * @deprecated Use {@link createMcpMount} — returns the same mount without Hono.
- */
-export declare function mountMcp(factory: McpServerFactory, options?: MountMcpOptions): McpMount;
-//# sourceMappingURL=mount-mcp.d.ts.map

package/dist/next/config.d.ts

@@ -0,0 +1,38 @@
+interface NextHeader {
+    key: string;
+    value: string;
+}
+interface NextHeaderRule {
+    source: string;
+    headers: NextHeader[];
+}
+/** Minimal structural Next.js config type, avoiding a runtime Next dependency. */
+export interface NextConfigLike {
+    /** Preserve arbitrary Next.js settings while augmenting the fields we use. */
+    [key: string]: unknown;
+    headers?: () => NextHeaderRule[] | Promise<NextHeaderRule[]>;
+    outputFileTracingIncludes?: Record<string, string[]>;
+}
+/** Options for {@link withMcpUse}. */
+export interface WithMcpUseOptions {
+    /** Authored MCP server entry, relative to `projectRoot`. */
+    entry?: string;
+    /** Conventional MCP source directory containing the entry and `views/`. */
+    mcpDir?: string;
+    /** Explicit views directory, relative to `projectRoot`. */
+    viewsDir?: string;
+    /** MCP route mounted by the application. Defaults to `/api/mcp`. */
+    basePath?: string;
+    /** Next.js project root. Defaults to `process.cwd()`. */
+    projectRoot?: string;
+}
+/** @internal Exported for focused composition tests, not from `mcp-use/next`. */
+export declare function composeNextConfig<T extends NextConfigLike>(nextConfig: T, basePath: string): T & NextConfigLike;
+/**
+ * Add mcp-use build, CORS, and serverless tracing to a Next.js config.
+ *
+ * The MCP build runs when Next evaluates `next.config`, for both development
+ * and production builds. This removes the need for a separate prebuild script.
+ */
+export declare function withMcpUse<T extends NextConfigLike = NextConfigLike>(nextConfig?: T, options?: WithMcpUseOptions): Promise<T & NextConfigLike>;
+export {};

package/dist/next/handler.d.ts

@@ -0,0 +1,16 @@
+import type { MCPServer } from "../server.js";
+/** Route Handler exports returned by {@link createNextHandler}. */
+export interface NextMcpHandlers {
+    GET(request: Request): Promise<Response>;
+    POST(request: Request): Promise<Response>;
+    DELETE(request: Request): Promise<Response>;
+    OPTIONS(request: Request): Promise<Response>;
+}
+/**
+ * Create App Router method exports for an authored MCP server.
+ *
+ * The generated artifact contains only view registration data; application
+ * source continues to import its own server module. Initialization is lazy so
+ * importing a route during `next build` does not perform filesystem I/O.
+ */
+export declare function createNextHandler<TUser>(server: MCPServer<TUser>): NextMcpHandlers;

package/dist/next/index.d.ts

@@ -0,0 +1,4 @@
+export { createNextHandler } from "./handler.js";
+export type { NextMcpHandlers } from "./handler.js";
+export { withMcpUse } from "./config.js";
+export type { NextConfigLike, WithMcpUseOptions } from "./config.js";

package/dist/next/index.js

@@ -0,0 +1 @@
+import{readFile}from"fs/promises";import{join}from"path";function isViewManifestEntry(value){return typeof value!="object"||value===null||!("kind"in value)?!1:value.kind==="inline"?"js"in value&&typeof value.js=="string"&&"css"in value&&typeof value.css=="string":value.kind==="external"&&"entry"in value&&typeof value.entry=="string"&&"css"in value&&Array.isArray(value.css)&&value.css.every(item=>typeof item=="string")&&(!("scripts"in value)||Array.isArray(value.scripts)&&value.scripts.every(item=>typeof item=="string"))}function parseBuildManifest(raw,manifestPath){let parsed;try{parsed=JSON.parse(raw)}catch(error){let reason=error instanceof Error?error.message:String(error);throw new Error(`Invalid mcp-use build manifest at ${manifestPath}: ${reason}`)}if(typeof parsed!="object"||parsed===null||Array.isArray(parsed)||!("views"in parsed)||typeof parsed.views!="object"||parsed.views===null||Array.isArray(parsed.views)||!Object.values(parsed.views).every(isViewManifestEntry))throw new Error(`Invalid mcp-use build manifest at ${manifestPath}.`);return parsed.views}function createNextHandler(server){let projectRoot=process.cwd(),manifestPath=join(process.cwd(),".mcp-use","build","manifest.json"),handlerPromise,initialize=async()=>{let raw;try{raw=await readFile(manifestPath,"utf8")}catch(error){throw(typeof error=="object"&&error!==null&&"code"in error?error.code:void 0)==="ENOENT"?new Error(`No mcp-use build found at ${manifestPath}. Wrap next.config with withMcpUse() before mounting this route.`):error}return server.__primeViews(parseBuildManifest(raw,manifestPath),{projectRoot}),async request=>server.fetch(request)},handle=async request=>(handlerPromise??=initialize(),(await handlerPromise)(request));return{GET:handle,POST:handle,DELETE:handle,OPTIONS:async()=>new Response(null,{status:204,headers:{"Access-Control-Allow-Origin":"*","Access-Control-Allow-Methods":"GET, POST, DELETE, OPTIONS","Access-Control-Allow-Headers":"Authorization, Content-Type, Accept, Mcp-Protocol-Version, Mcp-Method, Mcp-Name, Mcp-Session-Id, Last-Event-ID","Access-Control-Expose-Headers":"Mcp-Session-Id"}})}}var DEFAULT_BASE_PATH="/api/mcp",BUILD_TRACE_GLOB="./.mcp-use/build/**/*",MCP_CORS_HEADERS=[{key:"Access-Control-Allow-Origin",value:"*"},{key:"Access-Control-Allow-Methods",value:"GET, POST, DELETE, OPTIONS"},{key:"Access-Control-Allow-Headers",value:"Authorization, Content-Type, Accept, Mcp-Protocol-Version, Mcp-Method, Mcp-Name, Mcp-Session-Id, Last-Event-ID"},{key:"Access-Control-Expose-Headers",value:"Mcp-Session-Id"}];function normalizeBasePath(value){let raw=value??DEFAULT_BASE_PATH;if(!raw.startsWith("/")||raw==="/"||raw.includes(":"))throw new Error(`withMcpUse basePath must be a concrete absolute path; received ${JSON.stringify(raw)}.`);return raw.replace(/\/+$/,"")}function mergeHeaders(existing,additions){let next=[...existing];for(let header of additions){let index=next.findIndex(candidate=>candidate.key.toLowerCase()===header.key.toLowerCase());index===-1?next.push(header):next[index]=header}return next}async function buildMcpProject(projectRoot,options){let{spawn}=process.getBuiltinModule("node:child_process"),{fileURLToPath}=process.getBuiltinModule("node:url"),args=[fileURLToPath(new URL("../bin.js",import.meta.url)),"build"];options.entry!==void 0&&args.push("--entry",options.entry),options.mcpDir!==void 0&&args.push("--mcp-dir",options.mcpDir),options.viewsDir!==void 0&&args.push("--views-dir",options.viewsDir),await new Promise((resolvePromise,reject)=>{let child=spawn(process.execPath,args,{cwd:projectRoot,env:process.env,stdio:"inherit"});child.once("error",reject),child.once("exit",(code,signal)=>{if(code===0){resolvePromise();return}reject(new Error(`mcp-use build failed${code===null?` with signal ${signal}`:` with exit code ${code}`}.`))})})}function composeNextConfig(nextConfig,basePath){let source=`${basePath}/:path*`,originalHeaders=nextConfig.headers?.bind(nextConfig),existingTrace=nextConfig.outputFileTracingIncludes??{},routeTrace=existingTrace[basePath]??[];return{...nextConfig,async headers(){let rules=originalHeaders===void 0?[]:await originalHeaders(),matchingIndex=rules.findIndex(rule=>rule.source===source);return matchingIndex===-1?[...rules,{source,headers:MCP_CORS_HEADERS}]:rules.map((rule,index)=>index===matchingIndex?{...rule,headers:mergeHeaders(rule.headers,MCP_CORS_HEADERS)}:rule)},outputFileTracingIncludes:{...existingTrace,[basePath]:[...new Set([...routeTrace,BUILD_TRACE_GLOB])]}}}async function withMcpUse(nextConfig={},options={}){let basePath=normalizeBasePath(options.basePath),projectRoot=options.projectRoot??process.cwd();return await buildMcpProject(projectRoot,options),composeNextConfig(nextConfig,basePath)}export{createNextHandler,withMcpUse};

package/dist/node-bridge.d.ts

@@ -49,4 +49,3 @@ export interface ToWebRequestOptions {
  * @param options - Optional abort signal for the constructed request.
  */
 export declare function toWebRequest(req: NodeIncomingMessageLike, parsedBody?: unknown, options?: ToWebRequestOptions): Promise<Request>;
-//# sourceMappingURL=node-bridge.d.ts.map