fastmcp 2.3.3__py3-none-any.whl → 2.3.5__py3-none-any.whl

fastmcp/tools/tool.py

@@ -11,9 +11,8 @@ from mcp.types import Tool as MCPTool
 from pydantic import BaseModel, BeforeValidator, Field
 
 import fastmcp
-from fastmcp.exceptions import ToolError
 from fastmcp.server.dependencies import get_context
-from fastmcp.utilities.json_schema import prune_params
+from fastmcp.utilities.json_schema import compress_schema
 from fastmcp.utilities.logging import get_logger
 from fastmcp.utilities.types import (
     Image,
@@ -82,7 +81,11 @@ class Tool(BaseModel):
 
         context_kwarg = find_kwarg_by_type(fn, kwarg_type=Context)
         if context_kwarg:
-            schema = prune_params(schema, params=[context_kwarg])
+            prune_params = [context_kwarg]
+        else:
+            prune_params = None
+
+        schema = compress_schema(schema, prune_params=prune_params)
 
         return cls(
             fn=fn,
@@ -102,48 +105,45 @@ class Tool(BaseModel):
 
         arguments = arguments.copy()
 
-        try:
-            context_kwarg = find_kwarg_by_type(self.fn, kwarg_type=Context)
-            if context_kwarg and context_kwarg not in arguments:
-                arguments[context_kwarg] = get_context()
-
-            if fastmcp.settings.settings.tool_attempt_parse_json_args:
-                # Pre-parse data from JSON in order to handle cases like `["a", "b", "c"]`
-                # being passed in as JSON inside a string rather than an actual list.
-                #
-                # Claude desktop is prone to this - in fact it seems incapable of NOT doing
-                # this. For sub-models, it tends to pass dicts (JSON objects) as JSON strings,
-                # which can be pre-parsed here.
-                signature = inspect.signature(self.fn)
-                for param_name in self.parameters["properties"]:
-                    arg = arguments.get(param_name, None)
-                    # if not in signature, we won't have annotations, so skip logic
-                    if param_name not in signature.parameters:
-                        continue
-                    # if not a string, we won't have a JSON to parse, so skip logic
-                    if not isinstance(arg, str):
-                        continue
-                    # skip if the type is a simple type (int, float, bool)
-                    if signature.parameters[param_name].annotation in (
-                        int,
-                        float,
-                        bool,
-                    ):
-                        continue
-                    try:
-                        arguments[param_name] = json.loads(arg)
-
-                    except json.JSONDecodeError:
-                        pass
-
-            type_adapter = get_cached_typeadapter(self.fn)
-            result = type_adapter.validate_python(arguments)
-            if inspect.isawaitable(result):
-                result = await result
-
-            return _convert_to_content(result, serializer=self.serializer)
-        except Exception as e:
-            raise ToolError(f"Error executing tool {self.name}: {e}") from e
+        context_kwarg = find_kwarg_by_type(self.fn, kwarg_type=Context)
+        if context_kwarg and context_kwarg not in arguments:
+            arguments[context_kwarg] = get_context()
+
+        if fastmcp.settings.settings.tool_attempt_parse_json_args:
+            # Pre-parse data from JSON in order to handle cases like `["a", "b", "c"]`
+            # being passed in as JSON inside a string rather than an actual list.
+            #
+            # Claude desktop is prone to this - in fact it seems incapable of NOT doing
+            # this. For sub-models, it tends to pass dicts (JSON objects) as JSON strings,
+            # which can be pre-parsed here.
+            signature = inspect.signature(self.fn)
+            for param_name in self.parameters["properties"]:
+                arg = arguments.get(param_name, None)
+                # if not in signature, we won't have annotations, so skip logic
+                if param_name not in signature.parameters:
+                    continue
+                # if not a string, we won't have a JSON to parse, so skip logic
+                if not isinstance(arg, str):
+                    continue
+                # skip if the type is a simple type (int, float, bool)
+                if signature.parameters[param_name].annotation in (
+                    int,
+                    float,
+                    bool,
+                ):
+                    continue
+                try:
+                    arguments[param_name] = json.loads(arg)
+
+                except json.JSONDecodeError:
+                    pass
+
+        type_adapter = get_cached_typeadapter(self.fn)
+        result = type_adapter.validate_python(arguments)
+        if inspect.isawaitable(result):
+            result = await result
+
+        return _convert_to_content(result, serializer=self.serializer)
 
     def to_mcp_tool(self, **overrides: Any) -> MCPTool:
         kwargs = {

fastmcp/tools/tool_manager.py

@@ -5,7 +5,7 @@ from typing import TYPE_CHECKING, Any
 
 from mcp.types import EmbeddedResource, ImageContent, TextContent, ToolAnnotations
 
-from fastmcp.exceptions import NotFoundError
+from fastmcp.exceptions import NotFoundError, ToolError
 from fastmcp.settings import DuplicateBehavior
 from fastmcp.tools.tool import Tool
 from fastmcp.utilities.logging import get_logger
@@ -94,6 +94,20 @@ class ToolManager:
             self._tools[key] = tool
         return tool
 
+    def remove_tool(self, key: str) -> None:
+        """Remove a tool from the server.
+
+        Args:
+            key: The key of the tool to remove
+
+        Raises:
+            NotFoundError: If the tool is not found
+        """
+        if key in self._tools:
+            del self._tools[key]
+        else:
+            raise NotFoundError(f"Unknown tool: {key}")
+
     async def call_tool(
         self, key: str, arguments: dict[str, Any]
     ) -> list[TextContent | ImageContent | EmbeddedResource]:
@@ -102,4 +116,15 @@ class ToolManager:
         if not tool:
             raise NotFoundError(f"Unknown tool: {key}")
 
-        return await tool.run(arguments)
+        try:
+            return await tool.run(arguments)
+
+        # raise ToolErrors as-is
+        except ToolError as e:
+            logger.exception(f"Error calling tool {key!r}: {e}")
+            raise e
+
+        # raise other exceptions as ToolErrors without revealing internal details
+        except Exception as e:
+            logger.exception(f"Error calling tool {key!r}: {e}")
+            raise ToolError(f"Error calling tool {key!r}") from e

fastmcp/utilities/exceptions.py

@@ -0,0 +1,49 @@
+from collections.abc import Callable, Iterable, Mapping
+from typing import Any
+
+import httpx
+import mcp.types
+from exceptiongroup import BaseExceptionGroup
+from mcp import McpError
+
+import fastmcp
+
+
+def iter_exc(group: BaseExceptionGroup):
+    for exc in group.exceptions:
+        if isinstance(exc, BaseExceptionGroup):
+            yield from iter_exc(exc)
+        else:
+            yield exc
+
+
+def _exception_handler(group: BaseExceptionGroup):
+    for leaf in iter_exc(group):
+        if isinstance(leaf, httpx.ConnectTimeout):
+            raise McpError(
+                error=mcp.types.ErrorData(
+                    code=httpx.codes.REQUEST_TIMEOUT,
+                    message="Timed out while waiting for response.",
+                )
+            )
+        raise leaf
+
+
+# this catch handler is used to catch taskgroup exception groups and raise the
+# first exception. This allows more sane debugging.
+_catch_handlers: Mapping[
+    type[BaseException] | Iterable[type[BaseException]],
+    Callable[[BaseExceptionGroup[Any]], Any],
+] = {
+    Exception: _exception_handler,
+}
+
+
+def get_catch_handlers() -> Mapping[
+    type[BaseException] | Iterable[type[BaseException]],
+    Callable[[BaseExceptionGroup[Any]], Any],
+]:
+    if fastmcp.settings.settings.client_raise_first_exceptiongroup_error:
+        return _catch_handlers
+    else:
+        return {}

fastmcp/utilities/json_schema.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import copy
-from collections.abc import Mapping, Sequence
 
 
 def _prune_param(schema: dict, param: str) -> dict:
@@ -14,6 +13,7 @@ def _prune_param(schema: dict, param: str) -> dict:
     removed = props.pop(param, None)
     if removed is None:  # nothing to do
         return schema
+
     # Keep empty properties object rather than removing it entirely
     schema["properties"] = props
     if param in schema.get("required", []):
@@ -21,39 +21,100 @@ def _prune_param(schema: dict, param: str) -> dict:
         if not schema["required"]:
             schema.pop("required")
 
-    # ── 2. collect all remaining local $ref targets ───────────────────
+    return schema
+
+
+def _walk_and_prune(
+    schema: dict,
+    prune_defs: bool = False,
+    prune_titles: bool = False,
+    prune_additional_properties: bool = False,
+) -> dict:
+    """Walk the schema and optionally prune titles, unused definitions, and additionalProperties: false."""
+
+    # Will only be used if prune_defs is True
     used_defs: set[str] = set()
 
-    def walk(node: object) -> None:  # depth-first traversal
-        if isinstance(node, Mapping):
-            ref = node.get("$ref")
-            if isinstance(ref, str) and ref.startswith("#/$defs/"):
-                used_defs.add(ref.split("/")[-1])
+    def walk(node: object) -> None:
+        if isinstance(node, dict):
+            # Process $ref for definition tracking
+            if prune_defs:
+                ref = node.get("$ref")
+                if isinstance(ref, str) and ref.startswith("#/$defs/"):
+                    used_defs.add(ref.split("/")[-1])
+
+            # Remove title if requested
+            if prune_titles and "title" in node:
+                node.pop("title")
+
+            # Remove additionalProperties: false at any level if requested
+            if (
+                prune_additional_properties
+                and node.get("additionalProperties", None) is False
+            ):
+                node.pop("additionalProperties")
+
+            # Walk children
             for v in node.values():
                 walk(v)
-        elif isinstance(node, Sequence) and not isinstance(node, str | bytes):
+
+        elif isinstance(node, list):
             for v in node:
                 walk(v)
 
+    # Traverse the schema once
     walk(schema)
 
-    # ── 3. remove orphaned definitions ────────────────────────────────
-    defs = schema.get("$defs", {})
-    for def_name in list(defs):
-        if def_name not in used_defs:
-            defs.pop(def_name)
-    if not defs:
-        schema.pop("$defs", None)
+    # Remove orphaned definitions if requested
+    if prune_defs:
+        defs = schema.get("$defs", {})
+        for def_name in list(defs):
+            if def_name not in used_defs:
+                defs.pop(def_name)
+        if not defs:
+            schema.pop("$defs", None)
+
+    return schema
+
 
+def _prune_additional_properties(schema: dict) -> dict:
+    """Remove additionalProperties from the schema if it is False."""
+    if schema.get("additionalProperties", None) is False:
+        schema.pop("additionalProperties")
     return schema
 
 
-def prune_params(schema: dict, params: list[str]) -> dict:
+def compress_schema(
+    schema: dict,
+    prune_params: list[str] | None = None,
+    prune_defs: bool = True,
+    prune_additional_properties: bool = True,
+    prune_titles: bool = False,
+) -> dict:
     """
     Remove the given parameters from the schema.
 
+    Args:
+        schema: The schema to compress
+        prune_params: List of parameter names to remove from properties
+        prune_defs: Whether to remove unused definitions
+        prune_additional_properties: Whether to remove additionalProperties: false
+        prune_titles: Whether to remove title fields from the schema
     """
+    # Make a copy so we don't modify the original
     schema = copy.deepcopy(schema)
-    for param in params:
+
+    # Remove specific parameters if requested
+    for param in prune_params or []:
         schema = _prune_param(schema, param=param)
+
+    # Do a single walk to handle pruning operations
+    if prune_defs or prune_titles or prune_additional_properties:
+        schema = _walk_and_prune(
+            schema,
+            prune_defs=prune_defs,
+            prune_titles=prune_titles,
+            prune_additional_properties=prune_additional_properties,
+        )
+
     return schema

fastmcp/utilities/logging.py

@@ -21,22 +21,27 @@ def get_logger(name: str) -> logging.Logger:
 
 def configure_logging(
     level: Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"] | int = "INFO",
+    logger: logging.Logger | None = None,
 ) -> None:
-    """Configure logging for FastMCP.
+    """
+    Configure logging for FastMCP.
 
     Args:
+        logger: the logger to configure
         level: the log level to use
     """
+    if logger is None:
+        logger = logging.getLogger("FastMCP")
+
     # Only configure the FastMCP logger namespace
     handler = RichHandler(console=Console(stderr=True), rich_tracebacks=True)
     formatter = logging.Formatter("%(message)s")
     handler.setFormatter(formatter)
 
-    fastmcp_logger = logging.getLogger("FastMCP")
-    fastmcp_logger.setLevel(level)
+    logger.setLevel(level)
 
     # Remove any existing handlers to avoid duplicates on reconfiguration
-    for hdlr in fastmcp_logger.handlers[:]:
-        fastmcp_logger.removeHandler(hdlr)
+    for hdlr in logger.handlers[:]:
+        logger.removeHandler(hdlr)
 
-    fastmcp_logger.addHandler(handler)
+    logger.addHandler(handler)

fastmcp/utilities/openapi.py

@@ -84,6 +84,9 @@ class HTTPRoute(BaseModel):
     responses: dict[str, ResponseInfo] = Field(
         default_factory=dict
     )  # Key: status code str
+    schema_definitions: dict[str, JsonSchema] = Field(
+        default_factory=dict
+    )  # Store component schemas
 
 
 # Export public symbols
@@ -221,6 +224,27 @@ class OpenAPI31Parser(BaseOpenAPIParser):
             logger.warning("OpenAPI schema has no paths defined.")
             return []
 
+        # Extract component schemas to add to each route
+        schema_definitions = {}
+        if hasattr(self.openapi, "components") and self.openapi.components:
+            components = self.openapi.components
+            if hasattr(components, "schemas") and components.schemas:
+                for name, schema in components.schemas.items():
+                    try:
+                        if isinstance(schema, Reference):
+                            resolved_schema = self._resolve_ref(schema)
+                            schema_definitions[name] = self._extract_schema_as_dict(
+                                resolved_schema
+                            )
+                        else:
+                            schema_definitions[name] = self._extract_schema_as_dict(
+                                schema
+                            )
+                    except Exception as e:
+                        logger.warning(
+                            f"Failed to extract schema definition '{name}': {e}"
+                        )
+
         for path_str, path_item_obj in self.openapi.paths.items():
             if not isinstance(path_item_obj, PathItem):
                 logger.warning(
@@ -269,6 +293,7 @@ class OpenAPI31Parser(BaseOpenAPIParser):
                             parameters=parameters,
                             request_body=request_body_info,
                             responses=responses,
+                            schema_definitions=schema_definitions,
                         )
                         routes.append(route)
                         logger.info(
@@ -386,16 +411,36 @@ class OpenAPI31Parser(BaseOpenAPIParser):
 
                 param_schema_dict = {}
                 if param_schema_obj:  # Check if schema exists
+                    # Resolve the schema if it's a reference
+                    resolved_schema = self._resolve_ref(param_schema_obj)
                     param_schema_dict = self._extract_schema_as_dict(param_schema_obj)
+
+                    # Ensure default value is preserved from resolved schema
+                    if (
+                        not isinstance(resolved_schema, Reference)
+                        and hasattr(resolved_schema, "default")
+                        and resolved_schema.default is not None
+                    ):
+                        param_schema_dict["default"] = resolved_schema.default
                 elif parameter.content:
                     # Handle complex parameters with 'content'
                     first_media_type = next(iter(parameter.content.values()), None)
                     if (
                         first_media_type and first_media_type.media_type_schema
                     ):  # CORRECTED: Use 'media_type_schema'
-                        param_schema_dict = self._extract_schema_as_dict(
-                            first_media_type.media_type_schema
-                        )
+                        # Resolve the schema if it's a reference
+                        media_schema = first_media_type.media_type_schema
+                        resolved_media_schema = self._resolve_ref(media_schema)
+                        param_schema_dict = self._extract_schema_as_dict(media_schema)
+
+                        # Ensure default value is preserved from resolved schema
+                        if (
+                            not isinstance(resolved_media_schema, Reference)
+                            and hasattr(resolved_media_schema, "default")
+                            and resolved_media_schema.default is not None
+                        ):
+                            param_schema_dict["default"] = resolved_media_schema.default
+
                         logger.debug(
                             f"Parameter '{parameter.name}' using schema from 'content' field."
                         )
@@ -543,6 +588,27 @@ class OpenAPI30Parser(BaseOpenAPIParser):
             logger.warning("OpenAPI schema has no paths defined.")
             return []
 
+        # Extract component schemas to add to each route
+        schema_definitions = {}
+        if hasattr(self.openapi, "components") and self.openapi.components:
+            components = self.openapi.components
+            if hasattr(components, "schemas") and components.schemas:
+                for name, schema in components.schemas.items():
+                    try:
+                        if isinstance(schema, Reference_30):
+                            resolved_schema = self._resolve_ref(schema)
+                            schema_definitions[name] = self._extract_schema_as_dict(
+                                resolved_schema
+                            )
+                        else:
+                            schema_definitions[name] = self._extract_schema_as_dict(
+                                schema
+                            )
+                    except Exception as e:
+                        logger.warning(
+                            f"Failed to extract schema definition '{name}': {e}"
+                        )
+
         for path_str, path_item_obj in self.openapi.paths.items():
             if not isinstance(path_item_obj, PathItem_30):
                 logger.warning(
@@ -593,6 +659,7 @@ class OpenAPI30Parser(BaseOpenAPIParser):
                             parameters=parameters,
                             request_body=request_body_info,
                             responses=responses,
+                            schema_definitions=schema_definitions,
                         )
                         routes.append(route)
                         logger.info(
@@ -711,14 +778,34 @@ class OpenAPI30Parser(BaseOpenAPIParser):
 
                 param_schema_dict = {}
                 if param_schema_obj:  # Check if schema exists
+                    # Resolve the schema if it's a reference
+                    resolved_schema = self._resolve_ref(param_schema_obj)
                     param_schema_dict = self._extract_schema_as_dict(param_schema_obj)
+
+                    # Ensure default value is preserved from resolved schema
+                    if (
+                        not isinstance(resolved_schema, Reference_30)
+                        and hasattr(resolved_schema, "default")
+                        and resolved_schema.default is not None
+                    ):
+                        param_schema_dict["default"] = resolved_schema.default
                 elif parameter.content:
                     # Handle complex parameters with 'content'
                     first_media_type = next(iter(parameter.content.values()), None)
                     if first_media_type and first_media_type.media_type_schema:
-                        param_schema_dict = self._extract_schema_as_dict(
-                            first_media_type.media_type_schema
-                        )
+                        # Resolve the schema if it's a reference
+                        media_schema = first_media_type.media_type_schema
+                        resolved_media_schema = self._resolve_ref(media_schema)
+                        param_schema_dict = self._extract_schema_as_dict(media_schema)
+
+                        # Ensure default value is preserved from resolved schema
+                        if (
+                            not isinstance(resolved_media_schema, Reference_30)
+                            and hasattr(resolved_media_schema, "default")
+                            and resolved_media_schema.default is not None
+                        ):
+                            param_schema_dict["default"] = resolved_media_schema.default
+
                         logger.debug(
                             f"Parameter '{parameter.name}' using schema from 'content' field."
                         )
@@ -1173,6 +1260,23 @@ def _combine_schemas(route: openapi.HTTPRoute) -> dict[str, Any]:
         # 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
@@ -1193,8 +1297,19 @@ def _combine_schemas(route: openapi.HTTPRoute) -> dict[str, Any]:
         if route.request_body.required:
             required.extend(body_schema.get("required", []))
 
-    return {
+    result = {
         "type": "object",
         "properties": properties,
         "required": required,
     }
+
+    # Add schema definitions if available
+    if route.schema_definitions:
+        result["$defs"] = route.schema_definitions
+
+    # Use compress_schema to remove unused definitions
+    from fastmcp.utilities.json_schema import compress_schema
+
+    result = compress_schema(result)
+
+    return result

{fastmcp-2.3.3.dist-info → fastmcp-2.3.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastmcp
-Version: 2.3.3
+Version: 2.3.5
 Summary: The fast, Pythonic way to build MCP servers.
 Project-URL: Homepage, https://gofastmcp.com
 Project-URL: Repository, https://github.com/jlowin/fastmcp
@@ -19,7 +19,7 @@ Classifier: Typing :: Typed
 Requires-Python: >=3.10
 Requires-Dist: exceptiongroup>=1.2.2
 Requires-Dist: httpx>=0.28.1
-Requires-Dist: mcp<2.0.0,>=1.8.0
+Requires-Dist: mcp<2.0.0,>=1.9.0
 Requires-Dist: openapi-pydantic>=0.5.1
 Requires-Dist: python-dotenv>=1.1.0
 Requires-Dist: rich>=13.9.4
@@ -290,7 +290,7 @@ FastMCP introduces powerful ways to structure and deploy your MCP applications.
 
 ### Proxy Servers
 
-Create a FastMCP server that acts as an intermediary for another local or remote MCP server using `FastMCP.from_client()`. This is especially useful for bridging transports (e.g., remote SSE to local Stdio) or adding a layer of logic to a server you don't control.
+Create a FastMCP server that acts as an intermediary for another local or remote MCP server using `FastMCP.as_proxy()`. This is especially useful for bridging transports (e.g., remote SSE to local Stdio) or adding a layer of logic to a server you don't control.
 
 Learn more in the [**Proxying Documentation**](https://gofastmcp.com/patterns/proxy).