mcp-use 2.0.0-beta.13 → 2.0.0-beta.15

package/dist/index.js

@@ -11,7 +11,7 @@ import {
 } from "./chunk-KIZ72TIK.js";
 import {
   synthesizeViewDocument
-} from "./chunk-STCR3P5O.js";
+} from "./chunk-XUI7QE2D.js";
 import {
   hasExplicitAssetsBase,
   originFromAssetsBase,
@@ -51,7 +51,7 @@ import {
   localhostAllowedOrigins,
   McpServer as SdkMcpServer,
   ResourceTemplate,
-  isInputRequiredResult
+  isInputRequiredResult as isInputRequiredResult2
 } from "@modelcontextprotocol/server";
 
 // src/branding.ts
@@ -563,6 +563,72 @@ function isGlobalCorsEnabled(cors) {
 }
 
 // src/middleware/mcp-middleware.ts
+import {
+  CallToolResultSchema,
+  GetPromptResultSchema,
+  ListPromptsResultSchema,
+  ListResourcesResultSchema,
+  ListToolsResultSchema,
+  ReadResourceResultSchema
+} from "@modelcontextprotocol/core";
+import { isInputRequiredResult } from "@modelcontextprotocol/server";
+var MCP_MIDDLEWARE_METHODS = [
+  "tools/call",
+  "tools/list",
+  "resources/read",
+  "resources/list",
+  "prompts/get",
+  "prompts/list"
+];
+function withMcpMiddlewareParams(request, params) {
+  if (typeof request !== "object" || request === null || Array.isArray(request)) {
+    throw new TypeError(
+      "[mcp-use] MCP middleware received an invalid downstream request"
+    );
+  }
+  return { ...request, params };
+}
+function createMcpMiddlewareEntry(pattern, handler) {
+  const normalizedPattern = normalizeMcpMiddlewarePattern(pattern);
+  const invoke = handler;
+  if (normalizedPattern !== "*" && !isMcpMiddlewareMethod(normalizedPattern)) {
+    throw new TypeError(
+      `Unsupported MCP middleware pattern "${pattern}". Use an exact MCP method or "mcp:*".`
+    );
+  }
+  if (normalizedPattern === "*") {
+    return {
+      pattern: normalizedPattern,
+      handler: async (ctx, next) => {
+        let downstreamCalled = false;
+        let downstreamResult;
+        await invoke(ctx, async () => {
+          downstreamResult = await next();
+          downstreamCalled = true;
+        });
+        if (!downstreamCalled) {
+          throw new Error(
+            `Wildcard MCP middleware "${normalizedPattern}" must call next()`
+          );
+        }
+        return downstreamResult;
+      }
+    };
+  }
+  return {
+    pattern: normalizedPattern,
+    handler: (ctx, next) => invoke(ctx, next)
+  };
+}
+function createMcpEventListenerEntry(pattern, handler) {
+  const { pattern: normalizedPattern, phase } = parseMcpPattern(pattern);
+  const invoke = handler;
+  return {
+    pattern: normalizedPattern,
+    phase,
+    handler: (ctx, result) => invoke(ctx, result)
+  };
+}
 function matchesPattern(pattern, method) {
   if (pattern === "*") return true;
   if (pattern.endsWith("/*")) {
@@ -571,8 +637,13 @@ function matchesPattern(pattern, method) {
   }
   return pattern === method;
 }
+function isMcpMiddlewareMethod(value) {
+  return MCP_MIDDLEWARE_METHODS.some((method) => method === value);
+}
 function composeMiddleware(entries, method, innerFn) {
-  const matching = entries.filter((e) => matchesPattern(e.pattern, method));
+  const matching = entries.filter(
+    (entry) => matchesPattern(entry.pattern, method)
+  );
   if (matching.length === 0) {
     return (_ctx) => innerFn();
   }
@@ -596,17 +667,69 @@ function freezeMiddlewareContext(ctx) {
   return Object.freeze({
     method: ctx.method,
     params: Object.freeze({ ...ctx.params }),
+    ...ctx.session !== void 0 && {
+      session: Object.freeze({ ...ctx.session })
+    },
     ...ctx.auth !== void 0 && { auth: ctx.auth },
-    state: ctx.state
+    state: new Map(ctx.state)
   });
 }
 async function runMcpOperation(middlewares, events, method, ctx, innerFn) {
   dispatchMcpEvents(events, method, "before", ctx);
   const chained = composeMiddleware(middlewares, method, innerFn);
   const result = await chained(ctx);
+  assertValidMiddlewareResult(method, result);
   dispatchMcpEvents(events, method, "complete", ctx, result);
   return result;
 }
+function assertValidMiddlewareResult(method, result) {
+  if ((method === "tools/call" || method === "resources/read" || method === "prompts/get") && isInputRequiredResult(result)) {
+    return;
+  }
+  const validation = (() => {
+    switch (method) {
+      case "tools/call":
+        assertArrayProperty(method, result, "content");
+        return CallToolResultSchema.safeParse(result);
+      case "tools/list":
+        assertArrayResult(method, result);
+        return ListToolsResultSchema.safeParse({ tools: result });
+      case "resources/read":
+        assertArrayProperty(method, result, "contents");
+        return ReadResourceResultSchema.safeParse(result);
+      case "resources/list":
+        assertArrayResult(method, result);
+        return ListResourcesResultSchema.safeParse({ resources: result });
+      case "prompts/get":
+        assertArrayProperty(method, result, "messages");
+        return GetPromptResultSchema.safeParse(result);
+      case "prompts/list":
+        assertArrayResult(method, result);
+        return ListPromptsResultSchema.safeParse({ prompts: result });
+      default:
+        throw new TypeError(`Unsupported MCP middleware method "${method}"`);
+    }
+  })();
+  if (!validation.success) {
+    throw new TypeError(
+      `[mcp-use] ${method} middleware returned an invalid result: ${validation.error.message}`
+    );
+  }
+}
+function assertArrayResult(method, result) {
+  if (!Array.isArray(result)) {
+    throw new TypeError(
+      `[mcp-use] ${method} middleware returned an invalid result: expected an array`
+    );
+  }
+}
+function assertArrayProperty(method, result, property) {
+  if (typeof result !== "object" || result === null || !Array.isArray(result[property])) {
+    throw new TypeError(
+      `[mcp-use] ${method} middleware returned an invalid result: expected a ${property} array`
+    );
+  }
+}
 function dispatchMcpEvents(events, method, phase, ctx, result) {
   const frozen = freezeMiddlewareContext(ctx);
   for (const entry of events) {
@@ -614,11 +737,7 @@ function dispatchMcpEvents(events, method, phase, ctx, result) {
       continue;
     }
     try {
-      if (phase === "before") {
-        entry.handler(frozen);
-      } else {
-        entry.handler(frozen, result);
-      }
+      entry.handler(frozen, result);
     } catch (error) {
       console.error(
         `[mcp-use] MCP event listener for "${entry.pattern}" (${phase}) threw:`,
@@ -716,6 +835,7 @@ function renderInspectorShell(options) {
         };
         // Read by the current inspector bundle to derive its own URLs.
         window.__MCP_BASE_PATH__ = basePath;
+        ${process.env.MCP_USE_DEV_CLI === "1" ? "window.__MCP_DEV_CLI__ = true;" : ""}
         ${serializedManufactChatUrl ? `window.__MANUFACT_CHAT_URL__ = ${serializedManufactChatUrl};` : ""}
         // The bundle carries Node-flavored dependencies that touch \`process\`
         // at module scope; give them the same browser polyfill the v1
@@ -1412,6 +1532,21 @@ function viewResourceConfig(_viewName, _entry, authorFacts, options) {
 }
 
 // src/server.ts
+function omitRootSchemaDialect(schema) {
+  if (typeof schema !== "object" || schema === null || Array.isArray(schema) || !("$schema" in schema)) {
+    return schema;
+  }
+  const emittedSchema = { ...schema };
+  delete emittedSchema["$schema"];
+  return emittedSchema;
+}
+function omitToolSchemaDialects(tools) {
+  return tools.map((tool) => ({
+    ...tool,
+    inputSchema: omitRootSchemaDialect(tool.inputSchema),
+    ...tool.outputSchema === void 0 ? {} : { outputSchema: omitRootSchemaDialect(tool.outputSchema) }
+  }));
+}
 var MCPServer = class _MCPServer {
   #config;
   #branding;
@@ -1692,7 +1827,9 @@ var MCPServer = class _MCPServer {
    * Register MCP operation middleware that intercepts JSON-RPC dispatch.
    *
    * Patterns use an `mcp:` prefix (for example `mcp:tools/call`, `mcp:*`).
-   * Middleware runs in registration order; call `next()` to continue the chain.
+   * 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
@@ -1704,10 +1841,7 @@ var MCPServer = class _MCPServer {
    */
   use(pattern, handler) {
     this.#assertNotStarted("middleware", pattern);
-    this.#mcpMiddlewares.push({
-      pattern: normalizeMcpMiddlewarePattern(pattern),
-      handler
-    });
+    this.#mcpMiddlewares.push(createMcpMiddlewareEntry(pattern, handler));
     return this;
   }
   /**
@@ -1727,12 +1861,7 @@ var MCPServer = class _MCPServer {
    */
   on(pattern, handler) {
     this.#assertNotStarted("event listener", pattern);
-    const { pattern: stripped, phase } = parseMcpPattern(pattern);
-    this.#mcpEventListeners.push({
-      pattern: stripped,
-      phase,
-      handler
-    });
+    this.#mcpEventListeners.push(createMcpEventListenerEntry(pattern, handler));
     return this;
   }
   /**
@@ -2076,7 +2205,7 @@ var MCPServer = class _MCPServer {
           return mcpRouteHandler(request);
         }
         const respond = async () => {
-          const { createLandingPageResponse } = await import("./landing-handler-Z7WDR4S2.js");
+          const { createLandingPageResponse } = await import("./landing-handler-WE66NIGB.js");
           return createLandingPageResponse(
             request,
             basePath,
@@ -2287,6 +2416,9 @@ var MCPServer = class _MCPServer {
     return {
       method,
       params,
+      ...ctx.sessionId !== void 0 && {
+        session: { sessionId: ctx.sessionId }
+      },
       ...ctx.http?.authInfo !== void 0 && { auth: ctx.http.authInfo },
       state: /* @__PURE__ */ new Map()
     };
@@ -2312,7 +2444,7 @@ var MCPServer = class _MCPServer {
     if (handlers === void 0) {
       return;
     }
-    const wrapListMethod = (method, resultKey) => {
+    const wrapListMethod = (method, resultKey, transform) => {
       const original = handlers.get(method);
       if (original === void 0) {
         return;
@@ -2321,27 +2453,50 @@ var MCPServer = class _MCPServer {
         return;
       }
       const wrapped = async (request, extra) => {
-        const authInfo = extra?.http?.authInfo;
-        const mwCtx = {
+        const serverContext = extra;
+        const params = request.params ?? {};
+        const mwCtx = this.#createMiddlewareContext(
           method,
-          params: {},
-          ...authInfo !== void 0 && { auth: authInfo },
-          state: /* @__PURE__ */ new Map()
-        };
+          params,
+          serverContext
+        );
+        let originalEnvelope;
         const innerFn = async () => {
-          const result = await original(request, extra);
-          return result[resultKey] ?? result;
+          const downstreamRequest = withMcpMiddlewareParams(
+            request,
+            mwCtx.params
+          );
+          const result = await original(downstreamRequest, extra);
+          if (typeof result !== "object" || result === null) {
+            throw new TypeError(
+              `[mcp-use] ${method} handler returned a non-object result`
+            );
+          }
+          originalEnvelope = result;
+          const items = originalEnvelope[resultKey];
+          if (!Array.isArray(items)) {
+            throw new TypeError(
+              `[mcp-use] ${method} handler result is missing a ${resultKey} array`
+            );
+          }
+          return items;
         };
         const filtered = await this.#runMcpHook(method, mwCtx, innerFn);
-        if (Array.isArray(filtered)) {
-          return { [resultKey]: filtered };
+        if (!Array.isArray(filtered)) {
+          throw new TypeError(
+            `[mcp-use] ${method} middleware must return a ${resultKey} array`
+          );
         }
-        return filtered;
+        const emitted = transform?.(filtered) ?? filtered;
+        return {
+          ...originalEnvelope,
+          [resultKey]: emitted
+        };
       };
       wrapped.__mcpListWrapped = true;
       handlers.set(method, wrapped);
     };
-    wrapListMethod("tools/list", "tools");
+    wrapListMethod("tools/list", "tools", omitToolSchemaDialects);
     wrapListMethod("resources/list", "resources");
     wrapListMethod("prompts/list", "prompts");
   }
@@ -2370,7 +2525,11 @@ var MCPServer = class _MCPServer {
     const invokeTool = async (args, ctx) => {
       const mwCtx = this.#createMiddlewareContext(
         "tools/call",
-        { name: definition.name, arguments: args },
+        {
+          name: definition.name,
+          arguments: args,
+          ...ctx.mcpReq._meta !== void 0 && { _meta: ctx.mcpReq._meta }
+        },
         ctx
       );
       const innerFn = async () => {
@@ -2379,7 +2538,7 @@ var MCPServer = class _MCPServer {
           effectiveArgs,
           this.#toRequestContext(ctx)
         );
-        if (isInputRequiredResult(result) || wireResultMeta === void 0 || result.isError === true) {
+        if (isInputRequiredResult2(result) || wireResultMeta === void 0 || result.isError === true) {
           return result;
         }
         return {
@@ -2466,7 +2625,10 @@ var MCPServer = class _MCPServer {
       async (uri, ctx) => {
         const mwCtx = this.#createMiddlewareContext(
           "resources/read",
-          { uri: uri.href },
+          {
+            uri: uri.href,
+            ...ctx.mcpReq._meta !== void 0 && { _meta: ctx.mcpReq._meta }
+          },
           ctx
         );
         const innerFn = async () => callback(uri, this.#toRequestContext(ctx));
@@ -2504,7 +2666,10 @@ var MCPServer = class _MCPServer {
       async (uri, variables, ctx) => {
         const mwCtx = this.#createMiddlewareContext(
           "resources/read",
-          { uri: uri.href },
+          {
+            uri: uri.href,
+            ...ctx.mcpReq._meta !== void 0 && { _meta: ctx.mcpReq._meta }
+          },
           ctx
         );
         const innerFn = async () => callback(
@@ -2548,7 +2713,11 @@ var MCPServer = class _MCPServer {
     const invokePrompt = async (args, ctx) => {
       const mwCtx = this.#createMiddlewareContext(
         "prompts/get",
-        { name: definition.name, arguments: args },
+        {
+          name: definition.name,
+          arguments: args,
+          ...ctx.mcpReq._meta !== void 0 && { _meta: ctx.mcpReq._meta }
+        },
         ctx
       );
       const innerFn = async () => {
@@ -2586,7 +2755,7 @@ import {
   createRequestStateCodec,
   inputRequired as inputRequired2,
   inputResponse as inputResponse2,
-  isInputRequiredResult as isInputRequiredResult2
+  isInputRequiredResult as isInputRequiredResult3
 } from "@modelcontextprotocol/server";
 export {
   MCPServer,
@@ -2594,13 +2763,15 @@ export {
   completable,
   composeFetch,
   composeMiddleware,
+  createMcpEventListenerEntry,
+  createMcpMiddlewareEntry,
   createMcpMount,
   createRequestStateCodec,
   getRequestBag,
   hostValidationMiddleware,
   inputRequired2 as inputRequired,
   inputResponse2 as inputResponse,
-  isInputRequiredResult2 as isInputRequiredResult,
+  isInputRequiredResult3 as isInputRequiredResult,
   jsonBodyMiddleware,
   matchesPath,
   matchesPathPrefix,