fastmcp 2.10.2__py3-none-any.whl → 2.10.4__py3-none-any.whl

fastmcp/server/proxy.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+import warnings
+from collections.abc import Callable
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, cast
 from urllib.parse import quote
@@ -16,12 +18,14 @@ from mcp.types import (
 )
 from pydantic.networks import AnyUrl
 
-from fastmcp.client import Client
+import fastmcp
+from fastmcp.client.client import Client, FastMCP1Server
 from fastmcp.client.elicitation import ElicitResult
 from fastmcp.client.logging import LogMessage
 from fastmcp.client.roots import RootsList
 from fastmcp.client.transports import ClientTransportT
 from fastmcp.exceptions import NotFoundError, ResourceError, ToolError
+from fastmcp.mcp_config import MCPConfig
 from fastmcp.prompts import Prompt, PromptMessage
 from fastmcp.prompts.prompt import PromptArgument
 from fastmcp.prompts.prompt_manager import PromptManager
@@ -33,7 +37,6 @@ from fastmcp.server.server import FastMCP
 from fastmcp.tools.tool import Tool, ToolResult
 from fastmcp.tools.tool_manager import ToolManager
 from fastmcp.utilities.logging import get_logger
-from fastmcp.utilities.mcp_config import MCPConfig
 
 if TYPE_CHECKING:
     from fastmcp.server import Context
@@ -44,9 +47,9 @@ logger = get_logger(__name__)
 class ProxyToolManager(ToolManager):
     """A ToolManager that sources its tools from a remote client in addition to local and mounted tools."""
 
-    def __init__(self, client: Client, **kwargs):
+    def __init__(self, client_factory: Callable[[], Client], **kwargs):
         super().__init__(**kwargs)
-        self.client = client
+        self.client_factory = client_factory
 
     async def get_tools(self) -> dict[str, Tool]:
         """Gets the unfiltered tool inventory including local, mounted, and proxy tools."""
@@ -55,13 +58,12 @@ class ProxyToolManager(ToolManager):
 
         # Then add proxy tools, but don't overwrite existing ones
         try:
-            async with self.client:
-                client_tools = await self.client.list_tools()
+            client = self.client_factory()
+            async with client:
+                client_tools = await client.list_tools()
                 for tool in client_tools:
                     if tool.name not in all_tools:
-                        all_tools[tool.name] = ProxyTool.from_mcp_tool(
-                            self.client, tool
-                        )
+                        all_tools[tool.name] = ProxyTool.from_mcp_tool(client, tool)
         except McpError as e:
             if e.error.code == METHOD_NOT_FOUND:
                 pass  # No tools available from proxy
@@ -82,8 +84,9 @@ class ProxyToolManager(ToolManager):
             return await super().call_tool(key, arguments)
         except NotFoundError:
             # If not found locally, try proxy
