avoid exceptions during join call tool on timeout as this is expected behaviour use None when no result retrieved instead

Author: davemssavage

src/mcp/client/session.py

@@ -343,7 +343,7 @@ async def join_call_tool(
         progress_callback: ProgressFnT | None = None,
         request_read_timeout_seconds: timedelta | None = None,
         done_on_timeout: bool = True,
-    ) -> types.CallToolResult:
+    ) -> types.CallToolResult | None:
         return await self.join_request(
             request_id,
             types.CallToolResult,

src/mcp/server/streamable_http.py

@@ -763,8 +763,8 @@ async def send_event(event_message: EventMessage) -> None:
                             async with msg_reader:
                                 async for event_message in msg_reader:
                                     event_data = self._create_event_data(event_message)
-
                                     await sse_stream_writer.send(event_data)
+                                    
                 except Exception as e:
                     logger.exception(f"Error in replay sender: {e}")
 

src/mcp/shared/session.py

@@ -186,7 +186,7 @@ async def receive_response(
         self,
         request_id: RequestId,
         timeout: float | None = None,
-    ) -> JSONRPCResponse | JSONRPCError: ...
+    ) -> JSONRPCResponse | JSONRPCError | None: ...
 
     async def handle_response(self, message: JSONRPCResponse | JSONRPCError) -> bool: ...
 
@@ -278,7 +278,7 @@ async def receive_response(
         self,
         request_id: RequestId,
         timeout: float | None = None,
-    ) -> JSONRPCResponse | JSONRPCError:
+    ) -> JSONRPCResponse | JSONRPCError | None:
         _, receive_stream = self._response_streams.get(request_id, [None, None])
         if receive_stream is None:
             raise McpError(
@@ -302,16 +302,7 @@ async def receive_response(
                 )
             )
         except TimeoutError:
-            raise McpError(
-                ErrorData(
-                    code=httpx.codes.REQUEST_TIMEOUT,
-                    message=(
-                        f"Timed out while waiting for response to "
-                        f"{request.__class__.__name__}. Waited "
-                        f"{timeout} seconds."
-                    ),
-                )
-            )
+            return None
 
     async def handle_response(self, message: JSONRPCResponse | JSONRPCError) -> bool:
         send_stream, _ = self._response_streams.get(message.id, [None, None])
@@ -453,9 +444,11 @@ async def join_request(
         request_read_timeout_seconds: timedelta | None = None,
         progress_callback: ProgressFnT | None = None,
         done_on_timeout: bool = True,
-    ) -> ReceiveResultT:
+    ) -> ReceiveResultT | None:
         """
-        Joins a request previously started via start_request
+        Joins a request previously started via start_request.
+        
+        Returns the result or None if timeout is reached.
         """
         resume = self._request_state_manager.resume(request_id)
 
@@ -488,17 +481,23 @@ async def join_request(
 
         response_or_error = await self._request_state_manager.receive_response(request_id, timeout)
 
-        if isinstance(response_or_error, JSONRPCError):
+        if response_or_error is None:
+            if done_on_timeout:
+                await self._request_state_manager.close_request(request_id)  
+            return None
+        elif isinstance(response_or_error, JSONRPCError):
             if response_or_error.error.code == httpx.codes.REQUEST_TIMEOUT.value:
                 if done_on_timeout:
                     await self._request_state_manager.close_request(request_id)
+                return None
             else:
                 await self._request_state_manager.close_request(request_id)
-            raise McpError(response_or_error.error)
-        else:
+                raise McpError(response_or_error.error)
+        else :
             await self._request_state_manager.close_request(request_id)
             return result_type.model_validate(response_or_error.result)
 
+
     async def cancel_request(self, request_id: RequestId) -> bool:
         """
         Cancels a request previously started via start_request
@@ -533,7 +532,20 @@ async def send_request(
         """
         request_id = await self.start_request(request, metadata, progress_callback)
         try:
-            return await self.join_request(request_id, result_type, request_read_timeout_seconds)
+            result = await self.join_request(request_id, result_type, request_read_timeout_seconds)
+            if result is None:
+                raise McpError(
+                    ErrorData(
+                        code=httpx.codes.REQUEST_TIMEOUT,
+                        message=(
+                            f"Timed out while waiting for response to "
+                            f"{request.__class__.__name__}. Waited "
+                            f"{request_read_timeout_seconds} seconds."
+                        ),
+                    )
+                )
+            else:
+                return result
         finally:
             await self._request_state_manager.close_request(request_id)
 

tests/client/test_session.py

@@ -635,14 +635,10 @@ async def message_handler(
         request_id = await session.request_call_tool("hello", {"name": "world"})
 
         with anyio.fail_after(3):
-            try:
-                result = await session.join_call_tool(
-                    request_id, request_read_timeout_seconds=timedelta(seconds=0.5), done_on_timeout=False
-                )
-                # raise RuntimeError("Expected fail")
-            except McpError as e:
-                if not e.error.code == httpx.codes.REQUEST_TIMEOUT:
-                    raise e
+            result = await session.join_call_tool(
+                request_id, request_read_timeout_seconds=timedelta(seconds=0.5), done_on_timeout=False
+            )
+            assert result is None
             send_result.set()
             result = await session.join_call_tool(
                 request_id, request_read_timeout_seconds=timedelta(seconds=1), done_on_timeout=False

tests/shared/test_streamable_http.py

@@ -1351,13 +1351,13 @@ async def run_tool():
                         captured_request_id = await session.request_call_tool(
                             "long_running_with_checkpoints", arguments={}
                         )
-                        try:
-                            await session.join_call_tool(
-                                captured_request_id, request_read_timeout_seconds=timedelta(seconds=0.01)
-                            )
-                            raise RuntimeError("Expected timeout")
-                        except McpError as e:
-                            assert e.error.code == httpx.codes.REQUEST_TIMEOUT.value
+                        
+                        result = await session.join_call_tool(
+                            captured_request_id, request_read_timeout_seconds=timedelta(seconds=0.01),
+                            done_on_timeout=False
+                        )
+
+                        assert result is None
 
                         timed_out.set()
 
@@ -1409,6 +1409,7 @@ async def run_tool():
                 assert captured_request_id is not None
 
                 result = await session.join_call_tool(captured_request_id)
+                assert result is not None
 
                 # We should get a complete result
                 assert len(result.content) == 1