fastmcp 2.1.2__py3-none-any.whl → 2.2.1__py3-none-any.whl

fastmcp/cli/cli.py

@@ -297,6 +297,29 @@ def run(
             help="Transport protocol to use (stdio or sse)",
         ),
     ] = None,
+    host: Annotated[
+        str | None,
+        typer.Option(
+            "--host",
+            help="Host to bind to when using sse transport (default: 0.0.0.0)",
+        ),
+    ] = None,
+    port: Annotated[
+        int | None,
+        typer.Option(
+            "--port",
+            "-p",
+            help="Port to bind to when using sse transport (default: 8000)",
+        ),
+    ] = None,
+    log_level: Annotated[
+        str | None,
+        typer.Option(
+            "--log-level",
+            "-l",
+            help="Log level for sse transport (DEBUG, INFO, WARNING, ERROR, CRITICAL)",
+        ),
+    ] = None,
 ) -> None:
     """Run a MCP server.
 
@@ -316,6 +339,9 @@ def run(
             "file": str(file),
             "server_object": server_object,
             "transport": transport,
+            "host": host,
+            "port": port,
+            "log_level": log_level,
         },
     )
 
@@ -329,6 +355,12 @@ def run(
         kwargs = {}
         if transport:
             kwargs["transport"] = transport
+        if host:
+            kwargs["host"] = host
+        if port:
+            kwargs["port"] = port
+        if log_level:
+            kwargs["log_level"] = log_level
 
         server.run(**kwargs)
 

fastmcp/client/client.py

@@ -17,6 +17,7 @@ from fastmcp.client.roots import (
     create_roots_callback,
 )
 from fastmcp.client.sampling import SamplingHandler, create_sampling_callback
+from fastmcp.exceptions import ClientError
 from fastmcp.server import FastMCP
 
 from .transports import ClientTransport, SessionKwargs, infer_transport
@@ -24,10 +25,6 @@ from .transports import ClientTransport, SessionKwargs, infer_transport
 __all__ = ["Client", "RootsHandler", "RootsList"]
 
 
-class ClientError(ValueError):
-    """Base class for errors raised by the client."""
-
-
 class Client:
     """
     MCP client that delegates connection management to a Transport instance.
@@ -48,7 +45,7 @@ class Client:
     ):
         self.transport = infer_transport(transport)
         self._session: ClientSession | None = None
-        self._session_cm: AbstractAsyncContextManager[ClientSession] | None = None
+        self._session_cms: list[AbstractAsyncContextManager[ClientSession]] = []
 
         self._session_kwargs: SessionKwargs = {
             "sampling_callback": None,
@@ -89,24 +86,28 @@ class Client:
 
     async def __aenter__(self):
         if self.is_connected():
-            raise RuntimeError("Client is already connected in an async context.")
+            # We're already connected, no need to add None to the session_cms list
+            return self
+
         try:
-            self._session_cm = self.transport.connect_session(**self._session_kwargs)
-            self._session = await self._session_cm.__aenter__()
+            session_cm = self.transport.connect_session(**self._session_kwargs)
+            self._session_cms.append(session_cm)
+            self._session = await self._session_cms[-1].__aenter__()
             return self
         except Exception as e:
             # Ensure cleanup if __aenter__ fails partially
             self._session = None
-            self._session_cm = None
+            if self._session_cms:
+                self._session_cms.pop()
             raise ConnectionError(
                 f"Failed to connect using {self.transport}: {e}"
             ) from e
 
     async def __aexit__(self, exc_type, exc_val, exc_tb):
-        if self._session_cm:
-            await self._session_cm.__aexit__(exc_type, exc_val, exc_tb)
-        self._session = None
-        self._session_cm = None
+        if self._session_cms:
+            await self._session_cms[-1].__aexit__(exc_type, exc_val, exc_tb)
+            self._session = None
+            self._session_cms.pop()
 
     # --- MCP Client Methods ---
     async def ping(self) -> None:
@@ -168,10 +169,10 @@ class Client:
 
     async def get_prompt(
         self, name: str, arguments: dict[str, str] | None = None
-    ) -> mcp.types.GetPromptResult:
+    ) -> list[mcp.types.PromptMessage]:
         """Send a prompts/get request."""
         result = await self.session.get_prompt(name, arguments)