-            async with self.client:
-                result = await self.client.call_tool(key, arguments)
+            client = self.client_factory()
+            async with client:
+                result = await client.call_tool(key, arguments)
                 return ToolResult(
                     content=result.content,
                     structured_content=result.structured_content,
@@ -93,9 +96,9 @@ class ProxyToolManager(ToolManager):
 class ProxyResourceManager(ResourceManager):
     """A ResourceManager that sources its resources from a remote client in addition to local and mounted resources."""
 
-    def __init__(self, client: Client, **kwargs):
+    def __init__(self, client_factory: Callable[[], Client], **kwargs):
         super().__init__(**kwargs)
-        self.client = client
+        self.client_factory = client_factory
 
     async def get_resources(self) -> dict[str, Resource]:
         """Gets the unfiltered resource inventory including local, mounted, and proxy resources."""
@@ -104,12 +107,13 @@ class ProxyResourceManager(ResourceManager):
 
         # Then add proxy resources, but don't overwrite existing ones
         try:
-            async with self.client:
-                client_resources = await self.client.list_resources()
+            client = self.client_factory()
+            async with client:
+                client_resources = await client.list_resources()
                 for resource in client_resources:
                     if str(resource.uri) not in all_resources:
                         all_resources[str(resource.uri)] = (
-                            ProxyResource.from_mcp_resource(self.client, resource)
+                            ProxyResource.from_mcp_resource(client, resource)
                         )
         except McpError as e:
             if e.error.code == METHOD_NOT_FOUND:
@@ -126,12 +130,13 @@ class ProxyResourceManager(ResourceManager):
 
         # Then add proxy templates, but don't overwrite existing ones
         try:
-            async with self.client:
-                client_templates = await self.client.list_resource_templates()
+            client = self.client_factory()
+            async with client:
+                client_templates = await client.list_resource_templates()
                 for template in client_templates:
                     if template.uriTemplate not in all_templates:
                         all_templates[template.uriTemplate] = (
-                            ProxyTemplate.from_mcp_template(self.client, template)
+                            ProxyTemplate.from_mcp_template(client, template)
                         )
         except McpError as e:
             if e.error.code == METHOD_NOT_FOUND:
@@ -158,8 +163,9 @@ class ProxyResourceManager(ResourceManager):
             return await super().read_resource(uri)
         except NotFoundError:
             # If not found locally, try proxy
-            async with self.client:
-                result = await self.client.read_resource(uri)
+            client = self.client_factory()
+            async with client:
+                result = await client.read_resource(uri)
                 if isinstance(result[0], TextResourceContents):
                     return result[0].text
                 elif isinstance(result[0], BlobResourceContents):
@@ -171,9 +177,9 @@ class ProxyResourceManager(ResourceManager):
 class ProxyPromptManager(PromptManager):
     """A PromptManager that sources its prompts from a remote client in addition to local and mounted prompts."""
 
-    def __init__(self, client: Client, **kwargs):
+    def __init__(self, client_factory: Callable[[], Client], **kwargs):
         super().__init__(**kwargs)
-        self.client = client
+        self.client_factory = client_factory
 
     async def get_prompts(self) -> dict[str, Prompt]:
         """Gets the unfiltered prompt inventory including local, mounted, and proxy prompts."""
@@ -182,12 +188,13 @@ class ProxyPromptManager(PromptManager):
 
         # Then add proxy prompts, but don't overwrite existing ones
         try:
-            async with self.client:
-                client_prompts = await self.client.list_prompts()
+            client = self.client_factory()
+            async with client:
+                client_prompts = await client.list_prompts()
                 for prompt in client_prompts:
                     if prompt.name not in all_prompts:
                         all_prompts[prompt.name] = ProxyPrompt.from_mcp_prompt(
-                            self.client, prompt
+                            client, prompt
                         )
         except McpError as e:
             if e.error.code == METHOD_NOT_FOUND:
@@ -213,8 +220,9 @@ class ProxyPromptManager(PromptManager):
             return await super().render_prompt(name, arguments)
         except NotFoundError:
             # If not found locally, try proxy
-            async with self.client:
-                result = await self.client.get_prompt(name, arguments)
+            client = self.client_factory()
+            async with client:
+                result = await client.get_prompt(name, arguments)
                 return result
 
 
@@ -245,7 +253,6 @@ class ProxyTool(Tool):
         context: Context | None = None,
     ) -> ToolResult:
         """Executes the tool by making a call through the client."""
