Merge branch 'main' into main

Author: SoldierSacha

src/mcp/server/fastmcp/server.py

@@ -828,7 +828,6 @@ async def sse_endpoint(request: Request) -> Response:
     def streamable_http_app(self) -> Starlette:
         """Return an instance of the StreamableHTTP server app."""
         from starlette.middleware import Middleware
-        from starlette.routing import Mount
 
         # Create session manager on first call (lazy initialization)
         if self._session_manager is None:
@@ -841,8 +840,7 @@ def streamable_http_app(self) -> Starlette:
             )
 
         # Create the ASGI handler
-        async def handle_streamable_http(scope: Scope, receive: Receive, send: Send) -> None:
-            await self.session_manager.handle_request(scope, receive, send)
+        streamable_http_app = StreamableHTTPASGIApp(self._session_manager)
 
         # Create routes
         routes: list[Route | Mount] = []
@@ -889,17 +887,17 @@ async def handle_streamable_http(scope: Scope, receive: Receive, send: Send) ->
                 )
 
             routes.append(
-                Mount(
+                Route(
                     self.settings.streamable_http_path,
-                    app=RequireAuthMiddleware(handle_streamable_http, required_scopes, resource_metadata_url),
+                    endpoint=RequireAuthMiddleware(streamable_http_app, required_scopes, resource_metadata_url),
                 )
             )
         else:
             # Auth is disabled, no wrapper needed
             routes.append(
-                Mount(
+                Route(
                     self.settings.streamable_http_path,
-                    app=handle_streamable_http,
+                    endpoint=streamable_http_app,
                 )
             )
 
@@ -972,6 +970,18 @@ async def get_prompt(self, name: str, arguments: dict[str, Any] | None = None) -
             raise ValueError(str(e))
 
 
+class StreamableHTTPASGIApp:
+    """
+    ASGI application for Streamable HTTP server transport.
+    """
+
+    def __init__(self, session_manager: StreamableHTTPSessionManager):
+        self.session_manager = session_manager
+
+    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
+        await self.session_manager.handle_request(scope, receive, send)
+
+
 class Context(BaseModel, Generic[ServerSessionT, LifespanContextT, RequestT]):
     """Context object providing access to MCP capabilities.
 

tests/server/fastmcp/test_func_metadata.py

@@ -454,6 +454,98 @@ def func_with_str_and_int(a: str, b: int):
     assert result["b"] == 123
 
 
+def test_str_annotation_preserves_json_string():
+    """
+    Regression test for PR #1113: Ensure that when a parameter is annotated as str,
+    valid JSON strings are NOT parsed into Python objects.
+
+    This test would fail before the fix (JSON string would be parsed to dict)
+    and passes after the fix (JSON string remains as string).
+    """
+
+    def process_json_config(config: str, enabled: bool = True) -> str:
+        """Function that expects a JSON string as a string parameter."""
+        # In real use, this function might validate or transform the JSON string
+        # before parsing it, or pass it to another service as-is
+        return f"Processing config: {config}"
+
+    meta = func_metadata(process_json_config)
+
+    # Test case 1: JSON object as string
+    json_obj_str = '{"database": "postgres", "port": 5432}'
+    result = meta.pre_parse_json({"config": json_obj_str, "enabled": True})
+
+    # The config parameter should remain as a string, NOT be parsed to a dict
+    assert isinstance(result["config"], str)
+    assert result["config"] == json_obj_str
+
+    # Test case 2: JSON array as string
+    json_array_str = '["item1", "item2", "item3"]'
+    result = meta.pre_parse_json({"config": json_array_str})
+
+    # Should remain as string
+    assert isinstance(result["config"], str)
+    assert result["config"] == json_array_str
+
+    # Test case 3: JSON string value (double-encoded)
+    json_string_str = '"This is a JSON string"'
+    result = meta.pre_parse_json({"config": json_string_str})
+
+    # Should remain as the original string with quotes
+    assert isinstance(result["config"], str)
+    assert result["config"] == json_string_str
+
+    # Test case 4: Complex nested JSON as string
+    complex_json_str = '{"users": [{"id": 1, "name": "Alice"}, {"id": 2, "name": "Bob"}], "count": 2}'
+    result = meta.pre_parse_json({"config": complex_json_str})
+
+    # Should remain as string
+    assert isinstance(result["config"], str)
+    assert result["config"] == complex_json_str
+
+
+@pytest.mark.anyio
+async def test_str_annotation_runtime_validation():
+    """
+    Regression test for PR #1113: Test runtime validation with string parameters
+    containing valid JSON to ensure they are passed as strings, not parsed objects.
+    """
+
+    def handle_json_payload(payload: str, strict_mode: bool = False) -> str:
+        """Function that processes a JSON payload as a string."""
+        # This function expects to receive the raw JSON string
+        # It might parse it later after validation or logging
+        assert isinstance(payload, str), f"Expected str, got {type(payload)}"
+        return f"Handled payload of length {len(payload)}"
+
+    meta = func_metadata(handle_json_payload)
+
+    # Test with a JSON object string
+    json_payload = '{"action": "create", "resource": "user", "data": {"name": "Test User"}}'
+
+    result = await meta.call_fn_with_arg_validation(
+        handle_json_payload,
+        fn_is_async=False,
+        arguments_to_validate={"payload": json_payload, "strict_mode": True},
+        arguments_to_pass_directly=None,
+    )
+
+    # The function should have received the string and returned successfully
+    assert result == f"Handled payload of length {len(json_payload)}"
+
+    # Test with JSON array string
+    json_array_payload = '["task1", "task2", "task3"]'
+
+    result = await meta.call_fn_with_arg_validation(
+        handle_json_payload,
+        fn_is_async=False,
+        arguments_to_validate={"payload": json_array_payload},
+        arguments_to_pass_directly=None,
+    )
+
+    assert result == f"Handled payload of length {len(json_array_payload)}"
+
+
 # Tests for structured output functionality
 
 

tests/server/fastmcp/test_server.py

@@ -1072,3 +1072,22 @@ def prompt_fn(name: str) -> str:
         async with client_session(mcp._mcp_server) as client:
             with pytest.raises(McpError, match="Missing required arguments"):
                 await client.get_prompt("prompt_fn")
+
+
+def test_streamable_http_no_redirect() -> None:
+    """Test that streamable HTTP routes are correctly configured."""
+    mcp = FastMCP()
+    app = mcp.streamable_http_app()
+
+    # Find routes by type - streamable_http_app creates Route objects, not Mount objects
+    streamable_routes = [
+        r
+        for r in app.routes
+        if isinstance(r, Route) and hasattr(r, "path") and r.path == mcp.settings.streamable_http_path
+    ]
+
+    # Verify routes exist
+    assert len(streamable_routes) == 1, "Should have one streamable route"
+
+    # Verify path values
+    assert streamable_routes[0].path == "/mcp", "Streamable route path should be /mcp"