Internal refactor of MCP handlers (#2005)

Author: jlowin

examples/mount_example.py

@@ -104,7 +104,7 @@ async def get_server_details():
     print(f"  - Imported from news app: {news_resources}")
 
     # Let's try to access resources using the prefixed URI
-    weather_data = await app._mcp_read_resource(uri="weather://weather/forecast")
+    weather_data = await app._read_resource_mcp(uri="weather://weather/forecast")
     print(f"\nWeather data from prefixed URI: {weather_data}")
 
 

examples/serializer.py

@@ -21,7 +21,7 @@ def get_example_data() -> dict:
 
 
 async def example_usage():
-    result = await server._mcp_call_tool("get_example_data", {})
+    result = await server._call_tool_mcp("get_example_data", {})
     print("Tool Result:")
     print(result)
     print("This is an example of using a custom serializer with FastMCP.")

src/fastmcp/prompts/prompt_manager.py

@@ -46,21 +46,23 @@ def mount(self, server: MountedServer) -> None:
         """Adds a mounted server as a source for prompts."""
         self._mounted_servers.append(server)
 
-    async def _load_prompts(self, *, via_server: bool = False) -> dict[str, Prompt]:
+    async def _load_prompts(
+        self, *, apply_filtering: bool = False
+    ) -> dict[str, Prompt]:
         """
-        The single, consolidated recursive method for fetching prompts. The 'via_server'
+        The single, consolidated recursive method for fetching prompts. The 'apply_filtering'
         parameter determines the communication path.
 
-        - via_server=False: Manager-to-manager path for complete, unfiltered inventory
-        - via_server=True: Server-to-server path for filtered MCP requests
+        - apply_filtering=False: Manager-to-manager path for complete, unfiltered inventory
+        - apply_filtering=True: Server-to-server path for filtered MCP requests
         """
         all_prompts: dict[str, Prompt] = {}
 
         for mounted in self._mounted_servers:
             try:
-                if via_server:
+                if apply_filtering:
                     # Use the server-to-server filtered path
-                    child_results = await mounted.server._list_prompts()
+                    child_results = await mounted.server._list_prompts_middleware()
                 else:
                     # Use the manager-to-manager unfiltered path
                     child_results = await mounted.server._prompt_manager.list_prompts()
@@ -104,13 +106,13 @@ async def get_prompts(self) -> dict[str, Prompt]:
         """
         Gets the complete, unfiltered inventory of all prompts.
         """
-        return await self._load_prompts(via_server=False)
+        return await self._load_prompts(apply_filtering=False)
 
     async def list_prompts(self) -> list[Prompt]:
         """
         Lists all prompts, applying protocol filtering.
         """
-        prompts_dict = await self._load_prompts(via_server=True)
+        prompts_dict = await self._load_prompts(apply_filtering=True)
         return list(prompts_dict.values())
 
     def add_prompt_from_fn(
@@ -196,7 +198,9 @@ async def render_prompt(
                 else:
                     continue
             try:
-                return await mounted.server._get_prompt(prompt_key, arguments)
+                return await mounted.server._get_prompt_middleware(
+                    prompt_key, arguments
+                )
             except NotFoundError:
                 continue
 

src/fastmcp/resources/resource_manager.py

@@ -63,27 +63,31 @@ def mount(self, server: MountedServer) -> None:
 
     async def get_resources(self) -> dict[str, Resource]:
         """Get all registered resources, keyed by URI."""
-        return await self._load_resources(via_server=False)
+        return await self._load_resources(apply_filtering=False)
 
     async def get_resource_templates(self) -> dict[str, ResourceTemplate]:
         """Get all registered templates, keyed by URI template."""
-        return await self._load_resource_templates(via_server=False)
+        return await self._load_resource_templates(apply_filtering=False)
 
-    async def _load_resources(self, *, via_server: bool = False) -> dict[str, Resource]:
+    async def _load_resources(
+        self, *, apply_filtering: bool = False
+    ) -> dict[str, Resource]:
         """
-        The single, consolidated recursive method for fetching resources. The 'via_server'
+        The single, consolidated recursive method for fetching resources. The 'apply_filtering'
         parameter determines the communication path.
 
-        - via_server=False: Manager-to-manager path for complete, unfiltered inventory
-        - via_server=True: Server-to-server path for filtered MCP requests
+        - apply_filtering=False: Manager-to-manager path for complete, unfiltered inventory
+        - apply_filtering=True: Server-to-server path for filtered MCP requests
         """
         all_resources: dict[str, Resource] = {}
 
         for mounted in self._mounted_servers:
             try:
-                if via_server:
+                if apply_filtering:
                     # Use the server-to-server filtered path
-                    child_resources_list = await mounted.server._list_resources()
+                    child_resources_list = (
+                        await mounted.server._list_resources_middleware()
+                    )
                     child_resources = {
                         resource.key: resource for resource in child_resources_list
                     }
@@ -123,22 +127,24 @@ async def _load_resources(self, *, via_server: bool = False) -> dict[str, Resour
         return all_resources
 
     async def _load_resource_templates(
-        self, *, via_server: bool = False
+        self, *, apply_filtering: bool = False
     ) -> dict[str, ResourceTemplate]:
         """
-        The single, consolidated recursive method for fetching templates. The 'via_server'
+        The single, consolidated recursive method for fetching templates. The 'apply_filtering'
         parameter determines the communication path.
 
-        - via_server=False: Manager-to-manager path for complete, unfiltered inventory
-        - via_server=True: Server-to-server path for filtered MCP requests
+        - apply_filtering=False: Manager-to-manager path for complete, unfiltered inventory
+        - apply_filtering=True: Server-to-server path for filtered MCP requests
         """
         all_templates: dict[str, ResourceTemplate] = {}
 
         for mounted in self._mounted_servers:
             try:
-                if via_server:
+                if apply_filtering:
                     # Use the server-to-server filtered path
-                    child_templates = await mounted.server._list_resource_templates()
+                    child_templates = (
+                        await mounted.server._list_resource_templates_middleware()
+                    )
                 else:
                     # Use the manager-to-manager unfiltered path
                     child_templates = (
@@ -179,14 +185,14 @@ async def list_resources(self) -> list[Resource]:
         """
         Lists all resources, applying protocol filtering.
         """
-        resources_dict = await self._load_resources(via_server=True)
+        resources_dict = await self._load_resources(apply_filtering=True)
         return list(resources_dict.values())
 
     async def list_resource_templates(self) -> list[ResourceTemplate]:
         """
         Lists all templates, applying protocol filtering.
         """
-        templates_dict = await self._load_resource_templates(via_server=True)
+        templates_dict = await self._load_resource_templates(apply_filtering=True)
         return list(templates_dict.values())
 
     def add_resource_or_template_from_fn(
@@ -492,7 +498,7 @@ async def read_resource(self, uri: AnyUrl | str) -> str | bytes:
                         continue
 
                 try:
-                    result = await mounted.server._read_resource(key)
+                    result = await mounted.server._read_resource_middleware(key)
                     return result[0].content
                 except NotFoundError:
                     continue

src/fastmcp/server/context.py

@@ -205,7 +205,7 @@ async def read_resource(self, uri: str | AnyUrl) -> list[ReadResourceContents]:
         """
         if self.fastmcp is None:
             raise ValueError("Context is not available outside of a request")
-        return await self.fastmcp._mcp_read_resource(uri)
+        return await self.fastmcp._read_resource_mcp(uri)
 
     async def log(
         self,