Merge branch 'main' into add_root_notification

Author: gspencergoog

.github/CODEOWNERS

@@ -291,8 +291,15 @@ async def process_llm_response(self, llm_response: str) -> str:
         """
         import json
 
+        def _clean_json_string(json_string: str) -> str:
+            """Remove ```json ... ``` or ``` ... ``` wrappers if the LLM response is fenced."""
+            import re
+
+            pattern = r"^```(?:\s*json)?\s*(.*?)\s*```$"
+            return re.sub(pattern, r"\1", json_string, flags=re.DOTALL | re.IGNORECASE).strip()
+
         try:
-            tool_call = json.loads(llm_response)
+            tool_call = json.loads(_clean_json_string(llm_response))
             if "tool" in tool_call and "arguments" in tool_call:
                 logging.info(f"Executing tool: {tool_call['tool']}")
                 logging.info(f"With arguments: {tool_call['arguments']}")

examples/clients/simple-chatbot/mcp_simple_chatbot/main.py

@@ -8,6 +8,7 @@
 from anyio.abc import TaskStatus
 from anyio.streams.memory import MemoryObjectReceiveStream, MemoryObjectSendStream
 from httpx_sse import aconnect_sse
+from httpx_sse._exceptions import SSEError
 
 import mcp.types as types
 from mcp.shared._httpx_utils import McpHttpClientFactory, create_mcp_http_client
@@ -105,6 +106,9 @@ async def sse_reader(
                                         await read_stream_writer.send(session_message)
                                     case _:
                                         logger.warning(f"Unknown SSE event: {sse.event}")
+                        except SSEError as sse_exc:
+                            logger.exception("Encountered SSE exception")
+                            raise sse_exc
                         except Exception as exc:
                             logger.exception("Error in sse_reader")
                             await read_stream_writer.send(exc)

src/mcp/client/sse.py

@@ -10,6 +10,7 @@
 from mcp.server.fastmcp.resources.base import Resource
 from mcp.server.fastmcp.resources.templates import ResourceTemplate
 from mcp.server.fastmcp.utilities.logging import get_logger
+from mcp.types import Icon
 
 if TYPE_CHECKING:
     from mcp.server.fastmcp.server import Context
@@ -61,6 +62,7 @@ def add_template(
         title: str | None = None,
         description: str | None = None,
         mime_type: str | None = None,
+        icons: list[Icon] | None = None,
     ) -> ResourceTemplate:
         """Add a template from a function."""
         template = ResourceTemplate.from_function(
@@ -70,6 +72,7 @@ def add_template(
             title=title,
             description=description,
             mime_type=mime_type,
+            icons=icons,
         )
         self._templates[template.uri_template] = template
         return template

src/mcp/server/fastmcp/resources/resource_manager.py

@@ -12,6 +12,7 @@
 from mcp.server.fastmcp.resources.types import FunctionResource, Resource
 from mcp.server.fastmcp.utilities.context_injection import find_context_parameter, inject_context
 from mcp.server.fastmcp.utilities.func_metadata import func_metadata
+from mcp.types import Icon
 
 if TYPE_CHECKING:
     from mcp.server.fastmcp.server import Context
@@ -27,6 +28,7 @@ class ResourceTemplate(BaseModel):
     title: str | None = Field(description="Human-readable title of the resource", default=None)
     description: str | None = Field(description="Description of what the resource does")
     mime_type: str = Field(default="text/plain", description="MIME type of the resource content")
+    icons: list[Icon] | None = Field(default=None, description="Optional list of icons for the resource template")
     fn: Callable[..., Any] = Field(exclude=True)
     parameters: dict[str, Any] = Field(description="JSON schema for function parameters")
     context_kwarg: str | None = Field(None, description="Name of the kwarg that should receive context")
@@ -40,6 +42,7 @@ def from_function(
         title: str | None = None,
         description: str | None = None,
         mime_type: str | None = None,
+        icons: list[Icon] | None = None,
         context_kwarg: str | None = None,
     ) -> ResourceTemplate:
         """Create a template from a function."""
@@ -67,6 +70,7 @@ def from_function(
             title=title,
             description=description or fn.__doc__ or "",
             mime_type=mime_type or "text/plain",
+            icons=icons,
             fn=fn,
             parameters=parameters,
             context_kwarg=context_kwarg,
@@ -103,7 +107,7 @@ async def create_resource(
                 title=self.title,
                 description=self.description,
                 mime_type=self.mime_type,
-                icons=None,  # Resource templates don't support icons
+                icons=self.icons,
                 fn=lambda: result,  # Capture result in closure
             )
         except Exception as e:

src/mcp/server/fastmcp/resources/templates.py

@@ -335,6 +335,7 @@ async def list_resource_templates(self) -> list[MCPResourceTemplate]:
                 title=template.title,
                 description=template.description,
                 mimeType=template.mime_type,
+                icons=template.icons,
             )
             for template in templates
         ]
@@ -559,7 +560,7 @@ def decorator(fn: AnyFunction) -> AnyFunction:
                     title=title,
                     description=description,
                     mime_type=mime_type,
-                    # Note: Resource templates don't support icons
+                    icons=icons,
                 )
             else:
                 # Register as regular resource

src/mcp/server/fastmcp/server.py

@@ -392,11 +392,17 @@ async def _receive_loop(self) -> None:
                                     # call it with the progress information
                                     if progress_token in self._progress_callbacks:
                                         callback = self._progress_callbacks[progress_token]
-                                        await callback(
-                                            notification.root.params.progress,
-                                            notification.root.params.total,
-                                            notification.root.params.message,
-                                        )
+                                        try:
+                                            await callback(
+                                                notification.root.params.progress,
+                                                notification.root.params.total,
+                                                notification.root.params.message,
+                                            )
+                                        except Exception as e:
+                                            logging.error(
+                                                "Progress callback raised an exception: %s",
+                                                e,
+                                            )
                                 await self._received_notification(notification)
                                 await self._handle_incoming(notification)
                         except Exception as e:

src/mcp/shared/session.py

@@ -470,6 +470,8 @@ class ResourceTemplate(BaseMetadata):
     The MIME type for all resources that match this template. This should only be
     included if all resources matching this template have the same type.
     """
