refactor: rename ParsedMessage to MessageFrame for clarity

🤖 Generated with [Claude Code](https://claude.ai/code)
Co-Authored-By: Claude <[email protected]>

Author: dsp-ant

src/mcp/client/sse.py

@@ -10,7 +10,7 @@
 
 import mcp.types as types
 from mcp.shared.session import (
-    ParsedMessage,
+    MessageFrame,
     ReadStream,
     ReadStreamWriter,
     WriteStream,
@@ -90,7 +90,7 @@ async def sse_reader(
 
                                     case "message":
                                         try:
-                                            message = ParsedMessage(
+                                            message = MessageFrame(
                                                 types.JSONRPCMessage.model_validate_json(  # noqa: E501
                                                     sse.data
                                                 ),

src/mcp/server/sse.py

@@ -46,7 +46,7 @@ async def handle_sse(request):
 
 import mcp.types as types
 from mcp.shared.session import (
-    ParsedMessage,
+    MessageFrame,
     ReadStream,
     ReadStreamWriter,
     WriteStream,
@@ -176,4 +176,4 @@ async def handle_post_message(
         logger.debug(f"Sending message to writer: {message}")
         response = Response("Accepted", status_code=202)
         await response(scope, receive, send)
-        await writer.send(ParsedMessage(message, raw=request))
+        await writer.send(MessageFrame(message, raw=request))

src/mcp/server/stdio.py

@@ -27,7 +27,7 @@ async def run_server():
 
 import mcp.types as types
 from mcp.shared.session import (
-    ParsedMessage,
+    MessageFrame,
     ReadStream,
     ReadStreamWriter,
     WriteStream,
@@ -72,7 +72,7 @@ async def stdin_reader():
                         await read_stream_writer.send(exc)
                         continue
 
-                    await read_stream_writer.send(ParsedMessage(message, raw=line))
+                    await read_stream_writer.send(MessageFrame(message, raw=line))
         except anyio.ClosedResourceError:
             await anyio.lowlevel.checkpoint()
 

src/mcp/server/websocket.py

@@ -7,7 +7,7 @@
 
 import mcp.types as types
 from mcp.shared.session import (
-    ParsedMessage,
+    MessageFrame,
     ReadStream,
     ReadStreamWriter,
     WriteStream,
@@ -47,7 +47,7 @@ async def ws_reader():
                         continue
 
                     await read_stream_writer.send(
-                        ParsedMessage(client_message, raw=message)
+                        MessageFrame(client_message, raw=message)
                     )
         except anyio.ClosedResourceError:
             await websocket.close()

src/mcp/shared/memory.py

@@ -11,11 +11,11 @@
 
 from mcp.client.session import ClientSession, ListRootsFnT, SamplingFnT
 from mcp.server import Server
-from mcp.shared.session import ParsedMessage
+from mcp.shared.session import MessageFrame
 
 MessageStream = tuple[
-    MemoryObjectReceiveStream[ParsedMessage | Exception],
-    MemoryObjectSendStream[ParsedMessage],
+    MemoryObjectReceiveStream[MessageFrame | Exception],
+    MemoryObjectSendStream[MessageFrame],
 ]
 
 
@@ -32,10 +32,10 @@ async def create_client_server_memory_streams() -> (
     """
     # Create streams for both directions
     server_to_client_send, server_to_client_receive = anyio.create_memory_object_stream[
-        ParsedMessage | Exception
+        MessageFrame | Exception
     ](1)
     client_to_server_send, client_to_server_receive = anyio.create_memory_object_stream[
-        ParsedMessage | Exception
+        MessageFrame | Exception
     ](1)
 
     client_streams = (server_to_client_receive, client_to_server_send)

src/mcp/shared/session.py

@@ -30,18 +30,18 @@
 RawT = TypeVar("RawT")
 
 
-class ParsedMessage(RootModel[JSONRPCMessage], Generic[RawT]):
+class MessageFrame(RootModel[JSONRPCMessage], Generic[RawT]):
     root: JSONRPCMessage
     raw: RawT | None = None
 
     class Config:
         arbitrary_types_allowed = True
 
 
-ReadStream = MemoryObjectReceiveStream[ParsedMessage[RawT] | Exception]
-ReadStreamWriter = MemoryObjectSendStream[ParsedMessage[RawT] | Exception]
-WriteStream = MemoryObjectSendStream[ParsedMessage[RawT]]
-WriteStreamReader = MemoryObjectReceiveStream[ParsedMessage[RawT]]
+ReadStream = MemoryObjectReceiveStream[MessageFrame[RawT] | Exception]
+ReadStreamWriter = MemoryObjectSendStream[MessageFrame[RawT] | Exception]
+WriteStream = MemoryObjectSendStream[MessageFrame[RawT]]
+WriteStreamReader = MemoryObjectReceiveStream[MessageFrame[RawT]]
 
 SendRequestT = TypeVar("SendRequestT", ClientRequest, ServerRequest)
 SendResultT = TypeVar("SendResultT", ClientResult, ServerResult)
@@ -242,7 +242,7 @@ async def send_request(
         # TODO: Support progress callbacks
 
         await self._write_stream.send(
-            ParsedMessage(JSONRPCMessage(jsonrpc_request), None)
+            MessageFrame(JSONRPCMessage(jsonrpc_request), None)
         )
 
         try:
@@ -280,15 +280,15 @@ async def send_notification(self, notification: SendNotificationT) -> None:
         )
 
         await self._write_stream.send(
-            ParsedMessage(JSONRPCMessage(jsonrpc_notification))
+            MessageFrame(JSONRPCMessage(jsonrpc_notification))
         )
 
     async def _send_response(
         self, request_id: RequestId, response: SendResultT | ErrorData
     ) -> None:
         if isinstance(response, ErrorData):
             jsonrpc_error = JSONRPCError(jsonrpc="2.0", id=request_id, error=response)
-            await self._write_stream.send(ParsedMessage(JSONRPCMessage(jsonrpc_error)))
+            await self._write_stream.send(MessageFrame(JSONRPCMessage(jsonrpc_error)))
         else:
             jsonrpc_response = JSONRPCResponse(
                 jsonrpc="2.0",
@@ -298,7 +298,7 @@ async def _send_response(
                 ),
             )
             await self._write_stream.send(
-                ParsedMessage(JSONRPCMessage(jsonrpc_response))
+                MessageFrame(JSONRPCMessage(jsonrpc_response))
             )
 
     async def _receive_loop(self) -> None:

tests/client/test_session.py

@@ -2,7 +2,7 @@
 import pytest
 
 from mcp.client.session import ClientSession
-from mcp.shared.session import ParsedMessage
+from mcp.shared.session import MessageFrame
 from mcp.types import (
     LATEST_PROTOCOL_VERSION,
     ClientNotification,
@@ -22,10 +22,10 @@
 @pytest.mark.anyio
 async def test_client_session_initialize():
     client_to_server_send, client_to_server_receive = anyio.create_memory_object_stream[
-        ParsedMessage[None]
+        MessageFrame[None]
     ](1)
     server_to_client_send, server_to_client_receive = anyio.create_memory_object_stream[
-        ParsedMessage[None]
+        MessageFrame[None]
     ](1)
 
     initialized_notification = None
@@ -57,7 +57,7 @@ async def mock_server():
 
         async with server_to_client_send:
             await server_to_client_send.send(
-                ParsedMessage(
+                MessageFrame(
                     root=JSONRPCMessage(
                         JSONRPCResponse(
                             jsonrpc="2.0",
@@ -71,7 +71,7 @@ async def mock_server():
                 )
             )
             jsonrpc_notification = await client_to_server_receive.receive()
-            assert isinstance(jsonrpc_notification.root, ParsedMessage)
+            assert isinstance(jsonrpc_notification.root, MessageFrame)
             initialized_notification = ClientNotification.model_validate(
                 jsonrpc_notification.root.model_dump(
                     by_alias=True, mode="json", exclude_none=True

tests/server/test_session.py

@@ -6,7 +6,7 @@
 from mcp.server.lowlevel import NotificationOptions
 from mcp.server.models import InitializationOptions
 from mcp.server.session import ServerSession
-from mcp.shared.session import ParsedMessage
+from mcp.shared.session import MessageFrame
 from mcp.types import (
     ClientNotification,
     InitializedNotification,
@@ -19,10 +19,10 @@
 @pytest.mark.anyio
 async def test_server_session_initialize():
     server_to_client_send, server_to_client_receive = anyio.create_memory_object_stream[
-        ParsedMessage[None]
+        MessageFrame[None]
     ](1)
     client_to_server_send, client_to_server_receive = anyio.create_memory_object_stream[
-        ParsedMessage[None]
+        MessageFrame[None]
     ](1)
 
     async def run_client(client: ClientSession):

tests/server/test_stdio.py

@@ -4,7 +4,7 @@
 import pytest
 
 from mcp.server.stdio import stdio_server
-from mcp.shared.session import ParsedMessage
+from mcp.shared.session import MessageFrame
 from mcp.types import JSONRPCMessage, JSONRPCRequest, JSONRPCResponse
 
 
@@ -14,10 +14,10 @@ async def test_stdio_server():
     stdout = io.StringIO()
 
     messages = [
-        ParsedMessage(
+        MessageFrame(
             root=JSONRPCMessage(root=JSONRPCRequest(jsonrpc="2.0", id=1, method="ping"))
         ),
-        ParsedMessage(
+        MessageFrame(
             root=JSONRPCMessage(root=JSONRPCResponse(jsonrpc="2.0", id=2, result={}))
         ),
     ]
@@ -40,21 +40,21 @@ async def test_stdio_server():
 
         # Verify received messages
         assert len(received_messages) == 2
-        assert received_messages[0] == ParsedMessage(
+        assert received_messages[0] == MessageFrame(
             root=JSONRPCMessage(root=JSONRPCRequest(jsonrpc="2.0", id=1, method="ping"))
         )
-        assert received_messages[1] == ParsedMessage(
+        assert received_messages[1] == MessageFrame(
             root=JSONRPCMessage(root=JSONRPCResponse(jsonrpc="2.0", id=2, result={}))
         )
 
         # Test sending responses from the server
         responses = [
-            ParsedMessage(
+            MessageFrame(
                 root=JSONRPCMessage(
                     root=JSONRPCRequest(jsonrpc="2.0", id=3, method="ping")
                 )
             ),
-            ParsedMessage(
+            MessageFrame(
                 root=JSONRPCMessage(
                     root=JSONRPCResponse(jsonrpc="2.0", id=4, result={})
                 )
@@ -70,12 +70,12 @@ async def test_stdio_server():
     assert len(output_lines) == 2
 
     received_responses = [
-        ParsedMessage.model_validate_json(line.strip()) for line in output_lines
+        MessageFrame.model_validate_json(line.strip()) for line in output_lines
     ]
     assert len(received_responses) == 2
-    assert received_responses[0] == ParsedMessage(
+    assert received_responses[0] == MessageFrame(
         root=JSONRPCMessage(root=JSONRPCRequest(jsonrpc="2.0", id=3, method="ping"))
     )
-    assert received_responses[1] == ParsedMessage(
+    assert received_responses[1] == MessageFrame(
         root=JSONRPCMessage(root=JSONRPCResponse(jsonrpc="2.0", id=4, result={}))
     )