-        return result
+        return result.messages
 
     async def complete(
         self,

fastmcp/client/transports.py

@@ -2,13 +2,15 @@ import abc
 import contextlib
 import datetime
 import os
+import shutil
 from collections.abc import AsyncIterator
 from pathlib import Path
 from typing import (
     TypedDict,
 )
 
-from mcp import ClientSession, StdioServerParameters
+from exceptiongroup import BaseExceptionGroup, catch
+from mcp import ClientSession, McpError, StdioServerParameters
 from mcp.client.session import (
     ListRootsFnT,
     LoggingFnT,
@@ -22,6 +24,7 @@ from mcp.shared.memory import create_connected_server_and_client_session
 from pydantic import AnyUrl
 from typing_extensions import Unpack
 
+from fastmcp.exceptions import ClientError
 from fastmcp.server import FastMCP as FastMCPServer
 
 
@@ -341,6 +344,10 @@ class NpxStdioTransport(StdioTransport):
             env_vars: Additional environment variables
             use_package_lock: Whether to use package-lock.json (--prefer-offline)
         """
+        # verify npx is installed
+        if shutil.which("npx") is None:
+            raise ValueError("Command 'npx' not found")
+
         # Basic validation
         if project_directory and not Path(project_directory).exists():
             raise NotADirectoryError(
@@ -382,12 +389,26 @@ class FastMCPTransport(ClientTransport):
     async def connect_session(
         self, **session_kwargs: Unpack[SessionKwargs]
     ) -> AsyncIterator[ClientSession]:
-        # create_connected_server_and_client_session manages the session lifecycle itself
-        async with create_connected_server_and_client_session(
-            server=self._fastmcp._mcp_server,
-            **session_kwargs,
-        ) as session:
-            yield session
+        def exception_handler(excgroup: BaseExceptionGroup):
+            for exc in excgroup.exceptions:
+                if isinstance(exc, BaseExceptionGroup):
+                    exception_handler(exc)
+                raise exc
+
+        def mcperror_handler(excgroup: BaseExceptionGroup):
+            for exc in excgroup.exceptions:
+                if isinstance(exc, BaseExceptionGroup):
+                    mcperror_handler(exc)
+                raise ClientError(exc)
+
+        # backport of 3.11's except* syntax
+        with catch({McpError: mcperror_handler, Exception: exception_handler}):
+            # create_connected_server_and_client_session manages the session lifecycle itself
+            async with create_connected_server_and_client_session(
+                server=self._fastmcp._mcp_server,
+                **session_kwargs,
+            ) as session:
+                yield session
 
     def __repr__(self) -> str:
         return f"<FastMCP(server='{self._fastmcp.name}')>"

fastmcp/exceptions.py

@@ -23,3 +23,11 @@ class PromptError(FastMCPError):
 
 class InvalidSignature(Exception):
     """Invalid signature for use with FastMCP."""
+
+
+class ClientError(Exception):
+    """Error in client operations."""
+
+
+class NotFoundError(Exception):
+    """Object not found."""

fastmcp/prompts/prompt.py

@@ -7,6 +7,8 @@ from typing import Annotated, Any, Literal
 
 import pydantic_core
 from mcp.types import EmbeddedResource, ImageContent, TextContent
+from mcp.types import Prompt as MCPPrompt
+from mcp.types import PromptArgument as MCPPromptArgument
 from pydantic import BaseModel, BeforeValidator, Field, TypeAdapter, validate_call
 
 from fastmcp.utilities.types import _convert_set_defaults
@@ -113,7 +115,7 @@ class Prompt(BaseModel):
 
         return cls(
             name=func_name,
-            description=description or fn.__doc__ or "",
+            description=description or fn.__doc__,
             arguments=arguments,
             fn=fn,
             tags=tags or set(),
@@ -166,3 +168,20 @@ class Prompt(BaseModel):
         if not isinstance(other, Prompt):
             return False
         return self.model_dump() == other.model_dump()
+
+    def to_mcp_prompt(self, **overrides: Any) -> MCPPrompt:
+        """Convert the prompt to an MCP prompt."""
+        arguments = [
+            MCPPromptArgument(
+                name=arg.name,
+                description=arg.description,
+                required=arg.required,
+            )
+            for arg in self.arguments or []
+        ]
+        kwargs = {
+            "name": self.name,
+            "description": self.description,
+            "arguments": arguments,
+        }
+        return MCPPrompt(**kwargs | overrides)

fastmcp/prompts/prompt_manager.py

@@ -1,10 +1,9 @@
 """Prompt management functionality."""
 
-import copy
 from collections.abc import Awaitable, Callable
 from typing import Any
 
-from fastmcp.exceptions import PromptError
+from fastmcp.exceptions import NotFoundError
 from fastmcp.prompts.prompt import Message, Prompt, PromptResult
 from fastmcp.settings import DuplicateBehavior
 from fastmcp.utilities.logging import get_logger
@@ -15,17 +14,28 @@ logger = get_logger(__name__)
 class PromptManager:
     """Manages FastMCP prompts."""
 
-    def __init__(self, duplicate_behavior: DuplicateBehavior = DuplicateBehavior.WARN):
+    def __init__(self, duplicate_behavior: DuplicateBehavior | None = None):
         self._prompts: dict[str, Prompt] = {}
+
+        # Default to "warn" if None is provided
+        if duplicate_behavior is None:
+            duplicate_behavior = "warn"
+
+        if duplicate_behavior not in DuplicateBehavior.__args__:
+            raise ValueError(
+                f"Invalid duplicate_behavior: {duplicate_behavior}. "
+                f"Must be one of: {', '.join(DuplicateBehavior.__args__)}"
+            )
+
         self.duplicate_behavior = duplicate_behavior
 
-    def get_prompt(self, name: str) -> Prompt | None:
-        """Get prompt by name."""
-        return self._prompts.get(name)
+    def get_prompt(self, key: str) -> Prompt | None:
+        """Get prompt by key."""
+        return self._prompts.get(key)
 
-    def list_prompts(self) -> list[Prompt]:
-        """List all registered prompts."""
-        return list(self._prompts.values())
+    def get_prompts(self) -> dict[str, Prompt]:
+        """Get all registered prompts, indexed by registered key."""
+        return self._prompts
 
     def add_prompt_from_fn(
         self,
@@ -38,23 +48,24 @@ class PromptManager:
         prompt = Prompt.from_function(fn, name=name, description=description, tags=tags)
         return self.add_prompt(prompt)
 
-    def add_prompt(self, prompt: Prompt) -> Prompt:
+    def add_prompt(self, prompt: Prompt, key: str | None = None) -> Prompt:
         """Add a prompt to the manager."""
+        key = key or prompt.name
 
         # Check for duplicates
-        existing = self._prompts.get(prompt.name)
+        existing = self._prompts.get(key)
         if existing:
-            if self.duplicate_behavior == DuplicateBehavior.WARN:
-                logger.warning(f"Prompt already exists: {prompt.name}")
-                self._prompts[prompt.name] = prompt
-            elif self.duplicate_behavior == DuplicateBehavior.REPLACE:
-                self._prompts[prompt.name] = prompt
-            elif self.duplicate_behavior == DuplicateBehavior.ERROR:
-                raise ValueError(f"Prompt already exists: {prompt.name}")
-            elif self.duplicate_behavior == DuplicateBehavior.IGNORE:
-                pass
-
-        self._prompts[prompt.name] = prompt
+            if self.duplicate_behavior == "warn":
+                logger.warning(f"Prompt already exists: {key}")
+                self._prompts[key] = prompt
+            elif self.duplicate_behavior == "replace":
+                self._prompts[key] = prompt
+            elif self.duplicate_behavior == "error":
+                raise ValueError(f"Prompt already exists: {key}")
+            elif self.duplicate_behavior == "ignore":
+                return existing
+        else:
+            self._prompts[key] = prompt
         return prompt
 
     async def render_prompt(
@@ -63,31 +74,10 @@ class PromptManager:
         """Render a prompt by name with arguments."""
         prompt = self.get_prompt(name)
         if not prompt:
-            raise PromptError(f"Unknown prompt: {name}")
+            raise NotFoundError(f"Unknown prompt: {name}")
 
         return await prompt.render(arguments)
 
-    def import_prompts(
-        self, manager: "PromptManager", prefix: str | None = None
-    ) -> None:
-        """
-        Import all prompts from another PromptManager with prefixed names.
-
-        Args:
-            manager: Another PromptManager instance to import prompts from
-            prefix: Prefix to add to prompt names. The resulting prompt name will
-                   be in the format "{prefix}{original_name}" if prefix is provided,
-                   otherwise the original name is used.
-                   For example, with prefix "weather/" and prompt "forecast_prompt",
-                   the imported prompt would be available as "weather/forecast_prompt"
-        """
-        for name, prompt in manager._prompts.items():
-            # Create prefixed name
-            prefixed_name = f"{prefix}{name}" if prefix else name
-
-            new_prompt = copy.copy(prompt)
-            new_prompt.name = prefixed_name
-
-            # Store the prompt with the prefixed name
-            self.add_prompt(new_prompt)
-            logger.debug(f'Imported prompt "{name}" as "{prefixed_name}"')
+    def has_prompt(self, key: str) -> bool:
+        """Check if a prompt exists."""
+        return key in self._prompts

fastmcp/resources/resource.py

@@ -1,8 +1,9 @@
 """Base classes and interfaces for FastMCP resources."""
 
 import abc
-from typing import Annotated
+from typing import Annotated, Any
 
+from mcp.types import Resource as MCPResource
 from pydantic import (
     AnyUrl,
     BaseModel,
@@ -38,6 +39,14 @@ class Resource(BaseModel, abc.ABC):
         pattern=r"^[a-zA-Z0-9]+/[a-zA-Z0-9\-+.]+$",
     )
 
+    @field_validator("mime_type", mode="before")
+    @classmethod
+    def set_default_mime_type(cls, mime_type: str | None) -> str:
+        """Set default MIME type if not provided."""
+        if mime_type:
+            return mime_type
+        return "text/plain"
+
     @field_validator("name", mode="before")
     @classmethod
     def set_default_name(cls, name: str | None, info: ValidationInfo) -> str:
@@ -57,3 +66,13 @@ class Resource(BaseModel, abc.ABC):
         if not isinstance(other, Resource):
             return False
         return self.model_dump() == other.model_dump()
+
+    def to_mcp_resource(self, **overrides: Any) -> MCPResource:
+        """Convert the resource to an MCPResource."""
+        kwargs = {
+            "uri": self.uri,
+            "name": self.name,
+            "description": self.description,
+            "mimeType": self.mime_type,
+        }
+        return MCPResource(**kwargs | overrides)