fastmcp 2.2.5__py3-none-any.whl → 2.2.6__py3-none-any.whl

fastmcp/__init__.py

@@ -14,6 +14,7 @@ __all__ = [
     "FastMCP",
     "Context",
     "client",
+    "Client",
     "settings",
     "Image",
 ]

fastmcp/client/base.py

@@ -1 +0,0 @@
-

fastmcp/client/client.py

@@ -5,12 +5,9 @@ from typing import Any, Literal, cast, overload
 
 import mcp.types
 from mcp import ClientSession
-from mcp.client.session import (
-    LoggingFnT,
-    MessageHandlerFnT,
-)
 from pydantic import AnyUrl
 
+from fastmcp.client.logging import LogHandler, MessageHandler
 from fastmcp.client.roots import (
     RootsHandler,
     RootsList,
@@ -22,7 +19,14 @@ from fastmcp.server import FastMCP
 
 from .transports import ClientTransport, SessionKwargs, infer_transport
 
-__all__ = ["Client", "RootsHandler", "RootsList"]
+__all__ = [
+    "Client",
+    "RootsHandler",
+    "RootsList",
+    "LogHandler",
+    "MessageHandler",
+    "SamplingHandler",
+]
 
 
 class Client:
@@ -35,12 +39,12 @@ class Client:
 
     def __init__(
         self,
-        transport: ClientTransport | FastMCP | AnyUrl | Path | str,
+        transport: ClientTransport | FastMCP | AnyUrl | Path | dict[str, Any] | str,
         # Common args
         roots: RootsList | RootsHandler | None = None,
         sampling_handler: SamplingHandler | None = None,
-        log_handler: LoggingFnT | None = None,
-        message_handler: MessageHandlerFnT | None = None,
+        log_handler: LogHandler | None = None,
+        message_handler: MessageHandler | None = None,
         read_timeout_seconds: datetime.timedelta | None = None,
     ):
         self.transport = infer_transport(transport)

fastmcp/client/logging.py

@@ -0,0 +1,13 @@
+from typing import TypeAlias
+
+from mcp.client.session import (
+    LoggingFnT,
+    MessageHandlerFnT,
+)
+from mcp.types import LoggingMessageNotificationParams
+
+LogMessage: TypeAlias = LoggingMessageNotificationParams
+LogHandler: TypeAlias = LoggingFnT
+MessageHandler: TypeAlias = MessageHandlerFnT
+
+__all__ = ["LogMessage", "LogHandler", "MessageHandler"]

fastmcp/client/sampling.py

@@ -9,6 +9,8 @@ from mcp.shared.context import LifespanContextT, RequestContext
 from mcp.types import CreateMessageRequestParams as SamplingParams
 from mcp.types import SamplingMessage
 
+__all__ = ["SamplingMessage", "SamplingParams", "MessageResult", "SamplingHandler"]
+
 
 class MessageResult(CreateMessageResult):
     role: mcp.types.Role = "assistant"

fastmcp/client/transports.py

@@ -6,9 +6,7 @@ import shutil
 import sys
 from collections.abc import AsyncIterator
 from pathlib import Path
-from typing import (
-    TypedDict,
-)
+from typing import Any, TypedDict
 
 from exceptiongroup import BaseExceptionGroup, catch
 from mcp import ClientSession, McpError, StdioServerParameters
@@ -416,7 +414,7 @@ class FastMCPTransport(ClientTransport):
 
 
 def infer_transport(
-    transport: ClientTransport | FastMCPServer | AnyUrl | Path | str,
+    transport: ClientTransport | FastMCPServer | AnyUrl | Path | dict[str, Any] | str,
 ) -> ClientTransport:
     """
     Infer the appropriate transport type from the given transport argument.
@@ -450,6 +448,41 @@ def infer_transport(
     elif isinstance(transport, AnyUrl | str) and str(transport).startswith("ws"):
         return WSTransport(url=transport)
 
+    ## if the transport is a config dict
+    elif isinstance(transport, dict):
+        if "mcpServers" not in transport:
+            raise ValueError("Invalid transport dictionary: missing 'mcpServers' key")
+        else:
+            server = transport["mcpServers"]
+            if len(list(server.keys())) > 1:
+                raise ValueError(
+                    "Invalid transport dictionary: multiple servers found - only one expected"
+                )
+            server_name = list(server.keys())[0]
+            # Stdio transport
+            if "command" in server[server_name] and "args" in server[server_name]:
+                return StdioTransport(
+                    command=server[server_name]["command"],
+                    args=server[server_name]["args"],
+                    env=server[server_name].get("env", None),
+                    cwd=server[server_name].get("cwd", None),
+                )
+
+            # HTTP transport
+            elif "url" in server:
+                return SSETransport(
+                    url=server["url"],
+                    headers=server.get("headers", None),
+                )
+
+            # WebSocket transport
+            elif "ws_url" in server:
+                return WSTransport(
+                    url=server["ws_url"],
+                )
+
+            raise ValueError("Cannot determine transport type from dictionary")
+
     # the transport is an unknown type
     else:
         raise ValueError(f"Could not infer a valid transport from: {transport}")

fastmcp/server/context.py

@@ -1,7 +1,8 @@
 from __future__ import annotations as _annotations
 
-from typing import Any, Generic, Literal
+from typing import Any, Generic
 
+from mcp import LoggingLevel
 from mcp.server.lowlevel.helper_types import ReadResourceContents
 from mcp.server.session import ServerSessionT
 from mcp.shared.context import LifespanContextT, RequestContext
@@ -122,19 +123,20 @@ class Context(BaseModel, Generic[ServerSessionT, LifespanContextT]):
 
     async def log(
         self,
-        level: Literal["debug", "info", "warning", "error"],
         message: str,
-        *,
+        level: LoggingLevel | None = None,
         logger_name: str | None = None,
     ) -> None:
         """Send a log message to the client.
 
         Args:
-            level: Log level (debug, info, warning, error)
             message: Log message
+            level: Optional log level. One of "debug", "info", "notice", "warning", "error", "critical",
+                "alert", or "emergency". Default is "info".
             logger_name: Optional logger name
-            **extra: Additional structured data to include
         """
+        if level is None:
+            level = "info"
         await self.request_context.session.send_log_message(
             level=level, data=message, logger=logger_name
         )
@@ -159,21 +161,21 @@ class Context(BaseModel, Generic[ServerSessionT, LifespanContextT]):
         return self.request_context.session
 
     # Convenience methods for common log levels
-    async def debug(self, message: str, **extra: Any) -> None:
+    async def debug(self, message: str, logger_name: str | None = None) -> None:
         """Send a debug log message."""
-        await self.log("debug", message, **extra)
+        await self.log(level="debug", message=message, logger_name=logger_name)
 
-    async def info(self, message: str, **extra: Any) -> None:
+    async def info(self, message: str, logger_name: str | None = None) -> None:
         """Send an info log message."""
-        await self.log("info", message, **extra)
+        await self.log(level="info", message=message, logger_name=logger_name)
 
-    async def warning(self, message: str, **extra: Any) -> None:
+    async def warning(self, message: str, logger_name: str | None = None) -> None:
         """Send a warning log message."""
-        await self.log("warning", message, **extra)
+        await self.log(level="warning", message=message, logger_name=logger_name)
 
-    async def error(self, message: str, **extra: Any) -> None:
+    async def error(self, message: str, logger_name: str | None = None) -> None:
         """Send an error log message."""
-        await self.log("error", message, **extra)
+        await self.log(level="error", message=message, logger_name=logger_name)
 
     async def list_roots(self) -> list[Root]:
         """List the roots available to the server, as indicated by the client."""

fastmcp/server/openapi.py

@@ -10,12 +10,12 @@ from re import Pattern
 from typing import TYPE_CHECKING, Any, Literal
 
 import httpx
-from mcp.types import TextContent
+from mcp.types import EmbeddedResource, ImageContent, TextContent
 from pydantic.networks import AnyUrl
 
 from fastmcp.resources import Resource, ResourceTemplate
 from fastmcp.server.server import FastMCP
-from fastmcp.tools.tool import Tool
+from fastmcp.tools.tool import Tool, _convert_to_content
 from fastmcp.utilities import openapi
 from fastmcp.utilities.func_metadata import func_metadata
 from fastmcp.utilities.logging import get_logger
@@ -125,6 +125,7 @@ class OpenAPITool(Tool):
         fn_metadata: Any,
         is_async: bool = True,
         tags: set[str] = set(),
+        timeout: float | None = None,
     ):
         super().__init__(
             name=name,
@@ -138,6 +139,7 @@ class OpenAPITool(Tool):
         )
         self._client = client
         self._route = route
+        self._timeout = timeout
 
     async def _execute_request(self, *args, **kwargs):
         """Execute the HTTP request based on the route configuration."""
@@ -147,19 +149,37 @@ class OpenAPITool(Tool):
         path = self._route.path
 
         # Replace path parameters with values from kwargs
+        # 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)
             for p in self._route.parameters
             if p.location == "path"
+            and p.name in kwargs
+            and kwargs.get(p.name) is not None
         }
+
+        # Ensure all path parameters are provided
+        required_path_params = {
+            p.name
+            for p in self._route.parameters
+            if p.location == "path" and p.required
+        }
+        missing_params = required_path_params - path_params.keys()
+        if missing_params:
+            raise ValueError(f"Missing required path parameters: {missing_params}")
+
         for param_name, param_value in path_params.items():
             path = path.replace(f"{{{param_name}}}", str(param_value))
 
-        # Prepare query parameters
+        # Prepare query parameters - filter out None and empty strings
         query_params = {
             p.name: kwargs.get(p.name)
             for p in self._route.parameters
-            if p.location == "query" and p.name in kwargs
+            if p.location == "query"
+            and p.name in kwargs
+            and kwargs.get(p.name) is not None
+            and kwargs.get(p.name) != ""
         }
 
         # Prepare headers - fix typing by ensuring all values are strings
@@ -206,7 +226,7 @@ class OpenAPITool(Tool):
                 params=query_params,
                 headers=headers,
                 json=json_data,
-                timeout=30.0,  # Default timeout
+                timeout=self._timeout,
             )
 
             # Raise for 4xx/5xx responses
@@ -237,9 +257,14 @@ class OpenAPITool(Tool):
             # Handle request errors (connection, timeout, etc.)
             raise ValueError(f"Request error: {str(e)}")
 
-    async def run(self, arguments: dict[str, Any], context: Any = None) -> Any:
+    async def run(
+        self,
+        arguments: dict[str, Any],
+        context: Context[ServerSessionT, LifespanContextT] | None = None,
+    ) -> list[TextContent | ImageContent | EmbeddedResource]:
         """Run the tool with arguments and optional context."""
-        return await self._execute_request(**arguments, context=context)
+        response = await self._execute_request(**arguments, context=context)
+        return _convert_to_content(response)
 
 
 class OpenAPIResource(Resource):
@@ -254,6 +279,7 @@ class OpenAPIResource(Resource):
         description: str,
         mime_type: str = "application/json",
         tags: set[str] = set(),
+        timeout: float | None = None,
     ):
         super().__init__(
             uri=AnyUrl(uri),  # Convert string to AnyUrl
@@ -264,6 +290,7 @@ class OpenAPIResource(Resource):
         )
         self._client = client
         self._route = route
+        self._timeout = timeout
 
     async def read(
         self, context: Context[ServerSessionT, LifespanContextT] | None = None
@@ -278,30 +305,44 @@ class OpenAPIResource(Resource):
             if "{" in path and "}" in path:
                 # Extract the resource ID from the URI (the last part after the last slash)
                 parts = resource_uri.split("/")
+
                 if len(parts) > 1:
                     # Find all path parameters in the route path
                     path_params = {}
 
-                    # Extract parameters from the URI
-                    param_value = parts[
-                        -1
-                    ]  # The last part contains the parameter value
-
-                    # Find the path parameter name from the route path
+                    # Find the path parameter names from the route path
                     param_matches = re.findall(r"\{([^}]+)\}", path)
                     if param_matches:
-                        # Assume the last parameter in the URI is for the first path parameter in the route
-                        path_param_name = param_matches[0]
-                        path_params[path_param_name] = param_value
+                        # Reverse sorting from creation order (traversal is backwards)
+                        param_matches.sort(reverse=True)
+                        # Number of sent parameters is number of parts -1 (assuming first part is resource identifier)
+                        expected_param_count = len(parts) - 1
+                        # Map parameters from the end of the URI to the parameters in the path
+                        # Last parameter in URI (parts[-1]) maps to last parameter in path, and so on
+                        for i, param_name in enumerate(param_matches):
+                            # Ensure we don't use resource identifier as parameter
+                            if i < expected_param_count:
+                                # Get values from the end of parts
+                                param_value = parts[-1 - i]
+                                path_params[param_name] = param_value
 
                     # Replace path parameters with their values
                     for param_name, param_value in path_params.items():
                         path = path.replace(f"{{{param_name}}}", str(param_value))
 
+            # Filter any query parameters - get query parameters and filter out None/empty values
+            query_params = {}
+            for param in self._route.parameters:
+                if param.location == "query" and hasattr(self, f"_{param.name}"):
+                    value = getattr(self, f"_{param.name}")
+                    if value is not None and value != "":
+                        query_params[param.name] = value
+
             response = await self._client.request(
                 method=self._route.method,
                 url=path,
-                timeout=30.0,  # Default timeout
+                params=query_params,
+                timeout=self._timeout,
             )
 
             # Raise for 4xx/5xx responses
@@ -349,6 +390,7 @@ class OpenAPIResourceTemplate(ResourceTemplate):
         description: str,
         parameters: dict[str, Any],
         tags: set[str] = set(),
+        timeout: float | None = None,
     ):
         super().__init__(
             uri_template=uri_template,
@@ -361,6 +403,7 @@ class OpenAPIResourceTemplate(ResourceTemplate):
         )
         self._client = client
         self._route = route
+        self._timeout = timeout
 
     async def create_resource(
         self,
@@ -383,6 +426,7 @@ class OpenAPIResourceTemplate(ResourceTemplate):
             description=self.description or f"Resource for {self._route.path}",
             mime_type="application/json",
             tags=set(self._route.tags or []),
+            timeout=self._timeout,
         )
 
 
@@ -430,6 +474,7 @@ class FastMCPOpenAPI(FastMCP):
         client: httpx.AsyncClient,
         name: str | None = None,
         route_maps: list[RouteMap] | None = None,
+        timeout: float | None = None,
         **settings: Any,
     ):
         """
@@ -440,13 +485,13 @@ class FastMCPOpenAPI(FastMCP):
             client: httpx AsyncClient for making HTTP requests
             name: Optional name for the server
             route_maps: Optional list of RouteMap objects defining route mappings
-            default_mime_type: Default MIME type for resources
+            timeout: Optional timeout (in seconds) for all requests
             **settings: Additional settings for FastMCP
         """
         super().__init__(name=name or "OpenAPI FastMCP", **settings)
 
         self._client = client
-
+        self._timeout = timeout
         http_routes = openapi.parse_openapi_to_http_routes(openapi_spec)
 
         # Process routes
@@ -504,6 +549,7 @@ class FastMCPOpenAPI(FastMCP):
             fn_metadata=func_metadata(_openapi_passthrough),
             is_async=True,
             tags=set(route.tags or []),
+            timeout=self._timeout,
         )
         # Register the tool by directly assigning to the tools dictionary
         self._tool_manager._tools[tool_name] = tool
@@ -532,6 +578,7 @@ class FastMCPOpenAPI(FastMCP):
             name=resource_name,
             description=enhanced_description,
             tags=set(route.tags or []),
+            timeout=self._timeout,
         )
         # Register the resource by directly assigning to the resources dictionary
         self._resource_manager._resources[str(resource.uri)] = resource
@@ -577,6 +624,7 @@ class FastMCPOpenAPI(FastMCP):
             description=enhanced_description,
             parameters=template_params_schema,
             tags=set(route.tags or []),
+            timeout=self._timeout,
         )
         # Register the template by directly assigning to the templates dictionary
         self._resource_manager._templates[uri_template_str] = template
@@ -589,13 +637,4 @@ class FastMCPOpenAPI(FastMCP):
 
         context = self.get_context()
         result = await self._tool_manager.call_tool(name, arguments, context=context)
-
-        # For other tools, ensure the response is wrapped in TextContent
-        if isinstance(result, dict | str):
-            if isinstance(result, dict):
-                result_text = json.dumps(result)
-            else:
-                result_text = result
-            return [TextContent(text=result_text, type="text")]
-
         return result

fastmcp/server/proxy.py

@@ -61,7 +61,7 @@ class ProxyTool(Tool):
         self,
         arguments: dict[str, Any],
         context: Context[ServerSessionT, LifespanContextT] | None = None,
-    ) -> Any:
+    ) -> list[TextContent | ImageContent | EmbeddedResource]:
         # the client context manager will swallow any exceptions inside a TaskGroup
         # so we return the raw result and raise an exception ourselves
         async with self._client:

fastmcp/server/server.py

@@ -1,5 +1,7 @@
 """FastMCP - A more ergonomic interface for MCP servers."""
 
+from __future__ import annotations
+
 import datetime
 from collections.abc import AsyncIterator, Awaitable, Callable
 from contextlib import (
@@ -63,7 +65,7 @@ class MountedServer:
     def __init__(
         self,
         prefix: str,
-        server: "FastMCP",
+        server: FastMCP,
         tool_separator: str | None = None,
         resource_separator: str | None = None,
         prompt_separator: str | None = None,
@@ -149,7 +151,7 @@ class TimedCache:
 
 
 @asynccontextmanager
-async def default_lifespan(server: "FastMCP") -> AsyncIterator[Any]:
+async def default_lifespan(server: FastMCP) -> AsyncIterator[Any]:
     """Default lifespan context manager that does nothing.
 
     Args:
@@ -162,8 +164,8 @@ async def default_lifespan(server: "FastMCP") -> AsyncIterator[Any]:
 
 
 def _lifespan_wrapper(
-    app: "FastMCP",
-    lifespan: Callable[["FastMCP"], AbstractAsyncContextManager[LifespanResultT]],
+    app: FastMCP,
+    lifespan: Callable[[FastMCP], AbstractAsyncContextManager[LifespanResultT]],
 ) -> Callable[
     [MCPServer[LifespanResultT]], AbstractAsyncContextManager[LifespanResultT]
 ]:
@@ -182,7 +184,11 @@ class FastMCP(Generic[LifespanResultT]):
         name: str | None = None,
         instructions: str | None = None,
         lifespan: (
-            Callable[["FastMCP"], AbstractAsyncContextManager[LifespanResultT]] | None
+            Callable[
+                [FastMCP[LifespanResultT]],
+                AbstractAsyncContextManager[LifespanResultT],
+            ]
+            | None
         ) = None,
         tags: set[str] | None = None,
         **settings: Any,
@@ -273,7 +279,7 @@ class FastMCP(Generic[LifespanResultT]):
         self._mcp_server.get_prompt()(self._mcp_get_prompt)
         self._mcp_server.list_resource_templates()(self._mcp_list_resource_templates)
 
-    def get_context(self) -> "Context[ServerSession, LifespanResultT]":
+    def get_context(self) -> Context[ServerSession, LifespanResultT]:
         """
         Returns a Context object. Note that the context will only be valid
         during a request; outside a request, most methods will error.
@@ -766,7 +772,7 @@ class FastMCP(Generic[LifespanResultT]):
     def mount(
         self,
         prefix: str,
-        server: "FastMCP",
+        server: FastMCP[LifespanResultT],
         tool_separator: str | None = None,
         resource_separator: str | None = None,
         prompt_separator: str | None = None,
@@ -791,7 +797,7 @@ class FastMCP(Generic[LifespanResultT]):
     async def import_server(
         self,
         prefix: str,
-        server: "FastMCP",
+        server: FastMCP[LifespanResultT],
         tool_separator: str | None = None,
         resource_separator: str | None = None,
         prompt_separator: str | None = None,
@@ -865,7 +871,7 @@ class FastMCP(Generic[LifespanResultT]):
     @classmethod
     def from_openapi(
         cls, openapi_spec: dict[str, Any], client: httpx.AsyncClient, **settings: Any
-    ) -> "FastMCPOpenAPI":
+    ) -> FastMCPOpenAPI:
         """
         Create a FastMCP server from an OpenAPI specification.
         """
@@ -875,8 +881,8 @@ class FastMCP(Generic[LifespanResultT]):
 
     @classmethod
     def from_fastapi(
-        cls, app: "Any", name: str | None = None, **settings: Any
-    ) -> "FastMCPOpenAPI":
+        cls, app: Any, name: str | None = None, **settings: Any
+    ) -> FastMCPOpenAPI:
         """
         Create a FastMCP server from a FastAPI application.
         """
@@ -894,7 +900,7 @@ class FastMCP(Generic[LifespanResultT]):
         )
 
     @classmethod
-    def from_client(cls, client: "Client", **settings: Any) -> "FastMCPProxy":
+    def from_client(cls, client: Client, **settings: Any) -> FastMCPProxy:
         """
         Create a FastMCP proxy server from a FastMCP client.
         """

{fastmcp-2.2.5.dist-info → fastmcp-2.2.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastmcp
-Version: 2.2.5
+Version: 2.2.6
 Summary: The fast, Pythonic way to build MCP servers.
 Project-URL: Homepage, https://gofastmcp.com
 Project-URL: Repository, https://github.com/jlowin/fastmcp
@@ -24,7 +24,7 @@ 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>=15.0.1
+Requires-Dist: websockets>=14.0
 Description-Content-Type: text/markdown
 
 <div align="center">

{fastmcp-2.2.5.dist-info → fastmcp-2.2.6.dist-info}/RECORD

@@ -1,4 +1,4 @@
-fastmcp/__init__.py,sha256=2bwhjiyLJisyobp1O9tVYMjriHZAx_f4bIKJYOL-Rpk,399
+fastmcp/__init__.py,sha256=e-wu5UQpgduOauB-H8lzbnxv_H9K90fCJVnc1qgaAhM,413
 fastmcp/exceptions.py,sha256=QKVHbftoZp4YZQ2NxA-t1SjztqspFdX95YTFOAmr5EE,640
 fastmcp/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fastmcp/settings.py,sha256=VCjc-3011pKRYjt2h9rZ68XhVEekbpyLyVUREVBTSrg,1955
@@ -6,11 +6,12 @@ fastmcp/cli/__init__.py,sha256=Ii284TNoG5lxTP40ETMGhHEq3lQZWxu9m9JuU57kUpQ,87
 fastmcp/cli/claude.py,sha256=IAlcZ4qZKBBj09jZUMEx7EANZE_IR3vcu7zOBJmMOuU,4567
 fastmcp/cli/cli.py,sha256=wsFIYTv48_nr0mcW8vjI1l7_thr4cOrRxzo9g-qr2l8,15726
 fastmcp/client/__init__.py,sha256=BXO9NUhntZ5GnUACfaRCzDJ5IzxqFJs8qKG-CRMSco4,490
-fastmcp/client/base.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-fastmcp/client/client.py,sha256=XXpN28epV9N5w-keQSDPBCdLFtZ5EPK2msxuQ6PxTmo,7732
+fastmcp/client/base.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fastmcp/client/client.py,sha256=cGVy066XGBtwl4Bwa_Prx-Vy5NMZHrDH8jxiq1oYuBo,7812
+fastmcp/client/logging.py,sha256=Q8jYcZj4KA15Yiz3RP8tBXj8sd9IxL3VThF_Y0O4Upc,356
 fastmcp/client/roots.py,sha256=IxI_bHwHTmg6c2H-s1av1ZgrRnNDieHtYwdGFbzXT5c,2471
-fastmcp/client/sampling.py,sha256=WdRhIZbWv54rXYI8lWHv0thXmGCloZYPFpwJK9El_sQ,1613
-fastmcp/client/transports.py,sha256=7dJUQemdxj6UHNThizPzSJbHTGiJHlM77vLf4X9g11M,15491
+fastmcp/client/sampling.py,sha256=UlDHxnd6k_HoU8RA3ob0g8-e6haJBc9u27N_v291QoI,1698
+fastmcp/client/transports.py,sha256=FMMniyxnaaHyWeFHXXP_ayOpb4jtCoyjaiqLobgYb_M,16885
 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
@@ -29,10 +30,10 @@ fastmcp/resources/resource_manager.py,sha256=yfQNCEUooZiQ8LNslnAzjQp4Vh-y1YOlFyG
 fastmcp/resources/template.py,sha256=oa85KiuTjh3C7aZvMwmO4fwbTi6IvwlQ3fxizJuv3dk,7261
 fastmcp/resources/types.py,sha256=c1z6BQSosgrlPQ3v67DuXCvDjCJMq9Xl45npEpyk0ik,7710
 fastmcp/server/__init__.py,sha256=pdkghG11VLMZiluQ-4_rl2JK1LMWmV003m9dDRUN8W4,92
-fastmcp/server/context.py,sha256=s1885AZRipKB3VltfaO3VEtMxGefKs8fdZByj-4tbNI,7120
-fastmcp/server/openapi.py,sha256=hFMOVe-bzudxP8SE-CqQhUWlUCVF5inGfMVL28HlqDs,21179
-fastmcp/server/proxy.py,sha256=xOufto2gIfLk2BZfjhpLdZOlKDlJk5Rn6hCP0pzvaCU,10110
-fastmcp/server/server.py,sha256=89RreIOw0siZmc6SlVlYWm6d6cFvjfVPY7mczXCNGFM,33032
+fastmcp/server/context.py,sha256=_eaL_6QtlQC9yDvHYjntmMzG1aNQZSnli5bIIpCLIwc,7403
+fastmcp/server/openapi.py,sha256=bMmBfgNGzkbweM5g_64NpqvJ6cPtzhSWrzgRvUqP3ec,23185
+fastmcp/server/proxy.py,sha256=pOY6XRvU_GDVv6hd3BttG5W5D1bOtjs9u6iygUMHPsw,10158
+fastmcp/server/server.py,sha256=vQDVo7M8JwltqbprsE7Bd_lTxlnXyrc5jQ4C1uQA1lA,33152
 fastmcp/tools/__init__.py,sha256=ocw-SFTtN6vQ8fgnlF8iNAOflRmh79xS1xdO0Bc3QPE,96
 fastmcp/tools/tool.py,sha256=k797XAeXdcUuBfeuvxkEy8xckXi7xSzQVgkzL876rBQ,6755
 fastmcp/tools/tool_manager.py,sha256=hClv7fwj0cQSSwW0i-Swt7xiVqR4T9LVmr1Tp704nW4,3283
@@ -42,8 +43,8 @@ fastmcp/utilities/func_metadata.py,sha256=iYXnx7MILOSL8mUQ6Rtq_6U7qA08OkoEN2APY8
 fastmcp/utilities/logging.py,sha256=zav8pnFxG_fvGJHUV2XpobmT9WVrmv1mlQBSCz-CPx4,1159
 fastmcp/utilities/openapi.py,sha256=PrH3usbTblaVC6jIH1UGiPEfgB2sSCLj33zA5dH7o_s,45193
 fastmcp/utilities/types.py,sha256=m2rPYMzO-ZFvvZ46N-1-Xqyw693K7yq9Z2xR4pVELyk,2091
-fastmcp-2.2.5.dist-info/METADATA,sha256=JKwmnn7QiN_KbNkC3ZyTpTEoUOTIDHPoCZFraw3eMR8,27769
-fastmcp-2.2.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-fastmcp-2.2.5.dist-info/entry_points.txt,sha256=ff8bMtKX1JvXyurMibAacMSKbJEPmac9ffAKU9mLnM8,44
-fastmcp-2.2.5.dist-info/licenses/LICENSE,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
-fastmcp-2.2.5.dist-info/RECORD,,
+fastmcp-2.2.6.dist-info/METADATA,sha256=gjgxlV6gTth_za73JXr1kzU9LgD9ELMoqAMX1vaaUDY,27767
+fastmcp-2.2.6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+fastmcp-2.2.6.dist-info/entry_points.txt,sha256=ff8bMtKX1JvXyurMibAacMSKbJEPmac9ffAKU9mLnM8,44
+fastmcp-2.2.6.dist-info/licenses/LICENSE,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
+fastmcp-2.2.6.dist-info/RECORD,,