-        # This is where the remote execution logic lives.
         async with self._client:
             result = await self._client.call_tool_mcp(
                 name=self.name,
@@ -267,14 +274,22 @@ class ProxyResource(Resource):
     _client: Client
     _value: str | bytes | None = None
 
-    def __init__(self, client: Client, *, _value: str | bytes | None = None, **kwargs):
+    def __init__(
+        self,
+        client: Client,
+        *,
+        _value: str | bytes | None = None,
+        **kwargs,
+    ):
         super().__init__(**kwargs)
         self._client = client
         self._value = _value
 
     @classmethod
     def from_mcp_resource(
-        cls, client: Client, mcp_resource: mcp.types.Resource
+        cls,
+        client: Client,
+        mcp_resource: mcp.types.Resource,
     ) -> ProxyResource:
         """Factory method to create a ProxyResource from a raw MCP resource schema."""
         return cls(
@@ -397,24 +412,63 @@ class ProxyPrompt(Prompt):
 class FastMCPProxy(FastMCP):
     """
     A FastMCP server that acts as a proxy to a remote MCP-compliant server.
-    It uses specialized managers that fulfill requests via an HTTP client.
+    It uses specialized managers that fulfill requests via a client factory.
     """
 
-    def __init__(self, client: Client, **kwargs):
+    def __init__(
+        self,
+        client: Client | None = None,
+        *,
+        client_factory: Callable[[], Client] | None = None,
+        **kwargs,
+    ):
         """
         Initializes the proxy server.
 
+        FastMCPProxy requires explicit session management via client_factory.
+        Use FastMCP.as_proxy() for convenience with automatic session strategy.
+
         Args:
-            client: The FastMCP client connected to the backend server.
+            client: [DEPRECATED] A Client instance. Use client_factory instead for explicit
+                   session management. When provided, a client_factory will be automatically
+                   created that provides session isolation for backwards compatibility.
+            client_factory: A callable that returns a Client instance when called.
+                           This gives you full control over session creation and reuse.
             **kwargs: Additional settings for the FastMCP server.
         """
+
         super().__init__(**kwargs)
-        self.client = client
+
+        # Handle client and client_factory parameters
+        if client is not None and client_factory is not None:
+            raise ValueError("Cannot specify both 'client' and 'client_factory'")
+
+        if client is not None:
+            # Deprecated in 2.10.3
+            if fastmcp.settings.deprecation_warnings:
+                warnings.warn(
+                    "Passing 'client' to FastMCPProxy is deprecated. Use 'client_factory' instead for explicit session management. "
+                    "For automatic session strategy, use FastMCP.as_proxy().",
+                    DeprecationWarning,
+                    stacklevel=2,
+                )
+
+            # Create a factory that provides session isolation for backwards compatibility
+            def deprecated_client_factory():
+                return client.new()
+
+            self.client_factory = deprecated_client_factory
+        elif client_factory is not None:
+            self.client_factory = client_factory
+        else:
+            raise ValueError("Must specify 'client_factory'")
 
         # Replace the default managers with our specialized proxy managers.
-        self._tool_manager = ProxyToolManager(client=self.client)
-        self._resource_manager = ProxyResourceManager(client=self.client)
-        self._prompt_manager = ProxyPromptManager(client=self.client)
+        self._tool_manager = ProxyToolManager(client_factory=self.client_factory)
+        self._resource_manager = ProxyResourceManager(
+            client_factory=self.client_factory
+        )
+        self._prompt_manager = ProxyPromptManager(client_factory=self.client_factory)
 
 
 async def default_proxy_roots_handler(
@@ -435,15 +489,14 @@ class ProxyClient(Client[ClientTransportT]):
 
     def __init__(
         self,
-        transport: (
-            ClientTransportT
-            | FastMCP
-            | AnyUrl
-            | Path
-            | MCPConfig
-            | dict[str, Any]
-            | str
-        ),
+        transport: ClientTransportT
+        | FastMCP
+        | FastMCP1Server
+        | AnyUrl
+        | Path
+        | MCPConfig
+        | dict[str, Any]
+        | str,
         **kwargs,
     ):
         if "roots" not in kwargs:
@@ -456,7 +509,7 @@ class ProxyClient(Client[ClientTransportT]):
             kwargs["log_handler"] = ProxyClient.default_log_handler
         if "progress_handler" not in kwargs:
             kwargs["progress_handler"] = ProxyClient.default_progress_handler
-        super().__init__(transport, **kwargs)
+        super().__init__(**kwargs | dict(transport=transport))
 
     @classmethod
     async def default_sampling_handler(

fastmcp/server/server.py

@@ -43,6 +43,7 @@ from starlette.routing import BaseRoute, Route
 import fastmcp
 import fastmcp.server
 from fastmcp.exceptions import DisabledError, NotFoundError
+from fastmcp.mcp_config import MCPConfig
 from fastmcp.prompts import Prompt, PromptManager
 from fastmcp.prompts.prompt import FunctionPrompt
 from fastmcp.resources import Resource, ResourceManager
@@ -63,7 +64,6 @@ from fastmcp.utilities.cache import TimedCache
 from fastmcp.utilities.cli import log_server_banner
 from fastmcp.utilities.components import FastMCPComponent
 from fastmcp.utilities.logging import get_logger
-from fastmcp.utilities.mcp_config import MCPConfig
 from fastmcp.utilities.types import NotSet, NotSetT
 
 if TYPE_CHECKING:
@@ -1931,10 +1931,39 @@ class FastMCP(Generic[LifespanResultT]):
 
         if isinstance(backend, Client):
             client = backend
+            # Session strategy based on client connection state:
+            # - Connected clients: reuse existing session for all requests
+            # - Disconnected clients: create fresh sessions per request for isolation
+            if client.is_connected():
+                from fastmcp.utilities.logging import get_logger
+
+                logger = get_logger(__name__)
+                logger.info(
+                    "Proxy detected connected client - reusing existing session for all requests. "
+                    "This may cause context mixing in concurrent scenarios."
+                )
+
+                # Reuse sessions - return the same client instance
+                def reuse_client_factory():
+                    return client
+
+                client_factory = reuse_client_factory
+            else:
+                # Fresh sessions per request
+                def fresh_client_factory():
+                    return client.new()
+
+                client_factory = fresh_client_factory
         else:
-            client = ProxyClient(backend)
+            base_client = ProxyClient(backend)
+
+            # Fresh client created from transport - use fresh sessions per request
+            def proxy_client_factory():
+                return base_client.new()
+
+            client_factory = proxy_client_factory
 
-        return FastMCPProxy(client=client, **settings)
+        return FastMCPProxy(client_factory=client_factory, **settings)
 
     @classmethod
     def from_client(

fastmcp/tools/tool.py

@@ -46,7 +46,7 @@ class _UnserializableType:
 
 
 def default_serializer(data: Any) -> str:
-    return pydantic_core.to_json(data, fallback=str, indent=2).decode()
+    return pydantic_core.to_json(data, fallback=str).decode()
 
 
 class ToolResult:
@@ -434,6 +434,7 @@ def _convert_to_content(
     _process_as_single_item: bool = False,
 ) -> list[ContentBlock]:
     """Convert a result to a sequence of content objects."""
+
     if result is None:
         return []
 
@@ -467,7 +468,7 @@ def _convert_to_content(
 
         if other_content:
             other_content = _convert_to_content(
-                other_content[0] if len(other_content) == 1 else other_content,
+                other_content,
                 serializer=serializer,
                 _process_as_single_item=True,
             )

fastmcp/tools/tool_transform.py

@@ -9,7 +9,7 @@ from typing import Any, Literal
 from mcp.types import ToolAnnotations
 from pydantic import ConfigDict
 
-from fastmcp.tools.tool import ParsedFunction, Tool, ToolResult
+from fastmcp.tools.tool import ParsedFunction, Tool, ToolResult, _convert_to_content
 from fastmcp.utilities.logging import get_logger
 from fastmcp.utilities.types import NotSet, NotSetT, get_cached_typeadapter
 
@@ -233,7 +233,6 @@ class TransformedTool(Tool):
         Returns:
             ToolResult object containing content and optional structured output.
         """
-        from fastmcp.tools.tool import _convert_to_content
 
         # Fill in missing arguments with schema defaults to ensure
         # ArgTransform defaults take precedence over function defaults
@@ -274,7 +273,6 @@ class TransformedTool(Tool):
             if isinstance(result, ToolResult):
                 if self.output_schema is None:
                     # Check if this is from a custom function that returns ToolResult
-                    import inspect
 
                     return_annotation = inspect.signature(self.fn).return_annotation
                     if return_annotation is ToolResult:
@@ -298,7 +296,6 @@ class TransformedTool(Tool):
                     return result
 
             # Otherwise convert to content and create ToolResult with proper structured content
-            from fastmcp.tools.tool import _convert_to_content
 
             unstructured_result = _convert_to_content(
                 result, serializer=self.serializer
@@ -433,8 +430,6 @@ class TransformedTool(Tool):
                 final_output_schema = parsed_fn.output_schema
                 if final_output_schema is None:
                     # Check if function returns ToolResult - if so, don't fall back to parent
-                    import inspect
-
                     return_annotation = inspect.signature(
                         transform_fn
                     ).return_annotation
@@ -553,6 +548,7 @@ class TransformedTool(Tool):
         """
 
         # Build transformed schema and mapping
+        parent_defs = parent_tool.parameters.get("$defs", {})
         parent_props = parent_tool.parameters.get("properties", {}).copy()
         parent_required = set(parent_tool.parameters.get("required", []))
 
@@ -608,6 +604,9 @@ class TransformedTool(Tool):
             "required": list(new_required),
         }
 
+        if parent_defs:
+            schema["$defs"] = parent_defs
+
         # Create forwarding function that closes over everything it needs
         async def _forward(**kwargs):
             # Validate arguments

fastmcp/utilities/json_schema.py

@@ -67,13 +67,24 @@ def _prune_unused_defs(schema: dict) -> dict:
         walk(value, current_def=def_name)
 
     # Figure out what defs were referenced directly or recursively
-    def def_is_referenced(def_name):
+    def def_is_referenced(def_name, parent_def_names: set[str] | None = None):
         if def_name in root_defs:
             return True
         references = referenced_by.get(def_name)
         if references:
-            for reference in references:
-                if def_is_referenced(reference):
+            if parent_def_names is None:
+                parent_def_names = set()
+
+            # Handle recursion by excluding references already present in parent references
+            parent_def_names = parent_def_names | {def_name}
+            valid_references = [
+                reference
+                for reference in references
+                if reference not in parent_def_names
+            ]
+
+            for reference in valid_references:
+                if def_is_referenced(reference, parent_def_names):
                     return True
         return False
 

fastmcp/utilities/openapi.py

@@ -152,6 +152,7 @@ __all__ = [
     "ParameterLocation",
     "JsonSchema",
     "parse_openapi_to_http_routes",
+    "extract_output_schema_from_responses",
 ]
 
 # Type variables for generic parser
@@ -1107,3 +1108,94 @@ def _combine_schemas(route: HTTPRoute) -> dict[str, Any]:
     result = compress_schema(result)
 
     return result
+
+
+def extract_output_schema_from_responses(
+    responses: dict[str, ResponseInfo], schema_definitions: dict[str, Any] | None = None
+) -> dict[str, Any] | None:
+    """
+    Extract output schema from OpenAPI responses for use as MCP tool output schema.
+
+    This function finds the first successful response (200, 201, 202, 204) with a
+    JSON-compatible content type and extracts its schema. If the schema is not an
+    object type, it wraps it to comply with MCP requirements.
+
+    Args:
+        responses: Dictionary of ResponseInfo objects keyed by status code
+        schema_definitions: Optional schema definitions to include in the output schema
+
+    Returns:
+        dict: MCP-compliant output schema with potential wrapping, or None if no suitable schema found
+    """
+    if not responses:
+        return None
+
+    # Priority order for success status codes
+    success_codes = ["200", "201", "202", "204"]
+
+    # Find the first successful response
+    response_info = None
+    for status_code in success_codes:
+        if status_code in responses:
+            response_info = responses[status_code]
+            break
+
+    # If no explicit success codes, try any 2xx response
+    if response_info is None:
+        for status_code, resp_info in responses.items():
+            if status_code.startswith("2"):
+                response_info = resp_info
+                break
+
+    if response_info is None or not response_info.content_schema:
+        return None
+
+    # Prefer application/json, then fall back to other JSON-compatible types
+    json_compatible_types = [
+        "application/json",
+        "application/vnd.api+json",
+        "application/hal+json",
+        "application/ld+json",
+        "text/json",
+    ]
+
+    schema = None
+    for content_type in json_compatible_types:
+        if content_type in response_info.content_schema:
+            schema = response_info.content_schema[content_type]
+            break
+
+    # If no JSON-compatible type found, try the first available content type
+    if schema is None and response_info.content_schema:
+        first_content_type = next(iter(response_info.content_schema))
+        schema = response_info.content_schema[first_content_type]
+        logger.debug(
+            f"Using non-JSON content type for output schema: {first_content_type}"
+        )
+
+    if not schema or not isinstance(schema, dict):
+        return None
+
+    # Clean and copy the schema
+    output_schema = schema.copy()
+
+    # MCP requires output schemas to be objects. If this schema is not an object,
+    # we need to wrap it similar to how ParsedFunction.from_function() does it
+    if output_schema.get("type") != "object":
+        # Create a wrapped schema that contains the original schema under a "result" key
+        wrapped_schema = {
+            "type": "object",
+            "properties": {"result": output_schema},
+            "required": ["result"],
+            "x-fastmcp-wrap-result": True,
+        }
+        output_schema = wrapped_schema
+
+    # Add schema definitions if available
+    if schema_definitions:
+        output_schema["$defs"] = schema_definitions
+
+    # Use compress_schema to remove unused definitions
+    output_schema = compress_schema(output_schema)
+
+    return output_schema

{fastmcp-2.10.2.dist-info → fastmcp-2.10.4.dist-info}/METADATA

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: fastmcp
-Version: 2.10.2
-Summary: The fast, Pythonic way to build MCP servers.
+Version: 2.10.4
+Summary: The fast, Pythonic way to build MCP servers and clients.
 Project-URL: Homepage, https://gofastmcp.com
 Project-URL: Repository, https://github.com/jlowin/fastmcp
 Project-URL: Documentation, https://gofastmcp.com
@@ -18,14 +18,15 @@ Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Classifier: Typing :: Typed
 Requires-Python: >=3.10
 Requires-Dist: authlib>=1.5.2
+Requires-Dist: cyclopts>=3.0.0
 Requires-Dist: exceptiongroup>=1.2.2
 Requires-Dist: httpx>=0.28.1
 Requires-Dist: mcp>=1.10.0
 Requires-Dist: openapi-pydantic>=0.5.1
 Requires-Dist: pydantic[email]>=2.11.7
+Requires-Dist: pyperclip>=1.9.0
 Requires-Dist: python-dotenv>=1.1.0
 Requires-Dist: rich>=13.9.4
-Requires-Dist: typer>=0.15.2
 Provides-Extra: websockets
 Requires-Dist: websockets>=15.0.1; extra == 'websockets'
 Description-Content-Type: text/markdown