fix: bound HTTP bodies before MCP adapter conversion

Reject unsupported POST media types before consuming uploads. Route accepted bodies through the bounded Express reader and always supply a parsed value to prevent the SDK raw-stream fallback. Keep parser and encoding failures in JSON-RPC form. Regression tests cover unfinished uploads, chunked and gzip size limits, empty bodies and unsupported encodings; all 56 tests pass.

Author: ccbbccbb

docs/mcp-2026-07-28-upgrade.md

@@ -35,6 +35,7 @@ Verified against the registry on September 13, 2026: the server, Node, Express,
 - Added Host and Origin validation before the HTTP MCP handler.
 - Added application-level enforcement of the protocol-version header and both accepted response types, including `q=0` exclusions. These supplement SDK v2.0.0's header value validation.
 - Return JSON-RPC parse errors for malformed JSON and a JSON error for the 1 MB request limit; syntactically valid non-RPC JSON remains the SDK's responsibility.
+- Reject non-JSON or missing POST media types before reading the body. All accepted bodies pass through Express's 1 MB reader (including chunked and decompressed uploads); the Node adapter always receives a parsed value so its unbounded raw-stream fallback is never used. Unsupported encodings also return JSON-RPC errors.
 - Verified Base64 sentinel decoding for `Mcp-Name` and `x-mcp-header` parameter validation. Current EVM tools do not declare routing headers; an annotated test tool verifies missing, malformed, mismatched, and correctly encoded headers before handler execution.
 - Added MCP OAuth resource-server support for HTTP:
   - localhost can run without authorization
@@ -117,6 +118,7 @@ The automated MCP integration tests cover:
 - resource reads and a read-only tool call
 - final `HeaderMismatch` and `UnsupportedProtocolVersion` error codes
 - real Express HTTP requests covering media types, required headers, Host/Origin rejection, parser errors, removed methods, and the SDK client
+- unfinished uploads proving unsupported media types are rejected before body completion, plus chunked and gzip uploads exceeding the decoded size limit
 - packaged Node CLI clients exercising tools, resource reads, and prompts over modern and legacy stdio, plus startup exit-code propagation
 - local authorization opt-out, remote fail-closed behavior, OAuth metadata validation, RFC 7662 introspection, audience checks, and scopes
 

src/server/http-app.ts

