fastmcp 2.6.1__py3-none-any.whl → 2.7.1__py3-none-any.whl

fastmcp/resources/resource_manager.py

@@ -1,13 +1,13 @@
 """Resource manager functionality."""
 
 import inspect
+import warnings
 from collections.abc import Callable
 from typing import Any
 
 from pydantic import AnyUrl
 
 from fastmcp.exceptions import NotFoundError, ResourceError
-from fastmcp.resources import FunctionResource
 from fastmcp.resources.resource import Resource
 from fastmcp.resources.template import (
     ResourceTemplate,
@@ -121,13 +121,19 @@ class ResourceManager:
             The added resource. If a resource with the same URI already exists,
             returns the existing resource.
         """
-        resource = FunctionResource(
+        # deprecated in 2.7.0
+        warnings.warn(
+            "add_resource_from_fn is deprecated. Use Resource.from_function() and call add_resource() instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        resource = Resource.from_function(
             fn=fn,
-            uri=AnyUrl(uri),
+            uri=uri,
             name=name,
             description=description,
-            mime_type=mime_type or "text/plain",
-            tags=tags or set(),
+            mime_type=mime_type,
+            tags=tags,
         )
         return self.add_resource(resource)
 
@@ -172,7 +178,12 @@ class ResourceManager:
         tags: set[str] | None = None,
     ) -> ResourceTemplate:
         """Create a template from a function."""
-
+        # deprecated in 2.7.0
+        warnings.warn(
+            "add_template_from_fn is deprecated. Use ResourceTemplate.from_function() and call add_template() instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
         template = ResourceTemplate.from_function(
             fn,
             uri_template=uri_template,

fastmcp/resources/template.py

@@ -10,18 +10,17 @@ from urllib.parse import unquote
 
 from mcp.types import ResourceTemplate as MCPResourceTemplate
 from pydantic import (
-    AnyUrl,
-    BaseModel,
     BeforeValidator,
     Field,
     field_validator,
     validate_call,
 )
 
-from fastmcp.resources.types import FunctionResource, Resource
+from fastmcp.resources.types import Resource
 from fastmcp.server.dependencies import get_context
 from fastmcp.utilities.json_schema import compress_schema
 from fastmcp.utilities.types import (
+    FastMCPBaseModel,
     _convert_set_defaults,
     find_kwarg_by_type,
     get_cached_typeadapter,
@@ -52,12 +51,7 @@ def match_uri_template(uri: str, uri_template: str) -> dict[str, str] | None:
     return None
 
 
-class MyModel(BaseModel):
-    key: str
-    value: int
-
-
-class ResourceTemplate(BaseModel):
+class ResourceTemplate(FastMCPBaseModel):
     """A template for dynamically creating resources."""
 
     uri_template: str = Field(
@@ -71,11 +65,28 @@ class ResourceTemplate(BaseModel):
     mime_type: str = Field(
         default="text/plain", description="MIME type of the resource content"
     )
-    fn: Callable[..., Any]
     parameters: dict[str, Any] = Field(
         description="JSON schema for function parameters"
     )
 
+    @staticmethod
+    def from_function(
+        fn: Callable[..., Any],
+        uri_template: str,
+        name: str | None = None,
+        description: str | None = None,
+        mime_type: str | None = None,
+        tags: set[str] | None = None,
+    ) -> FunctionResourceTemplate:
+        return FunctionResourceTemplate.from_function(
+            fn=fn,
+            uri_template=uri_template,
+            name=name,
+            description=description,
+            mime_type=mime_type,
+            tags=tags,
+        )
+
     @field_validator("mime_type", mode="before")
     @classmethod
     def set_default_mime_type(cls, mime_type: str | None) -> str:
@@ -84,6 +95,70 @@ class ResourceTemplate(BaseModel):
             return mime_type
         return "text/plain"
 
+    def matches(self, uri: str) -> dict[str, Any] | None:
+        """Check if URI matches template and extract parameters."""
+        return match_uri_template(uri, self.uri_template)
+
+    async def read(self, arguments: dict[str, Any]) -> str | bytes:
+        """Read the resource content."""
+        raise NotImplementedError(
+            "Subclasses must implement read() or override create_resource()"
+        )
+
+    async def create_resource(self, uri: str, params: dict[str, Any]) -> Resource:
+        """Create a resource from the template with the given parameters."""
+
+        async def resource_read_fn() -> str | bytes:
+            # Call function and check if result is a coroutine
+            result = await self.read(arguments=params)
+            return result
+
+        return Resource.from_function(
+            fn=resource_read_fn,
+            uri=uri,
+            name=self.name,
+            description=self.description,
+            mime_type=self.mime_type,
+            tags=self.tags,
+        )
+
+    def __eq__(self, other: object) -> bool:
+        if type(self) is not type(other):
+            return False
+        assert isinstance(other, type(self))
+        return self.model_dump() == other.model_dump()
+
+    def to_mcp_template(self, **overrides: Any) -> MCPResourceTemplate:
+        """Convert the resource template to an MCPResourceTemplate."""
+        kwargs = {
+            "uriTemplate": self.uri_template,
+            "name": self.name,
+            "description": self.description,
+            "mimeType": self.mime_type,
+        }
+        return MCPResourceTemplate(**kwargs | overrides)
+
+
+class FunctionResourceTemplate(ResourceTemplate):
+    """A template for dynamically creating resources."""
+
+    fn: Callable[..., Any]
+
+    async def read(self, arguments: dict[str, Any]) -> str | bytes:
+        """Read the resource content."""
+        from fastmcp.server.context import Context
+
+        # Add context to parameters if needed
+        kwargs = arguments.copy()
+        context_kwarg = find_kwarg_by_type(self.fn, kwarg_type=Context)
+        if context_kwarg and context_kwarg not in kwargs:
+            kwargs[context_kwarg] = get_context()
+
+        result = self.fn(**kwargs)
+        if inspect.iscoroutine(result):
+            result = await result
+        return result
+
     @classmethod
     def from_function(
         cls,
@@ -93,7 +168,7 @@ class ResourceTemplate(BaseModel):
         description: str | None = None,
         mime_type: str | None = None,
         tags: set[str] | None = None,
-    ) -> ResourceTemplate:
+    ) -> FunctionResourceTemplate:
         """Create a template from a function."""
         from fastmcp.server.context import Context
 
@@ -150,8 +225,12 @@ class ResourceTemplate(BaseModel):
 
         description = description or fn.__doc__
 
+        # if the fn is a callable class, we need to get the __call__ method from here out
         if not inspect.isroutine(fn):
             fn = fn.__call__
+        # if the fn is a staticmethod, we need to work with the underlying function
+        if isinstance(fn, staticmethod):
+            fn = fn.__func__
 
         type_adapter = get_cached_typeadapter(fn)
         parameters = type_adapter.json_schema()
@@ -172,48 +251,3 @@ class ResourceTemplate(BaseModel):
             parameters=parameters,
             tags=tags or set(),
         )
-
-    def matches(self, uri: str) -> dict[str, Any] | None:
-        """Check if URI matches template and extract parameters."""
-        return match_uri_template(uri, self.uri_template)
-
-    async def create_resource(self, uri: str, params: dict[str, Any]) -> Resource:
-        """Create a resource from the template with the given parameters."""
-        from fastmcp.server.context import Context
-
-        # Add context to parameters if needed
-        kwargs = params.copy()
-        context_kwarg = find_kwarg_by_type(self.fn, kwarg_type=Context)
-        if context_kwarg and context_kwarg not in kwargs:
-            kwargs[context_kwarg] = get_context()
-
-        async def resource_read_fn() -> str | bytes:
-            # Call function and check if result is a coroutine
-            result = self.fn(**kwargs)
-            if inspect.iscoroutine(result):
-                result = await result
-            return result
-
-        return FunctionResource(
-            uri=AnyUrl(uri),  # Explicitly convert to AnyUrl
-            name=self.name,
-            description=self.description,
-            mime_type=self.mime_type,
-            fn=resource_read_fn,
-            tags=self.tags,
-        )
-
-    def __eq__(self, other: object) -> bool:
-        if not isinstance(other, ResourceTemplate):
-            return False
-        return self.model_dump() == other.model_dump()
-
-    def to_mcp_template(self, **overrides: Any) -> MCPResourceTemplate:
-        """Convert the resource template to an MCPResourceTemplate."""
-        kwargs = {
-            "uriTemplate": self.uri_template,
-            "name": self.name,
-            "description": self.description,
-            "mimeType": self.mime_type,
-        }
-        return MCPResourceTemplate(**kwargs | overrides)

fastmcp/resources/types.py

@@ -2,24 +2,18 @@
 
 from __future__ import annotations
 
-import inspect
 import json
-from collections.abc import Callable
 from pathlib import Path
-from typing import Any
 
 import anyio
 import anyio.to_thread
 import httpx
 import pydantic.json
-import pydantic_core
 from pydantic import Field, ValidationInfo
 
 from fastmcp.exceptions import ResourceError
 from fastmcp.resources.resource import Resource
-from fastmcp.server.dependencies import get_context
 from fastmcp.utilities.logging import get_logger
-from fastmcp.utilities.types import find_kwarg_by_type
 
 logger = get_logger(__name__)
 
@@ -44,44 +38,6 @@ class BinaryResource(Resource):
         return self.data
 
 
-class FunctionResource(Resource):
-    """A resource that defers data loading by wrapping a function.
-
-    The function is only called when the resource is read, allowing for lazy loading
-    of potentially expensive data. This is particularly useful when listing resources,
-    as the function won't be called until the resource is actually accessed.
-
-    The function can return:
-    - str for text content (default)
-    - bytes for binary content
-    - other types will be converted to JSON
-    """
-
-    fn: Callable[[], Any]
-
-    async def read(self) -> str | bytes:
-        """Read the resource by calling the wrapped function."""
-        from fastmcp.server.context import Context
-
-        kwargs = {}
-        context_kwarg = find_kwarg_by_type(self.fn, kwarg_type=Context)
-        if context_kwarg is not None:
-            kwargs[context_kwarg] = get_context()
-
-        result = self.fn(**kwargs)
-        if inspect.iscoroutinefunction(self.fn):
-            result = await result
-
-        if isinstance(result, Resource):
-            return await result.read()
-        elif isinstance(result, bytes):
-            return result
-        elif isinstance(result, str):
-            return result
-        else:
-            return pydantic_core.to_json(result, fallback=str, indent=2).decode()
-
-
 class FileResource(Resource):
     """A resource that reads from a file.
 

fastmcp/server/context.py

@@ -49,7 +49,7 @@ class Context:
     To use context in a tool function, add a parameter with the Context type annotation:
 
     ```python
-    @server.tool()
+    @server.tool
     def my_tool(x: int, ctx: Context) -> str:
         # Log messages to the client
         ctx.info(f"Processing {x}")

fastmcp/server/dependencies.py

@@ -67,6 +67,7 @@ def get_http_headers(include_all: bool = False) -> dict[str, str]:
             "te",
             "keep-alive",
             "expect",
+            "accept",
             # Proxy-related headers
             "proxy-authenticate",
             "proxy-authorization",

fastmcp/server/http.py

@@ -13,6 +13,7 @@ from mcp.server.auth.middleware.bearer_auth import (
 from mcp.server.auth.routes import create_auth_routes
 from mcp.server.lowlevel.server import LifespanResultT
 from mcp.server.sse import SseServerTransport
+from mcp.server.streamable_http import EventStore
 from mcp.server.streamable_http_manager import StreamableHTTPSessionManager
 from starlette.applications import Starlette
 from starlette.middleware import Middleware
@@ -241,7 +242,7 @@ def create_sse_app(
 def create_streamable_http_app(
     server: FastMCP[LifespanResultT],
     streamable_http_path: str,
-    event_store: None = None,
+    event_store: EventStore | None = None,
     auth: OAuthProvider | None = None,
     json_response: bool = False,
     stateless_http: bool = False,

fastmcp/server/openapi.py

@@ -233,7 +233,6 @@ class OpenAPITool(Tool):
             name=name,
             description=description,
             parameters=parameters,
-            fn=self._execute_request,  # We'll use an instance method instead of a global function
             tags=tags,
             annotations=annotations,
             exclude_args=exclude_args,
@@ -247,9 +246,10 @@ class OpenAPITool(Tool):
         """Custom representation to prevent recursion errors when printing."""
         return f"OpenAPITool(name={self.name!r}, method={self._route.method}, path={self._route.path})"
 
-    async def _execute_request(self, *args, **kwargs):
+    async def run(
+        self, arguments: dict[str, Any]
+    ) -> list[TextContent | ImageContent | EmbeddedResource]:
         """Execute the HTTP request based on the route configuration."""
-        context = kwargs.get("context")
 
         # Prepare URL
         path = self._route.path
@@ -258,11 +258,11 @@ class OpenAPITool(Tool):
         # Path parameters should never be None as they're typically required
         # but we'll handle that case anyway
         path_params = {
-            p.name: kwargs.get(p.name)
+            p.name: arguments.get(p.name)
             for p in self._route.parameters
             if p.location == "path"
-            and p.name in kwargs
-            and kwargs.get(p.name) is not None
+            and p.name in arguments
+            and arguments.get(p.name) is not None
         }
 
         # Ensure all path parameters are provided
@@ -340,11 +340,11 @@ class OpenAPITool(Tool):
         for p in self._route.parameters:
             if (
                 p.location == "query"
-                and p.name in kwargs
-                and kwargs.get(p.name) is not None
-                and kwargs.get(p.name) != ""
+                and p.name in arguments
+                and arguments.get(p.name) is not None
+                and arguments.get(p.name) != ""
             ):
-                param_value = kwargs.get(p.name)
+                param_value = arguments.get(p.name)
 
                 # Format array query parameters as comma-separated strings
                 # following OpenAPI form style (default for query parameters)
@@ -399,10 +399,10 @@ class OpenAPITool(Tool):
         for p in self._route.parameters:
             if (
                 p.location == "header"
-                and p.name in kwargs
-                and kwargs[p.name] is not None
+                and p.name in arguments
+                and arguments[p.name] is not None
             ):
-                openapi_headers[p.name.lower()] = str(kwargs[p.name])
+                openapi_headers[p.name.lower()] = str(arguments[p.name])
         headers.update(openapi_headers)
 
         # Add headers from the current MCP client HTTP request (these take precedence)
@@ -420,21 +420,13 @@ class OpenAPITool(Tool):
             }
             body_params = {
                 k: v
-                for k, v in kwargs.items()
+                for k, v in arguments.items()
                 if k not in path_query_header_params and k != "context"
             }
 
             if body_params:
                 json_data = body_params
 
-        # Log the request details if a context is available
-        if context:
-            try:
-                await context.info(f"Making {self._route.method} request to {path}")
-            except (ValueError, AttributeError):
-                # Silently continue if context logging is not available
-                pass
-
         # Execute the request
         try:
             response = await self._client.request(
@@ -451,10 +443,11 @@ class OpenAPITool(Tool):
 
             # Try to parse as JSON first
             try:
-                return response.json()
+                result = response.json()
             except (json.JSONDecodeError, ValueError):
                 # Return text content if not JSON
-                return response.text
+                result = response.text
+            return _convert_to_content(result)
 
         except httpx.HTTPStatusError as e:
             # Handle HTTP errors (4xx, 5xx)
@@ -474,13 +467,6 @@ class OpenAPITool(Tool):
             # Handle request errors (connection, timeout, etc.)
             raise ValueError(f"Request error: {str(e)}")
 
-    async def run(
-        self, arguments: dict[str, Any]
-    ) -> list[TextContent | ImageContent | EmbeddedResource]:
-        """Run the tool with arguments and optional context."""
-        response = await self._execute_request(**arguments)
-        return _convert_to_content(response)
-
 
 class OpenAPIResource(Resource):
     """Resource implementation for OpenAPI endpoints."""
@@ -619,7 +605,6 @@ class OpenAPIResourceTemplate(ResourceTemplate):
             uri_template=uri_template,
             name=name,
             description=description,
-            fn=lambda **kwargs: None,
             parameters=parameters,
             tags=tags,
         )

fastmcp/server/proxy.py

@@ -32,10 +32,6 @@ if TYPE_CHECKING:
 logger = get_logger(__name__)
 
 
-def _proxy_passthrough():
-    pass
-
-
 class ProxyTool(Tool):
     def __init__(self, client: Client, **kwargs):
         super().__init__(**kwargs)
@@ -48,7 +44,6 @@ class ProxyTool(Tool):
             name=tool.name,
             description=tool.description,
             parameters=tool.inputSchema,
-            fn=_proxy_passthrough,
         )
 
     async def run(
@@ -69,6 +64,9 @@ class ProxyTool(Tool):
 
 
 class ProxyResource(Resource):
+    _client: Client
+    _value: str | bytes | None = None
+
     def __init__(self, client: Client, *, _value: str | bytes | None = None, **kwargs):
         super().__init__(**kwargs)
         self._client = client
@@ -114,7 +112,6 @@ class ProxyTemplate(ResourceTemplate):
             uri_template=template.uriTemplate,
             name=template.name,
             description=template.description,
-            fn=_proxy_passthrough,
             parameters={},
         )
 
@@ -146,12 +143,13 @@ class ProxyTemplate(ResourceTemplate):
             name=self.name,
             description=self.description,
             mime_type=result[0].mimeType,
-            contents=result,
             _value=value,
         )
 
 
 class ProxyPrompt(Prompt):
+    _client: Client
+
     def __init__(self, client: Client, **kwargs):
         super().__init__(**kwargs)
         self._client = client
@@ -163,7 +161,6 @@ class ProxyPrompt(Prompt):
             name=prompt.name,
             description=prompt.description,
             arguments=[a.model_dump() for a in prompt.arguments or []],
-            fn=_proxy_passthrough,
         )
 
     async def render(self, arguments: dict[str, Any]) -> list[PromptMessage]: