Merge remote-tracking branch 'upstream/main' into feature/617-async-call-tools

Author: davemssavage

src/mcp/server/lowlevel/server.py

@@ -151,7 +151,7 @@ def __init__(
         self.result_cache = ResultCache(max_cache_size, max_cache_ttl)
         self.notification_handlers: dict[type, Callable[..., Awaitable[None]]] = {}
         self.notification_options = NotificationOptions()
-        logger.debug(f"Initializing server '{name}'")
+        logger.debug("Initializing server %r", name)
 
     def create_initialization_options(
         self,
@@ -542,7 +542,7 @@ async def run(
 
             async with anyio.create_task_group() as tg:
                 async for message in session.incoming_messages:
-                    logger.debug(f"Received message: {message}")
+                    logger.debug("Received message: %s", message)
 
                     tg.start_soon(
                         self._handle_message,
@@ -575,7 +575,9 @@ async def _handle_message(
                     await self._handle_notification(notify)
 
             for warning in w:
-                logger.info(f"Warning: {warning.category.__name__}: {warning.message}")
+                logger.info(
+                    "Warning: %s: %s", warning.category.__name__, warning.message
+                )
 
     async def _handle_request(
         self,
@@ -585,10 +587,9 @@ async def _handle_request(
         lifespan_context: LifespanResultT,
         raise_exceptions: bool,
     ):
-        logger.info(f"Processing request of type {type(req).__name__}")
-        if type(req) in self.request_handlers:
-            handler = self.request_handlers[type(req)]
-            logger.debug(f"Dispatching request of type {type(req).__name__}")
+        logger.info("Processing request of type %s", type(req).__name__)
+        if handler := self.request_handlers.get(type(req)):  # type: ignore
+            logger.debug("Dispatching request of type %s", type(req).__name__)
 
             token = None
             try:
@@ -634,16 +635,13 @@ async def _handle_request(
         logger.debug("Response sent")
 
     async def _handle_notification(self, notify: Any):
-        if type(notify) in self.notification_handlers:
-            assert type(notify) in self.notification_handlers
-
-            handler = self.notification_handlers[type(notify)]
-            logger.debug(f"Dispatching notification of type {type(notify).__name__}")
+        if handler := self.notification_handlers.get(type(notify)):  # type: ignore
+            logger.debug("Dispatching notification of type %s", type(notify).__name__)
 
             try:
                 await handler(notify)
-            except Exception as err:
-                logger.error(f"Uncaught exception in notification handler: {err}")
+            except Exception:
+                logger.exception("Uncaught exception in notification handler")
 
 
 async def _ping_handler(request: types.PingRequest) -> types.ServerResult: