fastmcp 2.6.0__py3-none-any.whl → 2.7.0__py3-none-any.whl

fastmcp/tools/tool.py

@@ -2,19 +2,21 @@ from __future__ import annotations
 
 import inspect
 import json
+from abc import ABC, abstractmethod
 from collections.abc import Callable
 from typing import TYPE_CHECKING, Annotated, Any
 
 import pydantic_core
 from mcp.types import EmbeddedResource, ImageContent, TextContent, ToolAnnotations
 from mcp.types import Tool as MCPTool
-from pydantic import BaseModel, BeforeValidator, Field
+from pydantic import BeforeValidator, Field
 
 import fastmcp
 from fastmcp.server.dependencies import get_context
 from fastmcp.utilities.json_schema import compress_schema
 from fastmcp.utilities.logging import get_logger
 from fastmcp.utilities.types import (
+    FastMCPBaseModel,
     Image,
     _convert_set_defaults,
     find_kwarg_by_type,
@@ -31,10 +33,9 @@ def default_serializer(data: Any) -> str:
     return pydantic_core.to_json(data, fallback=str, indent=2).decode()
 
 
-class Tool(BaseModel):
+class Tool(FastMCPBaseModel, ABC):
     """Internal tool registration info."""
 
-    fn: Callable[..., Any]
     name: str = Field(description="Name of the tool")
     description: str | None = Field(
         default=None, description="Description of what the tool does"
@@ -54,6 +55,53 @@ class Tool(BaseModel):
         None, description="Optional custom serializer for tool results"
     )
 
+    def to_mcp_tool(self, **overrides: Any) -> MCPTool:
+        kwargs = {
+            "name": self.name,
+            "description": self.description,
+            "inputSchema": self.parameters,
+            "annotations": self.annotations,
+        }
+        return MCPTool(**kwargs | overrides)
+
+    @staticmethod
+    def from_function(
+        fn: Callable[..., Any],
+        name: str | None = None,
+        description: str | None = None,
+        tags: set[str] | None = None,
+        annotations: ToolAnnotations | None = None,
+        exclude_args: list[str] | None = None,
+        serializer: Callable[[Any], str] | None = None,
+    ) -> FunctionTool:
+        """Create a Tool from a function."""
+        return FunctionTool.from_function(
+            fn=fn,
+            name=name,
+            description=description,
+            tags=tags,
+            annotations=annotations,
+            exclude_args=exclude_args,
+            serializer=serializer,
+        )
+
+    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()
+
+    @abstractmethod
+    async def run(
+        self, arguments: dict[str, Any]
+    ) -> list[TextContent | ImageContent | EmbeddedResource]:
+        """Run the tool with arguments."""
+        raise NotImplementedError("Subclasses must implement run()")
+
+
+class FunctionTool(Tool):
+    fn: Callable[..., Any]
+
     @classmethod
     def from_function(
         cls,
@@ -64,7 +112,7 @@ class Tool(BaseModel):
         annotations: ToolAnnotations | None = None,
         exclude_args: list[str] | None = None,
         serializer: Callable[[Any], str] | None = None,
-    ) -> Tool:
+    ) -> FunctionTool:
         """Create a Tool from a function."""
         from fastmcp.server.context import Context
 
@@ -98,6 +146,9 @@ class Tool(BaseModel):
         # 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)
         schema = type_adapter.json_schema()
@@ -170,20 +221,6 @@ class Tool(BaseModel):
 
         return _convert_to_content(result, serializer=self.serializer)
 
-    def to_mcp_tool(self, **overrides: Any) -> MCPTool:
-        kwargs = {
-            "name": self.name,
-            "description": self.description,
-            "inputSchema": self.parameters,
-            "annotations": self.annotations,
-        }
-        return MCPTool(**kwargs | overrides)
-
-    def __eq__(self, other: object) -> bool:
-        if not isinstance(other, Tool):
-            return False
-        return self.model_dump() == other.model_dump()
-
 
 def _convert_to_content(
     result: Any,
@@ -215,9 +252,12 @@ def _convert_to_content(
                 mcp_types.append(_convert_to_content(item)[0])
             else:
                 other_content.append(item)
+
         if other_content:
             other_content = _convert_to_content(
-                other_content, serializer=serializer, _process_as_single_item=True
+                other_content[0] if len(other_content) == 1 else other_content,
+                serializer=serializer,
+                _process_as_single_item=True,
             )
 
         return other_content + mcp_types

fastmcp/tools/tool_manager.py

@@ -1,5 +1,6 @@
 from __future__ import annotations as _annotations
 
+import warnings
 from collections.abc import Callable
 from typing import TYPE_CHECKING, Any
 
@@ -22,11 +23,9 @@ class ToolManager:
     def __init__(
         self,
         duplicate_behavior: DuplicateBehavior | None = None,
-        serializer: Callable[[Any], str] | None = None,
         mask_error_details: bool = False,
     ):
         self._tools: dict[str, Tool] = {}
-        self._serializer = serializer
         self.mask_error_details = mask_error_details
 
         # Default to "warn" if None is provided
@@ -66,17 +65,24 @@ class ToolManager:
         description: str | None = None,
         tags: set[str] | None = None,
         annotations: ToolAnnotations | None = None,
+        serializer: Callable[[Any], str] | None = None,
         exclude_args: list[str] | None = None,
     ) -> Tool:
         """Add a tool to the server."""
+        # deprecated in 2.7.0
+        warnings.warn(
+            "ToolManager.add_tool_from_fn() is deprecated. Use Tool.from_function() and call add_tool() instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
         tool = Tool.from_function(
             fn,
             name=name,
             description=description,
             tags=tags,
             annotations=annotations,
-            serializer=self._serializer,
             exclude_args=exclude_args,
+            serializer=serializer,
         )
         return self.add_tool(tool)
 

fastmcp/utilities/mcp_config.py

@@ -3,7 +3,9 @@ from __future__ import annotations
 from typing import TYPE_CHECKING, Any, Literal
 from urllib.parse import urlparse
 
-from pydantic import AnyUrl, BaseModel, Field
+from pydantic import AnyUrl, Field
+
+from fastmcp.utilities.types import FastMCPBaseModel
 
 if TYPE_CHECKING:
     from fastmcp.client.transports import (
@@ -32,7 +34,7 @@ def infer_transport_type_from_url(
         return "streamable-http"
 
 
-class StdioMCPServer(BaseModel):
+class StdioMCPServer(FastMCPBaseModel):
     command: str
     args: list[str] = Field(default_factory=list)
     env: dict[str, Any] = Field(default_factory=dict)
@@ -50,7 +52,7 @@ class StdioMCPServer(BaseModel):
         )
 
 
-class RemoteMCPServer(BaseModel):
+class RemoteMCPServer(FastMCPBaseModel):
     url: str
     headers: dict[str, str] = Field(default_factory=dict)
     transport: Literal["streamable-http", "sse", "http"] | None = None
@@ -69,7 +71,7 @@ class RemoteMCPServer(BaseModel):
             return StreamableHttpTransport(self.url, headers=self.headers)
 
 
-class MCPConfig(BaseModel):
+class MCPConfig(FastMCPBaseModel):
     mcpServers: dict[str, StdioMCPServer | RemoteMCPServer]
 
     @classmethod

fastmcp/utilities/openapi.py

@@ -25,6 +25,7 @@ from openapi_pydantic.v3.v3_0 import Schema as Schema_30
 from pydantic import BaseModel, Field, ValidationError
 
 from fastmcp.utilities.json_schema import compress_schema
+from fastmcp.utilities.types import FastMCPBaseModel
 
 logger = logging.getLogger(__name__)
 
@@ -38,7 +39,7 @@ ParameterLocation = Literal["path", "query", "header", "cookie"]
 JsonSchema = dict[str, Any]
 
 
-class ParameterInfo(BaseModel):
+class ParameterInfo(FastMCPBaseModel):
     """Represents a single parameter for an HTTP operation in our IR."""
 
     name: str
@@ -48,7 +49,7 @@ class ParameterInfo(BaseModel):
     description: str | None = None
 
 
-class RequestBodyInfo(BaseModel):
+class RequestBodyInfo(FastMCPBaseModel):
     """Represents the request body for an HTTP operation in our IR."""
 
     required: bool = False
@@ -58,7 +59,7 @@ class RequestBodyInfo(BaseModel):
     description: str | None = None
 
 
-class ResponseInfo(BaseModel):
+class ResponseInfo(FastMCPBaseModel):
     """Represents response information in our IR."""
 
     description: str | None = None
@@ -66,7 +67,7 @@ class ResponseInfo(BaseModel):
     content_schema: dict[str, JsonSchema] = Field(default_factory=dict)
 
 
-class HTTPRoute(BaseModel):
+class HTTPRoute(FastMCPBaseModel):
     """Intermediate Representation for a single OpenAPI operation."""
 
     path: str
@@ -872,6 +873,50 @@ def format_description_with_responses(
     return "\n".join(desc_parts)
 
 
+def _replace_ref_with_defs(
+    info: dict[str, Any], description: str | None = None
+) -> dict[str, Any]:
+    """
+    Replace openapi $ref with jsonschema $defs
+
+    Examples:
+    - {"type": "object", "properties": {"$ref": "#/components/schemas/..."}}
+    - {"$ref": "#/components/schemas/..."}
+    - {"items": {"$ref": "#/components/schemas/..."}}
+    - {"anyOf": [{"$ref": "#/components/schemas/..."}]}
+    - {"allOf": [{"$ref": "#/components/schemas/..."}]}
+    - {"oneOf": [{"$ref": "#/components/schemas/..."}]}
+
+    Args:
+        info: dict[str, Any]
+        description: str | None
+
+    Returns:
+        dict[str, Any]
+    """
+    schema = info.copy()
+    if ref_path := schema.get("$ref"):
+        if ref_path.startswith("#/components/schemas/"):
+            schema_name = ref_path.split("/")[-1]
+            schema["$ref"] = f"#/$defs/{schema_name}"
+    elif properties := schema.get("properties"):
+        if "$ref" in properties:
+            schema["properties"] = _replace_ref_with_defs(properties)
+        else:
+            schema["properties"] = {
+                prop_name: _replace_ref_with_defs(prop_schema)
+                for prop_name, prop_schema in properties.items()
+            }
+    elif item_schema := schema.get("items"):
+        schema["items"] = _replace_ref_with_defs(item_schema)
+    for section in ["anyOf", "allOf", "oneOf"]:
+        for i, item in enumerate(schema.get(section, [])):
+            schema[section][i] = _replace_ref_with_defs(item)
+    if info.get("description", description) and not schema.get("description"):
+        schema["description"] = description
+    return schema
+
+
 def _combine_schemas(route: HTTPRoute) -> dict[str, Any]:
     """
     Combines parameter and request body schemas into a single schema.
@@ -889,38 +934,18 @@ def _combine_schemas(route: HTTPRoute) -> dict[str, Any]:
     for param in route.parameters:
         if param.required:
             required.append(param.name)
-
-        # Copy the schema and add description if available
-        param_schema = param.schema_.copy() if isinstance(param.schema_, dict) else {}
-
-        # Convert #/components/schemas references to #/$defs references
-        if isinstance(param_schema, dict) and "$ref" in param_schema:
-            ref_path = param_schema["$ref"]
-            if ref_path.startswith("#/components/schemas/"):
-                schema_name = ref_path.split("/")[-1]
-                param_schema["$ref"] = f"#/$defs/{schema_name}"
-
-        # Also handle anyOf, allOf, oneOf references
-        for section in ["anyOf", "allOf", "oneOf"]:
-            if section in param_schema and isinstance(param_schema[section], list):
-                for i, item in enumerate(param_schema[section]):
-                    if isinstance(item, dict) and "$ref" in item:
-                        ref_path = item["$ref"]
-                        if ref_path.startswith("#/components/schemas/"):
-                            schema_name = ref_path.split("/")[-1]
-                            param_schema[section][i]["$ref"] = f"#/$defs/{schema_name}"
-
-        # Add parameter description to schema if available and not already present
-        if param.description and not param_schema.get("description"):
-            param_schema["description"] = param.description
-
-        properties[param.name] = param_schema
+        properties[param.name] = _replace_ref_with_defs(
+            param.schema_.copy(), param.description
+        )
 
     # Add request body if it exists
     if route.request_body and route.request_body.content_schema:
         # For now, just use the first content type's schema
         content_type = next(iter(route.request_body.content_schema))
-        body_schema = route.request_body.content_schema[content_type]
+        body_schema = _replace_ref_with_defs(
+            route.request_body.content_schema[content_type].copy(),
+            route.request_body.description,
+        )
         body_props = body_schema.get("properties", {})
 
         # Add request body properties
@@ -935,7 +960,6 @@ def _combine_schemas(route: HTTPRoute) -> dict[str, Any]:
         "properties": properties,
         "required": required,
     }
-
     # Add schema definitions if available
     if route.schema_definitions:
         result["$defs"] = route.schema_definitions

fastmcp/utilities/types.py

@@ -9,11 +9,17 @@ from types import UnionType
 from typing import Annotated, TypeVar, Union, get_args, get_origin
 
 from mcp.types import ImageContent
-from pydantic import TypeAdapter
+from pydantic import BaseModel, ConfigDict, TypeAdapter
 
 T = TypeVar("T")
 
 
+class FastMCPBaseModel(BaseModel):
+    """Base model for FastMCP models."""
+
+    model_config = ConfigDict(extra="forbid")
+
+
 @lru_cache(maxsize=5000)
 def get_cached_typeadapter(cls: T) -> TypeAdapter[T]:
     """

{fastmcp-2.6.0.dist-info → fastmcp-2.7.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastmcp
-Version: 2.6.0
+Version: 2.7.0
 Summary: The fast, Pythonic way to build MCP servers.
 Project-URL: Homepage, https://gofastmcp.com
 Project-URL: Repository, https://github.com/jlowin/fastmcp
@@ -25,7 +25,8 @@ Requires-Dist: openapi-pydantic>=0.5.1
 Requires-Dist: python-dotenv>=1.1.0
 Requires-Dist: rich>=13.9.4
 Requires-Dist: typer>=0.15.2
-Requires-Dist: websockets>=14.0
+Provides-Extra: websockets
+Requires-Dist: websockets>=15.0.1; extra == 'websockets'
 Description-Content-Type: text/markdown
 
 <div align="center">
@@ -61,7 +62,7 @@ from fastmcp import FastMCP
 
 mcp = FastMCP("Demo 🚀")
 
-@mcp.tool()
+@mcp.tool
 def add(a: int, b: int) -> int:
     """Add two numbers"""
     return a + b
@@ -104,6 +105,7 @@ There are two ways to access the LLM-friendly documentation:
   - [Proxy Servers](#proxy-servers)
   - [Composing MCP Servers](#composing-mcp-servers)
   - [OpenAPI \& FastAPI Generation](#openapi--fastapi-generation)
+  - [Authentication \& Security](#authentication--security)
 - [Running Your Server](#running-your-server)
 - [Contributing](#contributing)
   - [Prerequisites](#prerequisites)
@@ -116,20 +118,20 @@ There are two ways to access the LLM-friendly documentation:
 
 ## What is MCP?
 
-The [Model Context Protocol (MCP)](https://modelcontextprotocol.io) lets you build servers that expose data and functionality to LLM applications in a secure, standardized way. Think of it like a web API, but specifically designed for LLM interactions. MCP servers can:
+The [Model Context Protocol (MCP)](https://modelcontextprotocol.io) lets you build servers that expose data and functionality to LLM applications in a secure, standardized way. It is often described as "the USB-C port for AI", providing a uniform way to connect LLMs to resources they can use. It may be easier to think of it as an API, but specifically designed for LLM interactions. MCP servers can:
 
-- Expose data through **Resources** (similar to `GET` requests; load info into context)
-- Provide functionality through **Tools** (similar to `POST`/`PUT` requests; execute actions)
-- Define interaction patterns through **Prompts** (reusable templates)
+- Expose data through **Resources** (think of these sort of like GET endpoints; they are used to load information into the LLM's context)
+- Provide functionality through **Tools** (sort of like POST endpoints; they are used to execute code or otherwise produce a side effect)
+- Define interaction patterns through **Prompts** (reusable templates for LLM interactions)
 - And more!
 
-FastMCP provides a high-level, Pythonic interface for building and interacting with these servers.
+FastMCP provides a high-level, Pythonic interface for building, managing, and interacting with these servers.
 
 ## Why FastMCP?
 
 The MCP protocol is powerful but implementing it involves a lot of boilerplate - server setup, protocol handlers, content types, error management. FastMCP handles all the complex protocol details and server management, so you can focus on building great tools. It's designed to be high-level and Pythonic; in most cases, decorating a function is all you need.
 
-While the core server concepts of FastMCP 1.0 laid the groundwork and were contributed to the official MCP SDK, **FastMCP 2.0 (this project) is the actively developed successor**, adding significant enhancements and entirely new capabilities like a powerful **client library**, server **proxying**, **composition** patterns, **OpenAPI/FastAPI integration**, and much more.
+FastMCP 2.0 has evolved into a comprehensive platform that goes far beyond basic protocol implementation. While 1.0 provided server-building capabilities (and is now part of the official MCP SDK), 2.0 offers a complete ecosystem including client libraries, authentication systems, deployment tools, integrations with major AI platforms, testing frameworks, and production-ready infrastructure patterns.
 
 FastMCP aims to be:
 
@@ -139,7 +141,7 @@ FastMCP aims to be:
 
 🐍 **Pythonic:** Feels natural to Python developers
 
-🔍 **Complete:** FastMCP aims to provide a full implementation of the core MCP specification for both servers and clients
+🔍 **Complete:** A comprehensive platform for all MCP use cases, from dev to prod
 
 ## Installation
 
@@ -157,7 +159,7 @@ These are the building blocks for creating MCP servers and clients with FastMCP.
 
 ### The `FastMCP` Server
 
-The central object representing your MCP application. It holds your tools, resources, and prompts, manages connections, and can be configured with settings like [authentication providers](https://gofastmcp.com/servers/fastmcp#authentication).
+The central object representing your MCP application. It holds your tools, resources, and prompts, manages connections, and can be configured with settings like authentication.
 
 ```python
 from fastmcp import FastMCP
@@ -173,7 +175,7 @@ Learn more in the [**FastMCP Server Documentation**](https://gofastmcp.com/serve
 Tools allow LLMs to perform actions by executing your Python functions (sync or async). Ideal for computations, API calls, or side effects (like `POST`/`PUT`). FastMCP handles schema generation from type hints and docstrings. Tools can return various types, including text, JSON-serializable objects, and even images using the [`fastmcp.Image`](https://gofastmcp.com/servers/tools#return-values) helper.
 
 ```python
-@mcp.tool()
+@mcp.tool
 def multiply(a: float, b: float) -> float:
     """Multiplies two numbers."""
     return a * b
@@ -202,10 +204,10 @@ Learn more in the [**Resources & Templates Documentation**](https://gofastmcp.co
 
 ### Prompts
 
-Prompts define reusable message templates to guide LLM interactions. Decorate functions with `@mcp.prompt()`. Return strings or `Message` objects.
+Prompts define reusable message templates to guide LLM interactions. Decorate functions with `@mcp.prompt`. Return strings or `Message` objects.
 
 ```python
-@mcp.prompt()
+@mcp.prompt
 def summarize_request(text: str) -> str:
     """Generate a prompt asking for a summary."""
     return f"Please summarize the following text:\n\n{text}"
@@ -230,7 +232,7 @@ from fastmcp import FastMCP, Context
 
 mcp = FastMCP("My MCP Server")
 
-@mcp.tool()
+@mcp.tool
 async def process_data(uri: str, ctx: Context):
     # Log a message to the client
     await ctx.info(f"Processing {uri}...")
@@ -328,7 +330,17 @@ Learn more in the [**Composition Documentation**](https://gofastmcp.com/patterns
 
 Automatically generate FastMCP servers from existing OpenAPI specifications (`FastMCP.from_openapi()`) or FastAPI applications (`FastMCP.from_fastapi()`), instantly bringing your web APIs to the MCP ecosystem.
 
-Learn more: [**OpenAPI Integration**](https://gofastmcp.com/patterns/openapi) | [**FastAPI Integration**](https://gofastmcp.com/patterns/fastapi).
+Learn more: [**OpenAPI Integration**](https://gofastmcp.com/servers/openapi#openapi-integration) | [**FastAPI Integration**](https://gofastmcp.com/deployment/asgi#fastapi-integration).
+
+### Authentication & Security
+
+FastMCP provides built-in authentication support to secure both your MCP servers and clients in production environments. Protect your server endpoints from unauthorized access and authenticate your clients against secured MCP servers using industry-standard protocols.
+
+- **Server Protection**: Secure your FastMCP server endpoints with configurable authentication providers
+- **Client Authentication**: Connect to authenticated MCP servers with automatic credential management
+- **Production Ready**: Support for common authentication patterns used in enterprise environments
+
+Learn more in the **Authentication Documentation** for [servers](https://gofastmcp.com/servers/auth) and [clients](https://gofastmcp.com/clients/auth).
 
 ## Running Your Server
 
@@ -340,7 +352,7 @@ from fastmcp import FastMCP
 
 mcp = FastMCP("Demo 🚀")
 
-@mcp.tool()
+@mcp.tool
 def hello(name: str) -> str:
     return f"Hello, {name}!"
 

{fastmcp-2.6.0.dist-info → fastmcp-2.7.0.dist-info}/RECORD

@@ -1,10 +1,11 @@
 fastmcp/__init__.py,sha256=yTAqLZORsPqbr7AE0ayw6zIYBeMlxQlI-3HE2WqbvHk,435
 fastmcp/exceptions.py,sha256=YvaKqOT3w0boXF9ylIoaSIzW9XiQ1qLFG1LZq6B60H8,680
+fastmcp/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fastmcp/settings.py,sha256=DbFdWx4EVHhJZF6e2GB0pBMCSjc425kXIVY8mqfOVX8,6175
 fastmcp/cli/__init__.py,sha256=Ii284TNoG5lxTP40ETMGhHEq3lQZWxu9m9JuU57kUpQ,87
 fastmcp/cli/claude.py,sha256=IAlcZ4qZKBBj09jZUMEx7EANZE_IR3vcu7zOBJmMOuU,4567
-fastmcp/cli/cli.py,sha256=CQxpRTXgnQQynGJLEV5g1FnLMaiWoiUgefnMZ7VxS4o,12367
-fastmcp/cli/run.py,sha256=o7Ge6JZKXYwlY2vYdMNoVX8agBchAaeU_73iPndojIM,5351
+fastmcp/cli/cli.py,sha256=zoHJ8DjUBLISVb4VHaVP-fCJP4Y8zG6-UhhNqSvczqY,12667
+fastmcp/cli/run.py,sha256=sGH7M3Yi8HGju4sPypKGk3P2cdZq1n3l-_CpJmdGvDc,6277
 fastmcp/client/__init__.py,sha256=kd2hhSuD8rZuF87c9zlPJP_icJ-Rx3exyNoK0EzfOtE,617
 fastmcp/client/client.py,sha256=vQk0l6htoD6CyO0le8q23iYd5hX1l8NIbxchedbWqgE,24872
 fastmcp/client/logging.py,sha256=hOPRailZUp89RUck6V4HPaWVZinVrNY8HD4hD0dd-fE,822
@@ -12,56 +13,55 @@ fastmcp/client/oauth_callback.py,sha256=ODAnVX-ettL82RuI5KpfkKf8iDtYMDue3Tnab5sj
 fastmcp/client/progress.py,sha256=WjLLDbUKMsx8DK-fqO7AGsXb83ak-6BMrLvzzznGmcI,1043
 fastmcp/client/roots.py,sha256=IxI_bHwHTmg6c2H-s1av1ZgrRnNDieHtYwdGFbzXT5c,2471
 fastmcp/client/sampling.py,sha256=UlDHxnd6k_HoU8RA3ob0g8-e6haJBc9u27N_v291QoI,1698
-fastmcp/client/transports.py,sha256=XBbw5nDzDQffeWmfDgWgXZUOX0hJqk3fdusnqqUge9c,31822
+fastmcp/client/transports.py,sha256=Pi4g2B9lKbgvey-7lTLkjsSVxE2DoT2yMq82D7xktK0,32091
 fastmcp/client/auth/__init__.py,sha256=4DNsfp4iaQeBcpds0JDdMn6Mmfud44stWLsret0sVKY,91
 fastmcp/client/auth/bearer.py,sha256=MFEFqcH6u_V86msYiOsEFKN5ks1V9BnBNiPsPLHUTqo,399
-fastmcp/client/auth/oauth.py,sha256=qznXKVnoTHpmhUzRgIcQ-44l-_FMBZ4Vmn4wG5njXOM,14865
+fastmcp/client/auth/oauth.py,sha256=LJHCB-34EC-sL9GC97XFQkyanK8Cc5skAp6GkH0tKzE,14709
 fastmcp/contrib/README.md,sha256=rKknYSI1T192UvSszqwwDlQ2eYQpxywrNTLoj177SYU,878
 fastmcp/contrib/bulk_tool_caller/README.md,sha256=5aUUY1TSFKtz1pvTLSDqkUCkGkuqMfMZNsLeaNqEgAc,1960
 fastmcp/contrib/bulk_tool_caller/__init__.py,sha256=xvGSSaUXTQrc31erBoi1Gh7BikgOliETDiYVTP3rLxY,75
 fastmcp/contrib/bulk_tool_caller/bulk_tool_caller.py,sha256=2NcrGS59qvHo1lfbRaT8NSWfCxN66knciLxFvnGwCLY,4165
-fastmcp/contrib/bulk_tool_caller/example.py,sha256=3RdsU2KrRwYZHEdVAmHOGJsO3ZJBxSaqz8BTznkPg7Y,321
+fastmcp/contrib/bulk_tool_caller/example.py,sha256=6og_8pCJN_CabworC5R82zPAwwwM-W7HNJLQQSnS3lU,319
 fastmcp/contrib/mcp_mixin/README.md,sha256=9DDTJXWkA3yv1fp5V58gofmARPQ2xWDhblYGvUhKpDQ,1689
 fastmcp/contrib/mcp_mixin/__init__.py,sha256=aw9IQ1ssNjCgws4ZNt8bkdpossAAGVAwwjBpMp9O5ZQ,153
 fastmcp/contrib/mcp_mixin/example.py,sha256=GnunkXmtG5hLLTUsM8aW5ZURU52Z8vI4tNLl-fK7Dg0,1228
-fastmcp/contrib/mcp_mixin/mcp_mixin.py,sha256=cfIRbnSxsVzglTD-auyTE0izVQeHP7Oz18qzYoBZJgg,7899
+fastmcp/contrib/mcp_mixin/mcp_mixin.py,sha256=3e0wHlKI9OF12t-SbpRTL-TWjBBLw7T8ATjCdoDtX6k,8173
 fastmcp/prompts/__init__.py,sha256=An8uMBUh9Hrb7qqcn_5_Hent7IOeSh7EA2IUVsIrtHc,179
-fastmcp/prompts/prompt.py,sha256=_bMuLMSnkH_vJpPcf_b8HOUnMOsQJXZdtjZBoebzNjI,8249
-fastmcp/prompts/prompt_manager.py,sha256=qptEhZHMwc8XxQd5lTQg8iIb5MiTZVsNaux_XLvQ0mw,3871
-fastmcp/resources/__init__.py,sha256=t0x1j8lc74rjUKtXe9H5Gs4fpQt82K4NgBK6Y7A0xTg,467
-fastmcp/resources/resource.py,sha256=Rx1My_fi1f-oqnQ9R_v7ejopAk4BJDfbB75-s4d31dM,2492
-fastmcp/resources/resource_manager.py,sha256=nsgCR3lo9t4Q0QR6txPfAas2upqIb8P8ZlqWAfV9Qc0,11344
-fastmcp/resources/template.py,sha256=u0_-yNMmZfnl5DqtSRndGbGBrm7JgbzBU8IUd0hrEWE,7523
-fastmcp/resources/types.py,sha256=5fUFvzRlekNjtfihtq8S-fT0alKoNfclzrugqeM5JRE,6366
+fastmcp/prompts/prompt.py,sha256=FMvDO3491LJkdPSorKKwr_2KtDJx_C54iYDbGtBzH5M,9474
+fastmcp/prompts/prompt_manager.py,sha256=zAxlMzNHt8z5tD6lHl60aETvCBq6FNfE_1I4p5juKRE,4161
+fastmcp/resources/__init__.py,sha256=y1iAuqx-GIrS1NqIYzKezIDiYyjNEzzHD35epHpMnXE,463
+fastmcp/resources/resource.py,sha256=pvyeuUJvBGyudvxEKiBsof8B5X1EfYpCNwC4wO3-rZA,5139
+fastmcp/resources/resource_manager.py,sha256=AZO05oYJ6DmFst7hWedT6Jx7WfhISodw4K-HdQpY5iI,11761
+fastmcp/resources/template.py,sha256=EDoPOMFRwCNHugEtmlcuTuWx2O1qe5_nUOLrGNYvsXM,8749
+fastmcp/resources/types.py,sha256=SiYNLnpXT-mHgNUrzqKUvXYUsY-V3gwJIrYdJfFwDDo,4868
 fastmcp/server/__init__.py,sha256=bMD4aQD4yJqLz7-mudoNsyeV8UgQfRAg3PRwPvwTEds,119
-fastmcp/server/context.py,sha256=yN1e0LsnCl7cEpr9WlbvFhSf8oE56kKb-20m8h2SsBY,10171
+fastmcp/server/context.py,sha256=7r-gxMiCgDpd9AStTk0hwfme540H7S1dEcU0bjoerxU,10169
 fastmcp/server/dependencies.py,sha256=DfN40fz4UkmdzvVg3QesuHKUVJ07iQU5ookkWawAoH4,2336
 fastmcp/server/http.py,sha256=RbUnqqKsiThOGZwJH-BIzC5_V1EXQh9tBlN4S-JJhbY,11624
-fastmcp/server/openapi.py,sha256=yYO-_9QQhi6IUGW-TsSHkhZFLll4wt5ysbtl0VHaHZM,39239
-fastmcp/server/proxy.py,sha256=mt3eM6TQWfnZD5XehmTXisskZ4CBbsWyjRPjprlTjBY,9653
-fastmcp/server/server.py,sha256=l1kD2MBTEiZTB6pYXBSB7T3cYMRe1Fk6tQvOhLJZQyM,58210
+fastmcp/server/openapi.py,sha256=heLQA3B57nCOLNsbOYLVFbZGI8XQaVeXL6ST5L55vuo,38596
+fastmcp/server/proxy.py,sha256=EVup0L4gGMnxkG2SJHE09ugKvfhPyJ_3AnkhAS-Dc3E,9562
+fastmcp/server/server.py,sha256=pupGTlXcbindBILxYQoFYqQomQcDMK5QS04vTngYIdk,65399
 fastmcp/server/auth/__init__.py,sha256=doHCLwOIElvH1NrTdpeP9JKfnNf3MDYPSpQfdsQ-uI0,84
 fastmcp/server/auth/auth.py,sha256=kz02HGwXYU0N0clURZDjFNWdKSpTYmgmCnGJN-jSG3Y,1640
 fastmcp/server/auth/providers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fastmcp/server/auth/providers/bearer.py,sha256=3pTKL3tEU7FlCD5yI81LTa2n0dBsM7GRpIIn30WCWsA,12679
 fastmcp/server/auth/providers/bearer_env.py,sha256=MXsr4rjRm8DDmbdNd7IEXT6naCq48fkC1LlpoFAjt7c,1971
-fastmcp/server/auth/providers/in_memory.py,sha256=PmHc6qnnPB2DDY9ybokvp0JL536llwCTmcd1B7-RTpo,13909
-fastmcp/tools/__init__.py,sha256=ocw-SFTtN6vQ8fgnlF8iNAOflRmh79xS1xdO0Bc3QPE,96
-fastmcp/tools/tool.py,sha256=Lj0PZYNKbqZRBouqn17ayz2gDgU2-bEfHOC75r4GOB8,8687
-fastmcp/tools/tool_manager.py,sha256=HVT1-8Sdir5yY45oOUedMWnD8HJUkVkLUy0U-eAayoQ,4516
+fastmcp/server/auth/providers/in_memory.py,sha256=sCRJambxXFZLg_EbJ5ma-aUZvtxuuKbGy7lTxIbzVb0,13772
+fastmcp/tools/__init__.py,sha256=G-XFAr0RhVFj_crAZFaWZDUqcBPCTCyzAndpKXtpIFc,126
+fastmcp/tools/tool.py,sha256=J5VDyQE85IyZPXEq8x0n1V2qdNJ5zVlgB7FkzxJwW9E,9994
+fastmcp/tools/tool_manager.py,sha256=C3mB0lgQU-vmcrUltqck-Yx7zrnIHXthHijS-dJliU8,4724
 fastmcp/utilities/__init__.py,sha256=-imJ8S-rXmbXMWeDamldP-dHDqAPg_wwmPVz-LNX14E,31
 fastmcp/utilities/cache.py,sha256=aV3oZ-ZhMgLSM9iAotlUlEy5jFvGXrVo0Y5Bj4PBtqY,707
-fastmcp/utilities/decorators.py,sha256=AjhjsetQZF4YOPV5MTZmIxO21iFp_4fDIS3O2_KNCEg,2990
 fastmcp/utilities/exceptions.py,sha256=Aax9K0larjzrrgJBS6o_PQwoIrvBvVwck2suZvgafXE,1359
 fastmcp/utilities/http.py,sha256=1ns1ymBS-WSxbZjGP6JYjSO52Wa_ls4j4WbnXiupoa4,245
 fastmcp/utilities/json_schema.py,sha256=m65XU9lPq7pCxJ9vvCeGRl0HOFr6ArezvYpMBR6-gAg,3777
 fastmcp/utilities/logging.py,sha256=B1WNO-ZWFjd9wiFSh13YtW1hAKaNmbpscDZleIAhr-g,1317
-fastmcp/utilities/mcp_config.py,sha256=_wY3peaFDEgyOBkJ_Tb8sETk3mtdwtw1053q7ry0za0,2169
-fastmcp/utilities/openapi.py,sha256=QQos4vP59HQ8vPDTKftWOIVv_zmW30mNxYSXVU7JUbY,38441
+fastmcp/utilities/mcp_config.py,sha256=Htux1dKyDaeK6-gT_fZwpJ_yj0MxUjGfPFAY3Dnnxsk,2233
+fastmcp/utilities/openapi.py,sha256=ctceiGb4jYgzZGSseMb-yZccEEXf41P-dhB3ae9lGdk,38992
 fastmcp/utilities/tests.py,sha256=4Vuua6nVgbE5uQspEK0fk4tBuJ0rO4GTBmnyD0kXJPA,3930
-fastmcp/utilities/types.py,sha256=6CcqAQ1QqCO2HGSFlPS6FO5JRWnacjCcO2-EhyEnZV0,4400
-fastmcp-2.6.0.dist-info/METADATA,sha256=vKeS0OYYNKKjJLcXi6jLtnb9TIsBo9niw38QTfwruxg,16605
-fastmcp-2.6.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-fastmcp-2.6.0.dist-info/entry_points.txt,sha256=ff8bMtKX1JvXyurMibAacMSKbJEPmac9ffAKU9mLnM8,44
-fastmcp-2.6.0.dist-info/licenses/LICENSE,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
-fastmcp-2.6.0.dist-info/RECORD,,
+fastmcp/utilities/types.py,sha256=HX1y4JrDC3sZA2ENRqsyxMyLQepr5-JiS9StXhIX8TE,4548
+fastmcp-2.7.0.dist-info/METADATA,sha256=kXjE9Y1-qt0-OP2PVR2b1Gjdp6QKb68olWBNxM5xQmc,17687
+fastmcp-2.7.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+fastmcp-2.7.0.dist-info/entry_points.txt,sha256=ff8bMtKX1JvXyurMibAacMSKbJEPmac9ffAKU9mLnM8,44
+fastmcp-2.7.0.dist-info/licenses/LICENSE,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
+fastmcp-2.7.0.dist-info/RECORD,,