+    icons: list[Icon] | None = None
+    """An optional list of icons for this resource template."""
     annotations: Annotations | None = None
     meta: dict[str, Any] | None = Field(alias="_meta", default=None)
     """

src/mcp/types.py

@@ -39,6 +39,12 @@ def test_prompt(text: str) -> str:
         """A test prompt with an icon."""
         return text
 
+    # Create resource template with icon
+    @mcp.resource("test://weather/{city}", icons=[test_icon])
+    def test_resource_template(city: str) -> str:
+        """Get weather for a city."""
+        return f"Weather for {city}"
+
     # Test server metadata includes websiteUrl and icons
     assert mcp.name == "TestServer"
     assert mcp.website_url == "https://example.com"
@@ -75,6 +81,16 @@ def test_prompt(text: str) -> str:
     assert len(prompt.icons) == 1
     assert prompt.icons[0].src == test_icon.src
 
+    # Test resource template includes icon
+    templates = await mcp.list_resource_templates()
+    assert len(templates) == 1
+    template = templates[0]
+    assert template.name == "test_resource_template"
+    assert template.uriTemplate == "test://weather/{city}"
+    assert template.icons is not None
+    assert len(template.icons) == 1
+    assert template.icons[0].src == test_icon.src
+
 
 async def test_multiple_icons():
     """Test that multiple icons can be added to tools, resources, and prompts."""

tests/issues/test_1338_icons_and_metadata.py

@@ -1,5 +1,6 @@
 import asyncio
 from typing import Any, cast
+from unittest.mock import patch
 
 import anyio
 import pytest
@@ -11,6 +12,7 @@
 from mcp.server.models import InitializationOptions
 from mcp.server.session import ServerSession
 from mcp.shared.context import RequestContext
+from mcp.shared.memory import create_connected_server_and_client_session
 from mcp.shared.message import SessionMessage
 from mcp.shared.progress import progress
 from mcp.shared.session import BaseSession, RequestResponder
@@ -330,6 +332,72 @@ async def handle_client_message(
     assert server_progress_updates[3]["message"] == "Processing results..."
 
 
+@pytest.mark.anyio
+async def test_progress_callback_exception_logging():
+    """Test that exceptions in progress callbacks are logged and \
+        don't crash the session."""
+    # Track logged warnings
+    logged_errors: list[str] = []
+
+    def mock_log_error(msg: str, *args: Any) -> None:
+        logged_errors.append(msg % args if args else msg)
+
+    # Create a progress callback that raises an exception
+    async def failing_progress_callback(progress: float, total: float | None, message: str | None) -> None:
+        raise ValueError("Progress callback failed!")
+
+    # Create a server with a tool that sends progress notifications
+    server = Server(name="TestProgressServer")
+
+    @server.call_tool()
+    async def handle_call_tool(name: str, arguments: Any) -> list[types.TextContent]:
+        if name == "progress_tool":
+            # Send a progress notification
+            await server.request_context.session.send_progress_notification(
+                progress_token=server.request_context.request_id,
+                progress=50.0,
+                total=100.0,
+                message="Halfway done",
+            )
+            return [types.TextContent(type="text", text="progress_result")]
+        raise ValueError(f"Unknown tool: {name}")
+
+    @server.list_tools()
+    async def handle_list_tools() -> list[types.Tool]:
+        return [
+            types.Tool(
+                name="progress_tool",
+                description="A tool that sends progress notifications",
+                inputSchema={},
+            )
+        ]
+
+    # Test with mocked logging
+    with patch("mcp.shared.session.logging.error", side_effect=mock_log_error):
+        async with create_connected_server_and_client_session(server) as client_session:
+            # Send a request with a failing progress callback
+            result = await client_session.send_request(
+                types.ClientRequest(
+                    types.CallToolRequest(
+                        method="tools/call",
+                        params=types.CallToolRequestParams(name="progress_tool", arguments={}),
+                    )
+                ),
+                types.CallToolResult,
+                progress_callback=failing_progress_callback,
+            )
+
+            # Verify the request completed successfully despite the callback failure
+            assert len(result.content) == 1
+            content = result.content[0]
+            assert isinstance(content, types.TextContent)
+            assert content.text == "progress_result"
+
+            # Check that a warning was logged for the progress callback exception
+            assert len(logged_errors) > 0
+            assert any("Progress callback raised an exception" in warning for warning in logged_errors)
+
+
 @pytest.mark.anyio
 async def test_initialized_notification():
     """Test that the server receives and handles InitializedNotification."""