fastmcp 2.13.0rc2__py3-none-any.whl → 2.13.0.1__py3-none-any.whl

fastmcp/__init__.py

@@ -48,9 +48,9 @@ def __getattr__(name: str):
 
 
 __all__ = [
-    "FastMCP",
+    "Client",
     "Context",
+    "FastMCP",
     "client",
-    "Client",
     "settings",
 ]

fastmcp/cli/cli.py

@@ -78,7 +78,7 @@ def with_argv(args: list[str] | None):
         original = sys.argv[:]
         try:
             # Preserve the script name (sys.argv[0]) and replace the rest
-            sys.argv = [sys.argv[0]] + args
+            sys.argv = [sys.argv[0], *args]
             yield
         finally:
             sys.argv = original
@@ -277,7 +277,7 @@ async def dev(
 
         # Run the MCP Inspector command
         process = subprocess.run(
-            [npx_cmd, inspector_cmd] + uv_cmd,
+            [npx_cmd, inspector_cmd, *uv_cmd],
             check=True,
             env=env,
         )
@@ -772,6 +772,7 @@ async def inspect(
                 "server_spec": server_spec,
                 "error": str(e),
             },
+            exc_info=True,
         )
         console.print(f"[bold red]✗[/bold red] Failed to inspect server: {e}")
         sys.exit(1)

fastmcp/cli/install/claude_code.py

