Preserve the 1 MiB SSE event default

Author: Kludex

docs/client/transports.md

@@ -54,7 +54,7 @@ Pass `max_sse_event_size` when a server sends a large tool result or notificatio
 --8<-- "docs_src/client_transports/tutorial005.py"
 ```
 
-The default is 16 MiB per event, measured in bytes before the event is parsed. The limit applies to
+The default is 1 MiB per event, measured in bytes before the event is parsed. The limit applies to
 POST responses, the GET stream, and resumed streams. An oversized event in a POST response or resumed
 stream fails that request with an error naming the limit. On the background GET stream, the client logs
 the error and retries the stream. Set `max_sse_event_size=None` to disable the cap when you trust the

docs/migration.md

@@ -2104,7 +2104,7 @@ async with http_client:
 
 v1's internal client set `follow_redirects=True`. You don't need it on your own client: the transport follows a method-preserving redirect within the endpoint's origin (a trailing-slash 307/308, say) itself, and does not follow one anywhere else, whatever the client is configured to do.
 
-`streamable_http_client` itself keeps a small signature — `streamable_http_client(url, *, http_client=None, terminate_on_close=True, max_sse_event_size=16 * 1024 * 1024)` — and now yields a 2-tuple (next section). The removed function's other parameters map onto the client you build:
+`streamable_http_client` itself keeps a small signature — `streamable_http_client(url, *, http_client=None, terminate_on_close=True, max_sse_event_size=1024 * 1024)` — and now yields a 2-tuple (next section). The removed function's other parameters map onto the client you build:
 
 - `headers`, `timeout`, `sse_read_timeout`, `auth`: set them on the `httpx2.AsyncClient` as above. `streamablehttp_client` defaulted to `httpx.Timeout(30, read=300)`; a bare `httpx2.AsyncClient()` falls back to httpx2's flat 5-second timeout, too short for the long-lived GET stream, so set `timeout=httpx2.Timeout(30, read=300)` (as shown) to keep v1's values. Omitting `http_client` still gives you a default client with those timeouts.
 - `httpx_client_factory`: gone with no replacement — call your factory yourself and pass the result as `http_client`.

src/mcp/client/streamable_http.py

@@ -58,7 +58,7 @@
 # Reconnection defaults
 DEFAULT_RECONNECTION_DELAY_MS = 1000  # 1 second fallback when server doesn't provide retry
 MAX_RECONNECTION_ATTEMPTS = 2  # Max retry attempts before giving up
-DEFAULT_MAX_SSE_EVENT_SIZE = 16 * 1024 * 1024
+DEFAULT_MAX_SSE_EVENT_SIZE = 1024 * 1024
 
 
 class StreamableHTTPError(Exception):

tests/client/test_streamable_http.py

@@ -59,8 +59,8 @@
 
 
 @pytest.mark.anyio
-async def test_default_sse_limit_accepts_a_tool_result_larger_than_one_mebibyte() -> None:
-    """SDK-defined: the Streamable HTTP default accepts a large tool result sent as one POST SSE event."""
+async def test_configured_sse_limit_accepts_a_tool_result_larger_than_one_mebibyte() -> None:
+    """SDK-defined: a larger SSE limit accepts a large tool result sent as one POST SSE event."""
     payload = "x" * (2 * 1024 * 1024)
 
     async def list_tools(ctx: ServerRequestContext, params: PaginatedRequestParams | None) -> ListToolsResult:
@@ -77,24 +77,27 @@ async def call_tool(ctx: ServerRequestContext, params: CallToolRequestParams) ->
         async with (
             manager.run(),
             httpx2.AsyncClient(transport=StreamingASGITransport(app)) as http,
-            Client(streamable_http_client("http://localhost/mcp", http_client=http), mode="legacy") as client,
+            Client(
+                streamable_http_client("http://localhost/mcp", http_client=http, max_sse_event_size=4 * 1024 * 1024),
+                mode="legacy",
+            ) as client,
         ):
             result = await client.call_tool("large", {})
 
     assert result.content == [TextContent(text=payload)]
 
 
 @pytest.mark.anyio
-async def test_configured_sse_limit_fails_one_tool_call_and_keeps_the_session_usable() -> None:
-    """SDK-defined: an oversized POST SSE event fails its request once and does not poison the session."""
+async def test_default_sse_limit_fails_one_large_tool_call_and_keeps_the_session_usable() -> None:
+    """SDK-defined: the 1 MiB default rejects one oversized tool result without poisoning the session."""
     calls: list[str] = []
 
     async def list_tools(ctx: ServerRequestContext, params: PaginatedRequestParams | None) -> ListToolsResult:
         return ListToolsResult(tools=[Tool(name=name, input_schema={"type": "object"}) for name in ("large", "small")])
 
     async def call_tool(ctx: ServerRequestContext, params: CallToolRequestParams) -> CallToolResult:
         calls.append(params.name)
-        return CallToolResult(content=[TextContent(text="x" * 2048 if params.name == "large" else "ok")])
+        return CallToolResult(content=[TextContent(text="x" * (2 * 1024 * 1024) if params.name == "large" else "ok")])
 
     manager = StreamableHTTPSessionManager(
         app=Server("bounded-result", on_list_tools=list_tools, on_call_tool=call_tool)
@@ -105,10 +108,7 @@ async def call_tool(ctx: ServerRequestContext, params: CallToolRequestParams) ->
         async with (
             manager.run(),
             httpx2.AsyncClient(transport=StreamingASGITransport(app)) as http,
-            Client(
-                streamable_http_client("http://localhost/mcp", http_client=http, max_sse_event_size=1024),
-                mode="legacy",
-            ) as client,
+            Client(streamable_http_client("http://localhost/mcp", http_client=http), mode="legacy") as client,
         ):
             with pytest.raises(MCPError) as exc_info:
                 await client.call_tool("large", {})
@@ -224,11 +224,11 @@ async def test_streamable_http_rejects_nonpositive_sse_event_limits(limit: int)
 
 @pytest.mark.anyio
 async def test_none_disables_the_sse_event_limit() -> None:
-    """SDK-defined: opting out accepts a POST SSE response larger than 16 MiB.
+    """SDK-defined: opting out accepts a POST SSE response larger than the 1 MiB default.
 
     The raw peer forces SSE for the request; the typed server can choose a JSON response instead.
     """
-    payload = "x" * (16 * 1024 * 1024 + 1)
+    payload = "x" * (2 * 1024 * 1024)
 
     def handler(request: httpx2.Request) -> httpx2.Response:
         body = json.loads(request.content)