Merge branch 'modelcontextprotocol:main' into main

DebajitKumarPhukan · web-flow · commit 0d7d84d227a7 · 2025-09-06T12:03:45.000+05:30
diff --git a/README.md b/README.md
@@ -31,22 +31,32 @@
     - [Prompts](#prompts)
     - [Images](#images)
     - [Context](#context)
+      - [Getting Context in Functions](#getting-context-in-functions)
+      - [Context Properties and Methods](#context-properties-and-methods)
     - [Completions](#completions)
     - [Elicitation](#elicitation)
     - [Sampling](#sampling)
     - [Logging and Notifications](#logging-and-notifications)
     - [Authentication](#authentication)
     - [FastMCP Properties](#fastmcp-properties)
-    - [Session Properties](#session-properties-and-methods)
+    - [Session Properties and Methods](#session-properties-and-methods)
     - [Request Context Properties](#request-context-properties)
   - [Running Your Server](#running-your-server)
     - [Development Mode](#development-mode)
     - [Claude Desktop Integration](#claude-desktop-integration)
     - [Direct Execution](#direct-execution)
     - [Streamable HTTP Transport](#streamable-http-transport)
+      - [CORS Configuration for Browser-Based Clients](#cors-configuration-for-browser-based-clients)
     - [Mounting to an Existing ASGI Server](#mounting-to-an-existing-asgi-server)
+      - [StreamableHTTP servers](#streamablehttp-servers)
+        - [Basic mounting](#basic-mounting)
+        - [Host-based routing](#host-based-routing)
+        - [Multiple servers with path configuration](#multiple-servers-with-path-configuration)
+        - [Path configuration at initialization](#path-configuration-at-initialization)
+      - [SSE servers](#sse-servers)
   - [Advanced Usage](#advanced-usage)
     - [Low-Level Server](#low-level-server)
+      - [Structured Output Support](#structured-output-support)
     - [Writing MCP Clients](#writing-mcp-clients)
     - [Client Display Utilities](#client-display-utilities)
     - [OAuth Authentication for Clients](#oauth-authentication-for-clients)
@@ -400,7 +410,7 @@ def get_weather(city: str) -> WeatherData:
     """Get weather for a city - returns structured data."""
     # Simulated weather data
     return WeatherData(
-        temperature=72.5,
+        temperature=22.5,
         humidity=45.0,
         condition="sunny",
         wind_speed=5.2,
@@ -2137,6 +2147,7 @@ MCP servers declare capabilities during initialization:
 
 ## Documentation
 
+- [API Reference](https://modelcontextprotocol.github.io/python-sdk/api/)
 - [Model Context Protocol documentation](https://modelcontextprotocol.io)
 - [Model Context Protocol specification](https://spec.modelcontextprotocol.io)
 - [Officially supported servers](https://github.com/modelcontextprotocol/servers)
diff --git a/examples/servers/simple-resource/mcp_simple_resource/server.py b/examples/servers/simple-resource/mcp_simple_resource/server.py
@@ -2,6 +2,7 @@
 import click
 import mcp.types as types
 from mcp.server.lowlevel import Server
+from mcp.server.lowlevel.helper_types import ReadResourceContents
 from pydantic import AnyUrl, FileUrl
 from starlette.requests import Request
 
@@ -46,15 +47,15 @@ async def list_resources() -> list[types.Resource]:
         ]
 
     @app.read_resource()
-    async def read_resource(uri: AnyUrl) -> str | bytes:
+    async def read_resource(uri: AnyUrl):
         if uri.path is None:
             raise ValueError(f"Invalid resource path: {uri}")
         name = uri.path.replace(".txt", "").lstrip("/")
 
         if name not in SAMPLE_RESOURCES:
             raise ValueError(f"Unknown resource: {uri}")
 
-        return SAMPLE_RESOURCES[name]["content"]
+        return [ReadResourceContents(content=SAMPLE_RESOURCES[name]["content"], mime_type="text/plain")]
 
     if transport == "sse":
         from mcp.server.sse import SseServerTransport
diff --git a/examples/snippets/servers/structured_output.py b/examples/snippets/servers/structured_output.py
@@ -24,7 +24,7 @@ def get_weather(city: str) -> WeatherData:
     """Get weather for a city - returns structured data."""
     # Simulated weather data
     return WeatherData(
-        temperature=72.5,
+        temperature=22.5,
         humidity=45.0,
         condition="sunny",
         wind_speed=5.2,
diff --git a/pyproject.toml b/pyproject.toml
@@ -102,18 +102,36 @@ executionEnvironments = [
   { root = "examples/servers", reportUnusedFunction = false },
 ]
 
-[tool.ruff.lint]
-select = ["C4", "E", "F", "I", "PERF", "UP"]
-ignore = ["PERF203"]
-
 [tool.ruff]
 line-length = 120
 target-version = "py310"
 extend-exclude = ["README.md"]
 
+[tool.ruff.lint]
+select = [
+    "C4",    # flake8-comprehensions
+    "C90",   # mccabe
+    "E",     # pycodestyle
+    "F",     # pyflakes
+    "I",     # isort
+    "PERF",  # Perflint
+    "PL",    # Pylint
+    "UP",    # pyupgrade
+]
+ignore = ["PERF203", "PLC0415", "PLR0402"]
+mccabe.max-complexity = 24  # Default is 10
+
 [tool.ruff.lint.per-file-ignores]
 "__init__.py" = ["F401"]
 "tests/server/fastmcp/test_func_metadata.py" = ["E501"]
+"tests/shared/test_progress_notifications.py" = ["PLW0603"]
+
+[tool.ruff.lint.pylint]
+allow-magic-value-types = ["bytes", "float", "int", "str"]
+max-args = 23         # Default is 5
+max-branches = 23     # Default is 12
+max-returns = 13      # Default is 6
+max-statements = 102  # Default is 50
 
 [tool.uv.workspace]
 members = ["examples/servers/*", "examples/snippets"]
diff --git a/src/mcp/server/fastmcp/server.py b/src/mcp/server/fastmcp/server.py
@@ -182,9 +182,8 @@ def __init__(
                 raise ValueError("Cannot specify both auth_server_provider and token_verifier")
             if not auth_server_provider and not token_verifier:
                 raise ValueError("Must specify either auth_server_provider or token_verifier when auth is enabled")
-        else:
-            if auth_server_provider or token_verifier:
-                raise ValueError("Cannot specify auth_server_provider or token_verifier without auth settings")
+        elif auth_server_provider or token_verifier:
+            raise ValueError("Cannot specify auth_server_provider or token_verifier without auth settings")
 
         self._auth_server_provider = auth_server_provider
         self._token_verifier = token_verifier
diff --git a/src/mcp/server/fastmcp/utilities/func_metadata.py b/src/mcp/server/fastmcp/utilities/func_metadata.py
@@ -139,14 +139,14 @@ def pre_parse_json(self, data: dict[str, Any]) -> dict[str, Any]:
             if field_info.alias:
                 key_to_field_info[field_info.alias] = field_info
 
-        for data_key in data.keys():
+        for data_key, data_value in data.items():
             if data_key not in key_to_field_info:
                 continue
 
             field_info = key_to_field_info[data_key]
-            if isinstance(data[data_key], str) and field_info.annotation is not str:
+            if isinstance(data_value, str) and field_info.annotation is not str:
                 try:
-                    pre_parsed = json.loads(data[data_key])
+                    pre_parsed = json.loads(data_value)
                 except json.JSONDecodeError:
                     continue  # Not JSON - skip
                 if isinstance(pre_parsed, str | int | float):
diff --git a/src/mcp/server/lowlevel/server.py b/src/mcp/server/lowlevel/server.py
@@ -85,7 +85,6 @@ async def main():
 from mcp.server.lowlevel.helper_types import ReadResourceContents
 from mcp.server.models import InitializationOptions
 from mcp.server.session import ServerSession
-from mcp.server.stdio import stdio_server as stdio_server
 from mcp.shared.context import RequestContext
 from mcp.shared.exceptions import McpError
 from mcp.shared.message import ServerMessageMetadata, SessionMessage
diff --git a/src/mcp/server/session.py b/src/mcp/server/session.py
@@ -161,6 +161,9 @@ async def _received_request(self, responder: RequestResponder[types.ClientReques
                             )
                         )
                     )
+            case types.PingRequest():
+                # Ping requests are allowed at any time
+                pass
             case _:
                 if self._initialization_state != InitializationState.Initialized:
                     raise RuntimeError("Received request before initialization was complete")
diff --git a/src/mcp/server/streamable_http.py b/src/mcp/server/streamable_http.py
@@ -838,17 +838,16 @@ async def message_router():
                             # If this response is for an existing request stream,
                             # send it there
                             target_request_id = response_id
-                        else:
-                            # Extract related_request_id from meta if it exists
-                            if (
-                                session_message.metadata is not None
-                                and isinstance(
-                                    session_message.metadata,
-                                    ServerMessageMetadata,
-                                )
-                                and session_message.metadata.related_request_id is not None
-                            ):
-                                target_request_id = str(session_message.metadata.related_request_id)
+                        # Extract related_request_id from meta if it exists
+                        elif (
+                            session_message.metadata is not None
+                            and isinstance(
+                                session_message.metadata,
+                                ServerMessageMetadata,
+                            )
+                            and session_message.metadata.related_request_id is not None
+                        ):
+                            target_request_id = str(session_message.metadata.related_request_id)
 
                         request_stream_id = target_request_id if target_request_id is not None else GET_STREAM_KEY
 
diff --git a/tests/server/fastmcp/test_integration.py b/tests/server/fastmcp/test_integration.py
@@ -693,7 +693,7 @@ async def test_structured_output(server_transport: str, server_url: str) -> None
 
             # Check that the result contains expected weather data
             result_text = weather_result.content[0].text
-            assert "72.5" in result_text  # temperature
+            assert "22.5" in result_text  # temperature
             assert "sunny" in result_text  # condition
             assert "45" in result_text  # humidity
             assert "5.2" in result_text  # wind_speed
diff --git a/tests/server/test_session.py b/tests/server/test_session.py
@@ -213,3 +213,129 @@ async def mock_client():
 
     assert received_initialized
     assert received_protocol_version == "2024-11-05"
+
+
+@pytest.mark.anyio
+async def test_ping_request_before_initialization():
+    """Test that ping requests are allowed before initialization is complete."""
+    server_to_client_send, server_to_client_receive = anyio.create_memory_object_stream[SessionMessage](1)
+    client_to_server_send, client_to_server_receive = anyio.create_memory_object_stream[SessionMessage | Exception](1)
+
+    ping_response_received = False
+    ping_response_id = None
+
+    async def run_server():
+        async with ServerSession(
+            client_to_server_receive,
+            server_to_client_send,
+            InitializationOptions(
+                server_name="mcp",
+                server_version="0.1.0",
+                capabilities=ServerCapabilities(),
+            ),
+        ) as server_session:
+            async for message in server_session.incoming_messages:
+                if isinstance(message, Exception):
+                    raise message
+
+                # We should receive a ping request before initialization
+                if isinstance(message, RequestResponder) and isinstance(message.request.root, types.PingRequest):
+                    # Respond to the ping
+                    with message:
+                        await message.respond(types.ServerResult(types.EmptyResult()))
+                    return
+
+    async def mock_client():
+        nonlocal ping_response_received, ping_response_id
+
+        # Send ping request before any initialization
+        await client_to_server_send.send(
+            SessionMessage(
+                types.JSONRPCMessage(
+                    types.JSONRPCRequest(
+                        jsonrpc="2.0",
+                        id=42,
+                        method="ping",
+                    )
+                )
+            )
+        )
+
+        # Wait for the ping response
+        ping_response_message = await server_to_client_receive.receive()
+        assert isinstance(ping_response_message.message.root, types.JSONRPCResponse)
+
+        ping_response_received = True
+        ping_response_id = ping_response_message.message.root.id
+
+    async with (
+        client_to_server_send,
+        client_to_server_receive,
+        server_to_client_send,
+        server_to_client_receive,
+        anyio.create_task_group() as tg,
+    ):
+        tg.start_soon(run_server)
+        tg.start_soon(mock_client)
+
+    assert ping_response_received
+    assert ping_response_id == 42
+
+
+@pytest.mark.anyio
+async def test_other_requests_blocked_before_initialization():
+    """Test that non-ping requests are still blocked before initialization."""
+    server_to_client_send, server_to_client_receive = anyio.create_memory_object_stream[SessionMessage](1)
+    client_to_server_send, client_to_server_receive = anyio.create_memory_object_stream[SessionMessage | Exception](1)
+
+    error_response_received = False
+    error_code = None
+
+    async def run_server():
+        async with ServerSession(
+            client_to_server_receive,
+            server_to_client_send,
+            InitializationOptions(
+                server_name="mcp",
+                server_version="0.1.0",
+                capabilities=ServerCapabilities(),
+            ),
+        ):
+            # Server should handle the request and send an error response
+            # No need to process incoming_messages since the error is handled automatically
+            await anyio.sleep(0.1)  # Give time for the request to be processed
+
+    async def mock_client():
+        nonlocal error_response_received, error_code
+
+        # Try to send a non-ping request before initialization
+        await client_to_server_send.send(
+            SessionMessage(
+                types.JSONRPCMessage(
+                    types.JSONRPCRequest(
+                        jsonrpc="2.0",
+                        id=1,
+                        method="prompts/list",
+                    )
+                )
+            )
+        )
+
+        # Wait for the error response
+        error_message = await server_to_client_receive.receive()
+        if isinstance(error_message.message.root, types.JSONRPCError):
+            error_response_received = True
+            error_code = error_message.message.root.error.code
+
+    async with (
+        client_to_server_send,
+        client_to_server_receive,
+        server_to_client_send,
+        server_to_client_receive,
+        anyio.create_task_group() as tg,
+    ):
+        tg.start_soon(run_server)
+        tg.start_soon(mock_client)
+
+    assert error_response_received
+    assert error_code == types.INVALID_PARAMS

Original file line number	Diff line number	Diff line change
`@@ -161,6 +161,9 @@ async def _received_request(self, responder: RequestResponder[types.ClientReques`
`161`	`161`	`)`
`162`	`162`	`)`
`163`	`163`	`)`
	`164`	`+ case types.PingRequest():`
	`165`	`+ # Ping requests are allowed at any time`
	`166`	`+ pass`
`164`	`167`	`case _:`
`165`	`168`	`if self._initialization_state != InitializationState.Initialized:`
`166`	`169`	`raise RuntimeError("Received request before initialization was complete")`