@@ -7,6 +7,7 @@ import express, {
 import {
   bearerAuthChallengeResponse,
   createMcpHandler,
+  isJsonContentType,
   OAuthError,
   OAuthErrorCode,
   ProtocolErrorCode
@@ -77,9 +78,24 @@ export function createHttpApp(options: HttpAppOptions): HttpApp {
       return;
     }
 
+    if (req.method === "POST" && !isJsonContentType(req.get("Content-Type") ?? null)) {
+      res.status(415).json({
+        jsonrpc: "2.0",
+        error: {
+          code: ProtocolErrorCode.InvalidRequest,
+          message: "Content-Type must be application/json"
+        }
+      });
+      return;
+    }
+
     next();
   };
 
+  // Media types are checked above. Force every remaining body through this
+  // bounded reader, including chunked uploads and decompressed JSON.
+  const parseMcpBody = express.json({ limit: "1mb", strict: false, type: () => true });
+
   const handleMcpRequest = (req: Request, res: Response) => {
     // The v2 entry validates header values but permits an absent version header.
     if (req.method === "POST" && !req.get("MCP-Protocol-Version")) {
@@ -107,7 +123,9 @@ export function createHttpApp(options: HttpAppOptions): HttpApp {
       return;
     }
 
-    void nodeHandler(req, res, req.body);
+    // An undefined parsedBody makes the SDK buffer the raw stream without a limit.
+    // Treat an absent body as invalid JSON-RPC instead of entering that fallback.
+    void nodeHandler(req, res, req.body ?? null);
   };
 
   if (oauthConfiguration) {
@@ -152,21 +170,21 @@ export function createHttpApp(options: HttpAppOptions): HttpApp {
         requiredScopes: oauthConfiguration.requiredScopes,
         resourceMetadataUrl
       }),
-      express.json({ limit: "1mb", strict: false }),
+      parseMcpBody,
       requireOperationScope,
       handleMcpRequest
     );
   } else {
     app.all(
       "/mcp",
       validateMcpRequest,
-      express.json({ limit: "1mb", strict: false }),
+      parseMcpBody,
       handleMcpRequest
     );
   }
 
   app.use((error: unknown, _req: Request, res: Response, next: NextFunction) => {
-    const parserError = error as { type?: string } | undefined;
+    const parserError = error as { type?: string; status?: number } | undefined;
     if (parserError?.type === "entity.parse.failed") {
       res.status(400).json({
         jsonrpc: "2.0",
@@ -181,6 +199,13 @@ export function createHttpApp(options: HttpAppOptions): HttpApp {
       });
       return;
     }
+    if (parserError?.status === 400 || parserError?.status === 415) {
+      res.status(parserError.status).json({
+        jsonrpc: "2.0",
+        error: { code: ProtocolErrorCode.InvalidRequest, message: "Invalid request body or encoding" }
+      });
+      return;
+    }
     next(error);
   });
 

test/http-protocol.test.ts

@@ -1,5 +1,6 @@
 import { afterAll, beforeAll, describe, expect, test } from "bun:test";
-import type { Server } from "node:http";
+import { request, type Server } from "node:http";
+import { gzipSync } from "node:zlib";
 import type { AddressInfo } from "node:net";
 import { Client, StreamableHTTPClientTransport } from "@modelcontextprotocol/client";
 import { createHttpApp } from "../src/server/http-app.js";
@@ -65,6 +66,75 @@ function post(options: {
 }
 
 describe("Streamable HTTP protocol boundary", () => {
+  test("rejects unsupported media types before waiting for the request body", async () => {
+    for (const contentType of [undefined, "text/plain", "text/plain; a=application/json"]) {
+      for (const framing of ["length", "chunked"]) {
+        const response = await new Promise<{ status: number; type?: string; body: string }>((resolve, reject) => {
+          const req = request(endpoint, {
+            method: "POST",
+            headers: {
+              "Accept": "application/json, text/event-stream",
+              "MCP-Protocol-Version": MODERN_PROTOCOL_VERSION,
+              "Mcp-Method": "server/discover",
+              ...(contentType ? { "Content-Type": contentType } : {}),
+              ...(framing === "length" ? { "Content-Length": 2 * 1024 * 1024 } : { "Transfer-Encoding": "chunked" })
+            }
+          });
+          const deadline = setTimeout(() => {
+            req.destroy();
+            reject(new Error("Server waited for an unsupported request body"));
+          }, 2000);
+          req.on("error", error => {
+            clearTimeout(deadline);
+            reject(error);
+          });
+          req.on("response", res => {
+            let body = "";
+            res.setEncoding("utf8");
+            res.on("data", chunk => { body += chunk; });
+            res.on("end", () => {
+              clearTimeout(deadline);
+              resolve({ status: res.statusCode!, type: res.headers["content-type"], body });
+              req.destroy();
+            });
+          });
+          // Deliberately leave the upload unfinished: status-only tests miss buffering.
+          req.write("{");
+        });
+        expect(response.status).toBe(415);
+        expect(response.type).toContain("application/json");
+        expect(JSON.parse(response.body).error.code).toBe(-32600);
+      }
+    }
+  }, 15000);
+
+  test("limits chunked and decompressed JSON bodies", async () => {
+    const body = JSON.stringify({ padding: "x".repeat(1100 * 1024) });
+    const chunked = await new Promise<{ status: number; body: string }>((resolve, reject) => {
+      const req = request(endpoint, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", "Transfer-Encoding": "chunked" }
+      }, res => {
+        let responseBody = "";
+        res.setEncoding("utf8");
+        res.on("data", chunk => { responseBody += chunk; });
+        res.on("end", () => resolve({ status: res.statusCode!, body: responseBody }));
+      });
+      req.on("error", reject);
+      req.end(body);
+    });
+    expect(chunked.status).toBe(413);
+    expect(JSON.parse(chunked.body).error.code).toBe(-32600);
+
+    const compressed = await fetch(endpoint, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", "Content-Encoding": "gzip" },
+      body: gzipSync(body)
+    });
+    expect(compressed.status).toBe(413);
+    expect((await compressed.json() as { error: { code: number } }).error.code).toBe(-32600);
+  });
+
   test("serves an SDK client without protocol sessions", async () => {
     const client = new Client({ name: "http-test", version: "1.0.0" }, {
       versionNegotiation: { mode: { pin: MODERN_PROTOCOL_VERSION } }
@@ -92,6 +162,22 @@ describe("Streamable HTTP protocol boundary", () => {
     }));
   });
 
+  test("returns JSON-RPC errors for empty bodies and unsupported encodings", async () => {
+    const empty = await post({ rawBody: "" });
+    expect(empty.status).toBe(400);
+    expect((await empty.json() as { error: { code: number } }).error.code).toBe(-32600);
+
+    for (const headers of [
+      { "Content-Type": "application/json; charset=iso-8859-1" },
+      { "Content-Encoding": "unsupported" }
+    ] as Record<string, string>[]) {
+      const response = await post({ headers });
+      expect(response.status).toBe(415);
+      expect(response.headers.get("Content-Type")).toContain("application/json");
+      expect((await response.json() as { error: { code: number } }).error.code).toBe(-32600);
+    }
+  });
+
   test("rejects non-JSON media types and accepts JSON parameters", async () => {
     for (const type of ["text/plain", "text/plain; a=application/json"]) {
       const response = await post({ headers: { "Content-Type": type } });