@@ -125,15 +125,15 @@ def install_claude_code(
     full_command = env_config.build_command(["fastmcp", "run", server_spec])
 
     # Build claude mcp add command
-    cmd_parts = [claude_cmd, "mcp", "add"]
+    cmd_parts = [claude_cmd, "mcp", "add", name]
 
-    # Add environment variables if specified (before the name and command)
+    # Add environment variables if specified
     if env_vars:
         for key, value in env_vars.items():
             cmd_parts.extend(["-e", f"{key}={value}"])
 
     # Add server name and command
-    cmd_parts.extend([name, "--"])
+    cmd_parts.append("--")
     cmd_parts.extend(full_command)
 
     try:

fastmcp/client/__init__.py

@@ -15,18 +15,18 @@ from .transports import (
 from .auth import OAuth, BearerAuth
 
 __all__ = [
+    "BearerAuth",
     "Client",
     "ClientTransport",
-    "WSTransport",
-    "SSETransport",
-    "StdioTransport",
-    "PythonStdioTransport",
+    "FastMCPTransport",
     "NodeStdioTransport",
-    "UvxStdioTransport",
-    "UvStdioTransport",
     "NpxStdioTransport",
-    "FastMCPTransport",
-    "StreamableHttpTransport",
     "OAuth",
-    "BearerAuth",
+    "PythonStdioTransport",
+    "SSETransport",
+    "StdioTransport",
+    "StreamableHttpTransport",
+    "UvStdioTransport",
+    "UvxStdioTransport",
+    "WSTransport",
 ]

fastmcp/client/auth/oauth.py

@@ -36,8 +36,6 @@ logger = get_logger(__name__)
 class ClientNotFoundError(Exception):
     """Raised when OAuth client credentials are not found on the server."""
 
-    pass
-
 
 async def check_if_auth_required(
     mcp_url: str, httpx_kwargs: dict[str, Any] | None = None
@@ -58,7 +56,7 @@ async def check_if_auth_required(
                 return True
 
             # Check for WWW-Authenticate header
-            if "WWW-Authenticate" in response.headers:
+            if "WWW-Authenticate" in response.headers:  # noqa: SIM103
                 return True
 
             # If we get a successful response, auth may not be required
@@ -195,7 +193,8 @@ class OAuth(OAuthClientProvider):
 
             warn(
                 message="Using in-memory token storage is not recommended for production use -- "
-                + "tokens will be lost on server restart."
+                + "tokens will be lost on server restart.",
+                stacklevel=2,
             )
 
         self.token_storage_adapter: TokenStorageAdapter = TokenStorageAdapter(
@@ -272,8 +271,10 @@ class OAuth(OAuthClientProvider):
                     if result.error:
                         raise result.error
                     return result.code, result.state  # type: ignore
-            except TimeoutError:
-                raise TimeoutError(f"OAuth callback timed out after {TIMEOUT} seconds")
+            except TimeoutError as e:
+                raise TimeoutError(
+                    f"OAuth callback timed out after {TIMEOUT} seconds"
+                ) from e
             finally:
                 server.should_exit = True
                 await anyio.sleep(0.1)  # Allow server to shut down gracefully

fastmcp/client/client.py

@@ -61,15 +61,15 @@ from .transports import (
 
 __all__ = [
     "Client",
-    "SessionKwargs",
-    "RootsHandler",
-    "RootsList",
-    "LogHandler",
-    "MessageHandler",
     "ClientSamplingHandler",
-    "SamplingHandler",
     "ElicitationHandler",
+    "LogHandler",
+    "MessageHandler",
     "ProgressHandler",
+    "RootsHandler",
+    "RootsList",
+    "SamplingHandler",
+    "SessionKwargs",
 ]
 
 logger = get_logger(__name__)
@@ -362,10 +362,10 @@ class Client(Generic[ClientTransportT]):
                             await self._session_state.session.initialize()
                         )
                     yield
-                except anyio.ClosedResourceError:
-                    raise RuntimeError("Server session was closed unexpectedly")
-                except TimeoutError:
-                    raise RuntimeError("Failed to initialize server session")
+                except anyio.ClosedResourceError as e:
+                    raise RuntimeError("Server session was closed unexpectedly") from e
+                except TimeoutError as e:
+                    raise RuntimeError("Failed to initialize server session") from e
                 finally:
                     self._session_state.session = None
                     self._session_state.initialize_result = None

fastmcp/client/oauth_callback.py

@@ -46,9 +46,13 @@ def create_callback_html(
     # Add detail info box for both success and error cases
     detail_info = ""
     if is_success and server_url:
-        detail_info = create_info_box(f"Connected to: {server_url}", centered=True)
+        detail_info = create_info_box(
+            f"Connected to: {server_url}", centered=True, monospace=True
+        )
     elif not is_success:
-        detail_info = create_info_box(message, is_error=True, centered=True)
+        detail_info = create_info_box(
+            message, is_error=True, centered=True, monospace=True
+        )
 
     # Build the page content
     content = f"""

fastmcp/client/sampling.py

@@ -11,7 +11,7 @@ from mcp.types import SamplingMessage
 
 from fastmcp.server.sampling.handler import ServerSamplingHandler
 
-__all__ = ["SamplingMessage", "SamplingParams", "SamplingHandler"]
+__all__ = ["SamplingHandler", "SamplingMessage", "SamplingParams"]
 
 
 ClientSamplingHandler: TypeAlias = Callable[

fastmcp/client/transports.py

@@ -46,16 +46,16 @@ ClientTransportT = TypeVar("ClientTransportT", bound="ClientTransport")
 
 __all__ = [
     "ClientTransport",
-    "SSETransport",
-    "StreamableHttpTransport",
-    "StdioTransport",
-    "PythonStdioTransport",
     "FastMCPStdioTransport",
+    "FastMCPTransport",
     "NodeStdioTransport",
-    "UvxStdioTransport",
-    "UvStdioTransport",
     "NpxStdioTransport",
-    "FastMCPTransport",
+    "PythonStdioTransport",
+    "SSETransport",
+    "StdioTransport",
+    "StreamableHttpTransport",
+    "UvStdioTransport",
+    "UvxStdioTransport",
     "infer_transport",
 ]
 
@@ -109,9 +109,8 @@ class ClientTransport(abc.ABC):
         # Basic representation for subclasses
         return f"<{self.__class__.__name__}>"
 
-    async def close(self):
+    async def close(self):  # noqa: B027
         """Close the transport."""
-        pass
 
     def _set_auth(self, auth: httpx.Auth | Literal["oauth"] | str | None):
         if auth is not None:
@@ -141,10 +140,10 @@ class WSTransport(ClientTransport):
     ) -> AsyncIterator[ClientSession]:
         try:
             from mcp.client.websocket import websocket_client
-        except ImportError:
+        except ImportError as e:
             raise ImportError(
                 "The websocket transport is not available. Please install fastmcp[websockets] or install the websockets package manually."
-            )
+            ) from e
 
         async with websocket_client(self.url) as transport:
             read_stream, write_stream = transport
@@ -207,7 +206,7 @@ class SSETransport(ClientTransport):
         # instead we simply leave the kwarg out if it's not provided
         if self.sse_read_timeout is not None:
             client_kwargs["sse_read_timeout"] = self.sse_read_timeout.total_seconds()
-        if session_kwargs.get("read_timeout_seconds", None) is not None:
+        if session_kwargs.get("read_timeout_seconds") is not None:
             read_timeout_seconds = cast(
                 datetime.timedelta, session_kwargs.get("read_timeout_seconds")
             )
@@ -277,7 +276,7 @@ class StreamableHttpTransport(ClientTransport):
         # instead we simply leave the kwarg out if it's not provided
         if self.sse_read_timeout is not None:
             client_kwargs["sse_read_timeout"] = self.sse_read_timeout
-        if session_kwargs.get("read_timeout_seconds", None) is not None:
+        if session_kwargs.get("read_timeout_seconds") is not None:
             client_kwargs["timeout"] = session_kwargs.get("read_timeout_seconds")
 
         if self.httpx_client_factory is not None:
@@ -451,8 +450,7 @@ async def _stdio_transport_connect_task(
                 if log_file is None:
                     log_file_handle = sys.stderr
                 elif isinstance(log_file, Path):
-                    log_file_handle = open(log_file, "a")
-                    stack.callback(log_file_handle.close)
+                    log_file_handle = stack.enter_context(log_file.open("a"))
                 else:
                     # Must be TextIO - use it directly
                     log_file_handle = log_file
@@ -748,6 +746,7 @@ class UvxStdioTransport(StdioTransport):
         env: dict[str, str] | None = None
         if env_vars:
             env = os.environ.copy()
+            env.update(env_vars)
 
         super().__init__(
             command="uvx",
@@ -851,26 +850,28 @@ class FastMCPTransport(ClientTransport):
             server_read, server_write = server_streams
 
             # Create a cancel scope for the server task
-            async with anyio.create_task_group() as tg:
-                async with _enter_server_lifespan(server=self.server):
-                    tg.start_soon(
-                        lambda: self.server._mcp_server.run(
-                            server_read,
-                            server_write,
-                            self.server._mcp_server.create_initialization_options(),
-                            raise_exceptions=self.raise_exceptions,
-                        )
+            async with (
+                anyio.create_task_group() as tg,
+                _enter_server_lifespan(server=self.server),
+            ):
+                tg.start_soon(
+                    lambda: self.server._mcp_server.run(
+                        server_read,
+                        server_write,
+                        self.server._mcp_server.create_initialization_options(),
+                        raise_exceptions=self.raise_exceptions,
                     )
+                )
 
-                    try:
-                        async with ClientSession(
-                            read_stream=client_read,
-                            write_stream=client_write,
-                            **session_kwargs,
-                        ) as client_session:
-                            yield client_session
-                    finally:
-                        tg.cancel_scope.cancel()
+                try:
+                    async with ClientSession(
+                        read_stream=client_read,
+                        write_stream=client_write,
+                        **session_kwargs,
+                    ) as client_session:
+                        yield client_session
+                finally:
+                    tg.cancel_scope.cancel()
 
     def __repr__(self) -> str:
         return f"<FastMCPTransport(server='{self.server.name}')>"
@@ -951,7 +952,7 @@ class MCPConfigTransport(ClientTransport):
 
         # if there's exactly one server, create a client for that server
         elif len(self.config.mcpServers) == 1:
-            self.transport = list(self.config.mcpServers.values())[0].to_transport()
+            self.transport = next(iter(self.config.mcpServers.values())).to_transport()
             self._underlying_transports.append(self.transport)
 
         # otherwise create a composite client

fastmcp/contrib/component_manager/__init__.py

@@ -1,4 +1,4 @@
 from .component_manager import set_up_component_manager
 from .component_service import ComponentService
 
-__all__ = ["set_up_component_manager", "ComponentService"]
+__all__ = ["ComponentService", "set_up_component_manager"]

fastmcp/contrib/component_manager/component_manager.py

@@ -97,11 +97,11 @@ def make_endpoint(action, component, config):
             return JSONResponse(
                 {"message": f"{action.capitalize()}d {component}: {name}"}
             )
-        except NotFoundError:
+        except NotFoundError as e:
             raise StarletteHTTPException(
                 status_code=404,
                 detail=f"Unknown {component}: {name}",
-            )
+            ) from e
 
     return endpoint
 

fastmcp/contrib/mcp_mixin/__init__.py

@@ -2,7 +2,7 @@ from .mcp_mixin import MCPMixin, mcp_tool, mcp_resource, mcp_prompt
 
 __all__ = [
     "MCPMixin",
-    "mcp_tool",
-    "mcp_resource",
     "mcp_prompt",
+    "mcp_resource",
+    "mcp_tool",
 ]

fastmcp/experimental/sampling/handlers/openai.py

@@ -21,10 +21,10 @@ try:
         ChatCompletionUserMessageParam,
     )
     from openai.types.shared.chat_model import ChatModel
-except ImportError:
+except ImportError as e:
     raise ImportError(
         "The `openai` package is not installed. Please install `fastmcp[openai]` or add `openai` to your dependencies manually."
-    )
+    ) from e
 
 from typing_extensions import override
 

fastmcp/experimental/server/openapi/__init__.py

@@ -22,17 +22,14 @@ from .components import (
 
 # Export public symbols - maintaining backward compatibility
 __all__ = [
-    # Server
+    "DEFAULT_ROUTE_MAPPINGS",
+    "ComponentFn",
     "FastMCPOpenAPI",
-    # Routing
     "MCPType",
+    "OpenAPIResource",
+    "OpenAPIResourceTemplate",
+    "OpenAPITool",
     "RouteMap",
     "RouteMapFn",
-    "ComponentFn",
-    "DEFAULT_ROUTE_MAPPINGS",
     "_determine_route_type",
-    # Components
-    "OpenAPITool",
-    "OpenAPIResource",
-    "OpenAPIResourceTemplate",
 ]

fastmcp/experimental/server/openapi/components.py

@@ -146,11 +146,11 @@ class OpenAPITool(Tool):
                 if e.response.text:
                     error_message += f" - {e.response.text}"
 
-            raise ValueError(error_message)
+            raise ValueError(error_message) from e
 
         except httpx.RequestError as e:
             # Handle request errors (connection, timeout, etc.)
-            raise ValueError(f"Request error: {str(e)}")
+            raise ValueError(f"Request error: {e!s}") from e
 
 
 class OpenAPIResource(Resource):
@@ -165,9 +165,11 @@ class OpenAPIResource(Resource):
         name: str,
         description: str,
         mime_type: str = "application/json",
-        tags: set[str] = set(),
+        tags: set[str] | None = None,
         timeout: float | None = None,
     ):
+        if tags is None:
+            tags = set()
         super().__init__(
             uri=AnyUrl(uri),  # Convert string to AnyUrl
             name=name,
@@ -276,11 +278,11 @@ class OpenAPIResource(Resource):
                 if e.response.text:
                     error_message += f" - {e.response.text}"
 
-            raise ValueError(error_message)
+            raise ValueError(error_message) from e
 
         except httpx.RequestError as e:
             # Handle request errors (connection, timeout, etc.)
-            raise ValueError(f"Request error: {str(e)}")
+            raise ValueError(f"Request error: {e!s}") from e
 
 
 class OpenAPIResourceTemplate(ResourceTemplate):
@@ -295,9 +297,11 @@ class OpenAPIResourceTemplate(ResourceTemplate):
         name: str,
         description: str,
         parameters: dict[str, Any],
-        tags: set[str] = set(),
+        tags: set[str] | None = None,
         timeout: float | None = None,
     ):
+        if tags is None:
+            tags = set()
         super().__init__(
             uri_template=uri_template,
             name=name,
@@ -342,7 +346,7 @@ class OpenAPIResourceTemplate(ResourceTemplate):
 
 # Export public symbols
 __all__ = [
-    "OpenAPITool",
     "OpenAPIResource",
     "OpenAPIResourceTemplate",
+    "OpenAPITool",
 ]

fastmcp/experimental/server/openapi/routing.py

@@ -121,10 +121,10 @@ def _determine_route_type(
 
 # Export public symbols
 __all__ = [
+    "DEFAULT_ROUTE_MAPPINGS",
+    "ComponentFn",
     "MCPType",
     "RouteMap",
     "RouteMapFn",
-    "ComponentFn",
-    "DEFAULT_ROUTE_MAPPINGS",
     "_determine_route_type",
 ]

fastmcp/experimental/utilities/openapi/__init__.py

@@ -40,29 +40,24 @@ from .json_schema_converter import (
 
 # Export public symbols - maintaining backward compatibility
 __all__ = [
-    # Models
     "HTTPRoute",
+    "HttpMethod",
+    "JsonSchema",
     "ParameterInfo",
+    "ParameterLocation",
     "RequestBodyInfo",
     "ResponseInfo",
-    "HttpMethod",
-    "ParameterLocation",
-    "JsonSchema",
-    # Parser
-    "parse_openapi_to_http_routes",
-    # Formatters
+    "_combine_schemas",
+    "_make_optional_parameter_nullable",
+    "clean_schema_for_display",
+    "convert_openapi_schema_to_json_schema",
+    "convert_schema_definitions",
+    "extract_output_schema_from_responses",
     "format_array_parameter",
     "format_deep_object_parameter",
     "format_description_with_responses",
     "format_json_for_description",
     "format_simple_description",
     "generate_example_from_schema",
-    # Schemas
-    "_combine_schemas",
-    "extract_output_schema_from_responses",
-    "clean_schema_for_display",
-    "_make_optional_parameter_nullable",
-    # JSON Schema Converter
-    "convert_openapi_schema_to_json_schema",
-    "convert_schema_definitions",
+    "parse_openapi_to_http_routes",
 ]

fastmcp/experimental/utilities/openapi/director.py

@@ -63,7 +63,7 @@ class RequestDirector:
 
         # Step 4: Handle request body
         if body is not None:
-            if isinstance(body, dict) or isinstance(body, list):
+            if isinstance(body, dict | list):
                 request_data["json"] = body
             else:
                 request_data["content"] = body

fastmcp/experimental/utilities/openapi/json_schema_converter.py

@@ -164,10 +164,10 @@ def _convert_nullable_field(schema: dict[str, Any]) -> dict[str, Any]:
         if isinstance(current_type, str):
             result["type"] = [current_type, "null"]
         elif isinstance(current_type, list) and "null" not in current_type:
-            result["type"] = current_type + ["null"]
+            result["type"] = [*current_type, "null"]
     elif "oneOf" in result:
         # Convert oneOf to anyOf with null
-        result["anyOf"] = result.pop("oneOf") + [{"type": "null"}]
+        result["anyOf"] = [*result.pop("oneOf"), {"type": "null"}]
     elif "anyOf" in result:
         # Add null to anyOf if not present
         if not any(item.get("type") == "null" for item in result["anyOf"]):

fastmcp/experimental/utilities/openapi/models.py

@@ -79,10 +79,10 @@ class HTTPRoute(FastMCPBaseModel):
 # Export public symbols
 __all__ = [
     "HTTPRoute",
+    "HttpMethod",
+    "JsonSchema",
     "ParameterInfo",
+    "ParameterLocation",
     "RequestBodyInfo",
     "ResponseInfo",
-    "HttpMethod",
-    "ParameterLocation",
-    "JsonSchema",
 ]

fastmcp/experimental/utilities/openapi/parser.py

@@ -178,7 +178,7 @@ class OpenAPIParser(
                         else:
                             # Special handling for components
                             if part == "components" and hasattr(target, "components"):
-                                target = getattr(target, "components")
+                                target = target.components
                             elif hasattr(target, part):  # Fallback check
                                 target = getattr(target, part, None)
                             else:
@@ -554,9 +554,7 @@ class OpenAPIParser(
                 if "$ref" in obj and isinstance(obj["$ref"], str):
                     ref = obj["$ref"]
                     # Handle both converted and unconverted refs
-                    if ref.startswith("#/$defs/"):
-                        schema_name = ref.split("/")[-1]
-                    elif ref.startswith("#/components/schemas/"):
+                    if ref.startswith(("#/$defs/", "#/components/schemas/")):
                         schema_name = ref.split("/")[-1]
                     else:
                         return
@@ -815,6 +813,6 @@ class OpenAPIParser(
 
 # Export public symbols
 __all__ = [
-    "parse_openapi_to_http_routes",
     "OpenAPIParser",
+    "parse_openapi_to_http_routes",
 ]

fastmcp/experimental/utilities/openapi/schemas.py

@@ -585,9 +585,9 @@ def extract_output_schema_from_responses(
 
 # Export public symbols
 __all__ = [
-    "clean_schema_for_display",
     "_combine_schemas",
     "_combine_schemas_and_map_params",
-    "extract_output_schema_from_responses",
     "_make_optional_parameter_nullable",
+    "clean_schema_for_display",
+    "extract_output_schema_from_responses",
 ]

fastmcp/mcp_config.py

@@ -288,9 +288,8 @@ class MCPConfig(BaseModel):
     @classmethod
     def from_file(cls, file_path: Path) -> Self:
         """Load configuration from JSON file."""
-        if file_path.exists():
-            if content := file_path.read_text().strip():
-                return cls.model_validate_json(content)
+        if file_path.exists() and (content := file_path.read_text().strip()):
+            return cls.model_validate_json(content)
 
         raise ValueError(f"No MCP servers defined in the config: {file_path}")
 

fastmcp/prompts/__init__.py

@@ -2,8 +2,8 @@ from .prompt import Prompt, PromptMessage, Message
 from .prompt_manager import PromptManager
 
 __all__ = [
+    "Message",
     "Prompt",
     "PromptManager",
     "PromptMessage",
-    "Message",
 ]