Clean up idle timeout implementation

- Remove unrelated blank line between logger.info and try block
- Only create CancelScope when session_idle_timeout is set, keeping
  the no-timeout path identical to the original code
- Add docstring to _effective_idle_timeout explaining the 3x
  retry_interval multiplier rationale

Author: felixweinberger

src/mcp/server/streamable_http_manager.py

@@ -131,7 +131,6 @@ async def lifespan(app: Starlette) -> AsyncIterator[None]:
             # Store the task group for later use
             self._task_group = tg
             logger.info("StreamableHTTP session manager started")
-
             try:
                 yield  # Let the application run
             finally:
@@ -266,30 +265,39 @@ async def run_server(*, task_status: TaskStatus[None] = anyio.TASK_STATUS_IGNORE
                         read_stream, write_stream = streams
                         task_status.started()
                         try:
-                            # Use a cancel scope for idle timeout — when the
-                            # deadline passes the scope cancels app.run() and
-                            # execution continues after the ``with`` block.
-                            # Incoming requests push the deadline forward.
-                            idle_scope = anyio.CancelScope()
                             if self.session_idle_timeout is not None:
+                                # Use a cancel scope for idle timeout — when
+                                # the deadline passes the scope cancels
+                                # app.run() and execution continues after the
+                                # ``with`` block.  Incoming requests push the
+                                # deadline forward.
                                 timeout = self._effective_idle_timeout()
-                                idle_scope.deadline = anyio.current_time() + timeout
+                                idle_scope = anyio.CancelScope(
+                                    deadline=anyio.current_time() + timeout,
+                                )
                                 http_transport.idle_scope = idle_scope
 
-                            with idle_scope:
+                                with idle_scope:
+                                    await self.app.run(
+                                        read_stream,
+                                        write_stream,
+                                        self.app.create_initialization_options(),
+                                        stateless=False,
+                                    )
+
+                                if idle_scope.cancelled_caught:
+                                    session_id = http_transport.mcp_session_id
+                                    logger.info(f"Session {session_id} idle timeout")
+                                    if session_id is not None:  # pragma: no branch
+                                        self._server_instances.pop(session_id, None)
+                                    await http_transport.terminate()
+                            else:
                                 await self.app.run(
                                     read_stream,
                                     write_stream,
                                     self.app.create_initialization_options(),
                                     stateless=False,
                                 )
-
-                            if idle_scope.cancelled_caught:
-                                session_id = http_transport.mcp_session_id
-                                logger.info(f"Session {session_id} idle timeout")
-                                if session_id is not None:  # pragma: no branch
-                                    self._server_instances.pop(session_id, None)
-                                await http_transport.terminate()
                         except Exception as e:
                             logger.error(
                                 f"Session {http_transport.mcp_session_id} crashed: {e}",
@@ -335,7 +343,14 @@ async def run_server(*, task_status: TaskStatus[None] = anyio.TASK_STATUS_IGNORE
             await response(scope, receive, send)
 
     def _effective_idle_timeout(self) -> float:
-        """Compute the effective idle timeout, accounting for retry_interval."""
+        """Compute the effective idle timeout, accounting for retry_interval.
+
+        When SSE retry_interval is configured, clients periodically reconnect
+        to resume the event stream.  A gap of up to ``retry_interval`` between
+        connections is normal, not a sign of idleness.  We use a 3x multiplier
+        to tolerate up to two consecutive missed polls (network jitter, slow
+        client) before considering the session idle.
+        """
         assert self.session_idle_timeout is not None
         timeout = self.session_idle_timeout
         if self.retry_interval is not None: