fix: respect resource mime type in responses

The server was ignoring mime types set on resources, defaulting to text/plain
for strings and application/octet-stream for bytes. Now properly preserves
the specified mime type in both FastMCP and low-level server implementations.

Reported-by: eiseleMichael

Author: dsp-ant

CLAUDE.md

@@ -23,6 +23,20 @@ This file is intended to be used by an LLM such as Claude.
   git commit -am "\"fix: my commit message\""
   ```
 
+- For commits fixing bugs or adding features based on user reports add:
+  ```bash
+  git commit --trailer "Reported-by:<name>"
+  ```
+  Where `<name>` is the name of the user.
+
+- For commits related to a Github issue, add
+  ```bash
+  git commit --trailer "Github-Issue:<number>"
+  ```
+- NEVER ever mention a `co-authored-by` or similar aspects. In particular, never
+  mention the tool used to create the commit message or PR.
+
+
 ## Python Tools
 
 ### Ruff

src/mcp/server/fastmcp/server.py

@@ -24,10 +24,13 @@
 from mcp.server.stdio import stdio_server
 from mcp.shared.context import RequestContext
 from mcp.types import (
+    BlobResourceContents,
     EmbeddedResource,
     GetPromptResult,
     ImageContent,
+    ReadResourceResult,
     TextContent,
+    TextResourceContents,
 )
 from mcp.types import (
     Prompt as MCPPrompt,
@@ -197,14 +200,36 @@ async def list_resource_templates(self) -> list[MCPResourceTemplate]:
             for template in templates
         ]
 
-    async def read_resource(self, uri: AnyUrl | str) -> str | bytes:
+    async def read_resource(
+        self, uri: AnyUrl | str
+    ) -> str | bytes | ReadResourceResult:
         """Read a resource by URI."""
+        import base64
+
         resource = await self._resource_manager.get_resource(uri)
         if not resource:
             raise ResourceError(f"Unknown resource: {uri}")
 
         try:
-            return await resource.read()
+            match await resource.read():
+                case str() as s:
+                    return ReadResourceResult(
+                        contents=[
+                            TextResourceContents(
+                                uri=resource.uri, mimeType=resource.mime_type, text=s
+                            )
+                        ]
+                    )
+                case bytes() as b:
+                    return ReadResourceResult(
+                        contents=[
+                            BlobResourceContents(
+                                uri=resource.uri,
+                                mimeType=resource.mime_type,
+                                blob=base64.b64encode(b).decode(),
+                            )
+                        ]
+                    )
         except Exception as e:
             logger.error(f"Error reading resource {uri}: {e}")
             raise ResourceError(str(e))

src/mcp/server/lowlevel/server.py

@@ -252,32 +252,44 @@ async def handler(_: Any):
         return decorator
 
     def read_resource(self):
-        def decorator(func: Callable[[AnyUrl], Awaitable[str | bytes]]):
+        def decorator(
+            func: Callable[[AnyUrl], Awaitable[types.ReadResourceResult | str | bytes]],
+        ):
             logger.debug("Registering handler for ReadResourceRequest")
 
             async def handler(req: types.ReadResourceRequest):
                 result = await func(req.params.uri)
                 match result:
-                    case str(s):
+                    case types.ReadResourceResult() as result:
+                        return types.ServerResult(result)
+                    case str() as s:
                         content = types.TextResourceContents(
                             uri=req.params.uri,
                             text=s,
                             mimeType="text/plain",
                         )
-                    case bytes(b):
+                        return types.ServerResult(
+                            types.ReadResourceResult(
+                                contents=[content],
+                            )
+                        )
+                    case bytes() as b:
                         import base64
 
                         content = types.BlobResourceContents(
                             uri=req.params.uri,
                             blob=base64.urlsafe_b64encode(b).decode(),
                             mimeType="application/octet-stream",
                         )
-
-                return types.ServerResult(
-                    types.ReadResourceResult(
-                        contents=[content],
-                    )
-                )
+                        return types.ServerResult(
+                            types.ReadResourceResult(
+                                contents=[content],
+                            )
+                        )
+                    case _:
+                        raise ValueError(
+                            f"Unexpected return type from read_resource: {type(result)}"
+                        )
 
             self.request_handlers[types.ReadResourceRequest] = handler
             return func

tests/issues/test_152_resource_mime_type.py

@@ -98,9 +98,23 @@ async def handle_list_resources():
     @server.read_resource()
     async def handle_read_resource(uri: AnyUrl):
         if str(uri) == "test://image":
-            return base64_string
+            return types.ReadResourceResult(
+                contents=[
+                    types.TextResourceContents(
+                        uri=uri, mimeType="image/png", text=base64_string
+                    )
+                ]
+            )
         elif str(uri) == "test://image_bytes":
-            return image_bytes
+            return types.ReadResourceResult(
+                contents=[
+                    types.BlobResourceContents(
+                        uri=uri,
+                        mimeType="image/png",
+                        blob=base64.b64encode(image_bytes).decode(),
+                    )
+                ]
+            )
         raise Exception(f"Resource not found: {uri}")
 
     # Test that resources are listed with correct mime type