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

fastmcp/settings.py

@@ -29,6 +29,17 @@ class Settings(BaseSettings):
 
     test_mode: bool = False
     log_level: LOG_LEVEL = "INFO"
+    enable_rich_tracebacks: Annotated[
+        bool,
+        Field(
+            description=inspect.cleandoc(
+                """
+                If True, will use rich tracebacks for logging.
+                """
+            )
+        ),
+    ] = True
+
     client_raise_first_exceptiongroup_error: Annotated[
         bool,
         Field(
@@ -44,6 +55,21 @@ class Settings(BaseSettings):
             ),
         ),
     ] = True
+
+    resource_prefix_format: Annotated[
+        Literal["protocol", "path"],
+        Field(
+            default="path",
+            description=inspect.cleandoc(
+                """
+                When perfixing a resource URI, either use path formatting (resource://prefix/path)
+                or protocol formatting (prefix+resource://path). Protocol formatting was the default in FastMCP < 2.4;
+                path formatting is current default.
+                """
+            ),
+        ),
+    ] = "path"
+
     tool_attempt_parse_json_args: Annotated[
         bool,
         Field(
@@ -66,7 +92,9 @@ class Settings(BaseSettings):
         """Finalize the settings."""
         from fastmcp.utilities.logging import configure_logging
 
-        configure_logging(self.log_level)
+        configure_logging(
+            self.log_level, enable_rich_tracebacks=self.enable_rich_tracebacks
+        )
 
         return self
 
@@ -108,6 +136,23 @@ class ServerSettings(BaseSettings):
     # prompt settings
     on_duplicate_prompts: DuplicateBehavior = "warn"
 
+    # error handling
+    mask_error_details: Annotated[
+        bool,
+        Field(
+            default=False,
+            description=inspect.cleandoc(
+                """
+                If True, error details from user-supplied functions (tool, resource, prompt)
+                will be masked before being sent to clients. Only error messages from explicitly
+                raised ToolError, ResourceError, or PromptError will be included in responses.
+                If False (default), all error details will be included in responses, but prefixed
+                with appropriate context.
+                """
+            ),
+        ),
+    ] = False
+
     dependencies: Annotated[
         list[str],
         Field(

fastmcp/tools/tool.py

@@ -69,13 +69,17 @@ class Tool(BaseModel):
             if param.kind == inspect.Parameter.VAR_KEYWORD:
                 raise ValueError("Functions with **kwargs are not supported as tools")
 
-        func_name = name or fn.__name__
+        func_name = name or getattr(fn, "__name__", None) or fn.__class__.__name__
 
         if func_name == "<lambda>":
             raise ValueError("You must provide a name for lambda functions")
 
         func_doc = description or fn.__doc__ or ""
 
+        # 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__
+
         type_adapter = get_cached_typeadapter(fn)
         schema = type_adapter.json_schema()
 

fastmcp/tools/tool_manager.py

@@ -23,9 +23,11 @@ class ToolManager:
         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
         if duplicate_behavior is None:
@@ -124,7 +126,12 @@ class ToolManager:
             logger.exception(f"Error calling tool {key!r}: {e}")
             raise e
 
-        # raise other exceptions as ToolErrors without revealing internal details
+        # Handle other exceptions
         except Exception as e:
             logger.exception(f"Error calling tool {key!r}: {e}")
-            raise ToolError(f"Error calling tool {key!r}") from e
+            if self.mask_error_details:
+                # Mask internal details
+                raise ToolError(f"Error calling tool {key!r}") from e
+            else:
+                # Include original error details
+                raise ToolError(f"Error calling tool {key!r}: {e}") from e

fastmcp/utilities/logging.py

@@ -22,6 +22,7 @@ def get_logger(name: str) -> logging.Logger:
 def configure_logging(
     level: Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"] | int = "INFO",
     logger: logging.Logger | None = None,
+    enable_rich_tracebacks: bool = True,
 ) -> None:
     """
     Configure logging for FastMCP.
@@ -30,11 +31,15 @@ def configure_logging(
         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)
+    handler = RichHandler(
+        console=Console(stderr=True),
+        rich_tracebacks=enable_rich_tracebacks,
+    )
     formatter = logging.Formatter("%(message)s")
     handler.setFormatter(formatter)
 

fastmcp/utilities/mcp_config.py

@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Literal
+from urllib.parse import urlparse
+
+from pydantic import AnyUrl, BaseModel, Field
+
+if TYPE_CHECKING:
+    from fastmcp.client.transports import (
+        SSETransport,
+        StdioTransport,
+        StreamableHttpTransport,
+    )
+
+
+def infer_transport_type_from_url(
+    url: str | AnyUrl,
+) -> Literal["streamable-http", "sse"]:
+    """
+    Infer the appropriate transport type from the given URL.
+    """
+    url = str(url)
+    if not url.startswith("http"):
+        raise ValueError(f"Invalid URL: {url}")
+
+    parsed_url = urlparse(url)
+    path = parsed_url.path
+
+    if "/sse/" in path or path.rstrip("/").endswith("/sse"):
+        return "sse"
+    else:
+        return "streamable-http"
+
+
+class StdioMCPServer(BaseModel):
+    command: str
+    args: list[str] = Field(default_factory=list)
+    env: dict[str, Any] = Field(default_factory=dict)
+    cwd: str | None = None
+    transport: Literal["stdio"] = "stdio"
+
+    def to_transport(self) -> StdioTransport:
+        from fastmcp.client.transports import StdioTransport
+
+        return StdioTransport(
+            command=self.command,
+            args=self.args,
+            env=self.env,
+            cwd=self.cwd,
+        )
+
+
+class RemoteMCPServer(BaseModel):
+    url: str
+    headers: dict[str, str] = Field(default_factory=dict)
+    transport: Literal["streamable-http", "sse", "http"] | None = None
+
+    def to_transport(self) -> StreamableHttpTransport | SSETransport:
+        from fastmcp.client.transports import SSETransport, StreamableHttpTransport
+
+        if self.transport is None:
+            transport = infer_transport_type_from_url(self.url)
+        else:
+            transport = self.transport
+
+        if transport == "sse":
+            return SSETransport(self.url, headers=self.headers)
+        else:
+            return StreamableHttpTransport(self.url, headers=self.headers)
+
+
+class MCPConfig(BaseModel):
+    mcpServers: dict[str, StdioMCPServer | RemoteMCPServer]
+
+    @classmethod
+    def from_dict(cls, config: dict[str, Any]) -> MCPConfig:
+        return cls(mcpServers=config.get("mcpServers", config))