fastmcp 2.0.0__py3-none-any.whl → 2.1.1__py3-none-any.whl

fastmcp/cli/cli.py

@@ -65,7 +65,7 @@ def _build_uv_command(
     """Build the uv run command that runs a MCP server through mcp run."""
     cmd = ["uv"]
 
-    cmd.extend(["run", "--with", "mcp"])
+    cmd.extend(["run", "--with", "fastmcp"])
 
     if with_editable:
         cmd.extend(["--with-editable", str(with_editable)])
@@ -76,7 +76,7 @@ def _build_uv_command(
                 cmd.extend(["--with", pkg])
 
     # Add mcp run command
-    cmd.extend(["mcp", "run", file_spec])
+    cmd.extend(["fastmcp", "run", file_spec])
     return cmd
 
 
@@ -323,6 +323,8 @@ def run(
         # Import and get server object
         server = _import_server(file, server_object)
 
+        logger.info(f'Found server "{server.name}" in {file}')
+
         # Run the server
         kwargs = {}
         if transport:

fastmcp/client/client.py

@@ -1,7 +1,7 @@
 import datetime
 from contextlib import AbstractAsyncContextManager
 from pathlib import Path
-from typing import Any
+from typing import Any, Literal, cast, overload
 
 import mcp.types
 from mcp import ClientSession
@@ -24,6 +24,10 @@ 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.
@@ -122,60 +126,101 @@ class Client:
         """Send a logging/setLevel request."""
         await self.session.set_logging_level(level)
 
-    async def list_resources(self) -> mcp.types.ListResourcesResult:
+    async def send_roots_list_changed(self) -> None:
+        """Send a roots/list_changed notification."""
+        await self.session.send_roots_list_changed()
+
+    async def list_resources(self) -> list[mcp.types.Resource]:
         """Send a resources/list request."""
-        return await self.session.list_resources()
+        result = await self.session.list_resources()
+        return result.resources
 
-    async def list_resource_templates(self) -> mcp.types.ListResourceTemplatesResult:
+    async def list_resource_templates(self) -> list[mcp.types.ResourceTemplate]:
         """Send a resources/listResourceTemplates request."""
-        return await self.session.list_resource_templates()
+        result = await self.session.list_resource_templates()
+        return result.resourceTemplates
 
-    async def read_resource(self, uri: AnyUrl | str) -> mcp.types.ReadResourceResult:
+    async def read_resource(
+        self, uri: AnyUrl | str
+    ) -> list[mcp.types.TextResourceContents | mcp.types.BlobResourceContents]:
         """Send a resources/read request."""
         if isinstance(uri, str):
             uri = AnyUrl(uri)  # Ensure AnyUrl
-        return await self.session.read_resource(uri)
-
-    async def subscribe_resource(self, uri: AnyUrl | str) -> None:
-        """Send a resources/subscribe request."""
-        if isinstance(uri, str):
-            uri = AnyUrl(uri)
-        await self.session.subscribe_resource(uri)
-
-    async def unsubscribe_resource(self, uri: AnyUrl | str) -> None:
-        """Send a resources/unsubscribe request."""
-        if isinstance(uri, str):
-            uri = AnyUrl(uri)
-        await self.session.unsubscribe_resource(uri)
-
-    async def list_prompts(self) -> mcp.types.ListPromptsResult:
+        result = await self.session.read_resource(uri)
+        return result.contents
+
+    # async def subscribe_resource(self, uri: AnyUrl | str) -> None:
+    #     """Send a resources/subscribe request."""
+    #     if isinstance(uri, str):
+    #         uri = AnyUrl(uri)
+    #     await self.session.subscribe_resource(uri)
+
+    # async def unsubscribe_resource(self, uri: AnyUrl | str) -> None:
+    #     """Send a resources/unsubscribe request."""
+    #     if isinstance(uri, str):
+    #         uri = AnyUrl(uri)
+    #     await self.session.unsubscribe_resource(uri)
+
+    async def list_prompts(self) -> list[mcp.types.Prompt]:
         """Send a prompts/list request."""
-        return await self.session.list_prompts()
+        result = await self.session.list_prompts()
+        return result.prompts
 
     async def get_prompt(
         self, name: str, arguments: dict[str, str] | None = None
     ) -> mcp.types.GetPromptResult:
         """Send a prompts/get request."""
-        return await self.session.get_prompt(name, arguments)
+        result = await self.session.get_prompt(name, arguments)
+        return result
 
     async def complete(
         self,
         ref: mcp.types.ResourceReference | mcp.types.PromptReference,
         argument: dict[str, str],
-    ) -> mcp.types.CompleteResult:
-        """Send a completion/complete request."""
-        return await self.session.complete(ref, argument)
+    ) -> mcp.types.Completion:
+        """Send a completion request."""
+        result = await self.session.complete(ref, argument)
+        return result.completion
 
-    async def list_tools(self) -> mcp.types.ListToolsResult:
+    async def list_tools(self) -> list[mcp.types.Tool]:
         """Send a tools/list request."""
-        return await self.session.list_tools()
+        result = await self.session.list_tools()
+        return result.tools
 
+    @overload
     async def call_tool(
-        self, name: str, arguments: dict[str, Any] | None = None
-    ) -> mcp.types.CallToolResult:
-        """Send a tools/call request."""
-        return await self.session.call_tool(name, arguments)
+        self,
+        name: str,
+        arguments: dict[str, Any] | None = None,
+        _return_raw_result: Literal[False] = False,
+    ) -> list[
+        mcp.types.TextContent | mcp.types.ImageContent | mcp.types.EmbeddedResource
+    ]: ...
+
+    @overload
+    async def call_tool(
+        self,
+        name: str,
+        arguments: dict[str, Any] | None = None,
+        _return_raw_result: Literal[True] = True,
+    ) -> mcp.types.CallToolResult: ...
 
-    async def send_roots_list_changed(self) -> None:
-        """Send a roots/list_changed notification."""
-        await self.session.send_roots_list_changed()
+    async def call_tool(
+        self,
+        name: str,
+        arguments: dict[str, Any] | None = None,
+        _return_raw_result: bool = False,
+    ) -> (
+        list[
+            mcp.types.TextContent | mcp.types.ImageContent | mcp.types.EmbeddedResource
+        ]
+        | mcp.types.CallToolResult
+    ):
+        """Send a tools/call request."""
+        result = await self.session.call_tool(name, arguments)
+        if _return_raw_result:
+            return result
+        elif result.isError:
+            msg = cast(mcp.types.TextContent, result.content[0]).text
+            raise ClientError(msg)
+        return result.content

fastmcp/client/transports.py

@@ -208,6 +208,28 @@ class PythonStdioTransport(StdioTransport):
         self.script_path = script_path
 
 
+class FastMCPStdioTransport(StdioTransport):
+    """Transport for running FastMCP servers using the FastMCP CLI."""
+
+    def __init__(
+        self,
+        script_path: str | Path,
+        args: list[str] | None = None,
+        env: dict[str, str] | None = None,
+        cwd: str | None = None,
+    ):
+        script_path = Path(script_path).resolve()
+        if not script_path.is_file():
+            raise FileNotFoundError(f"Script not found: {script_path}")
+        if not str(script_path).endswith(".py"):
+            raise ValueError(f"Not a Python script: {script_path}")
+
+        super().__init__(
+            command="fastmcp", args=["run", str(script_path)], env=env, cwd=cwd
+        )
+        self.script_path = script_path
+
+
 class NodeStdioTransport(StdioTransport):
     """Transport for running Node.js scripts."""
 

fastmcp/exceptions.py

@@ -17,5 +17,9 @@ class ToolError(FastMCPError):
     """Error in tool operations."""
 
 
+class PromptError(FastMCPError):
+    """Error in prompt operations."""
+
+
 class InvalidSignature(Exception):
     """Invalid signature for use with FastMCP."""

fastmcp/prompts/__init__.py

@@ -1,4 +1,4 @@
-from .base import Prompt
+from .prompt import Prompt, Message, UserMessage, AssistantMessage
 from .prompt_manager import PromptManager
 
-__all__ = ["Prompt", "PromptManager"]
+__all__ = ["Prompt", "PromptManager", "Message", "UserMessage", "AssistantMessage"]

fastmcp/prompts/{base.py → prompt.py}

@@ -3,11 +3,14 @@
 import inspect
 import json
 from collections.abc import Awaitable, Callable, Sequence
-from typing import Any, Literal
+from typing import Annotated, Any, Literal
 
 import pydantic_core
 from mcp.types import EmbeddedResource, ImageContent, TextContent
-from pydantic import BaseModel, Field, TypeAdapter, validate_call
+from pydantic import BaseModel, BeforeValidator, Field, TypeAdapter, validate_call
+from typing_extensions import Self
+
+from fastmcp.utilities.types import _convert_set_defaults
 
 CONTENT_TYPES = TextContent | ImageContent | EmbeddedResource
 
@@ -24,27 +27,17 @@ class Message(BaseModel):
         super().__init__(content=content, **kwargs)
 
 
-class UserMessage(Message):
+def UserMessage(content: str | CONTENT_TYPES, **kwargs: Any) -> Message:
     """A message from the user."""
+    return Message(content=content, role="user", **kwargs)
 
-    role: Literal["user", "assistant"] = "user"
-
-    def __init__(self, content: str | CONTENT_TYPES, **kwargs: Any):
-        super().__init__(content=content, **kwargs)
 
-
-class AssistantMessage(Message):
+def AssistantMessage(content: str | CONTENT_TYPES, **kwargs: Any) -> Message:
     """A message from the assistant."""
+    return Message(content=content, role="assistant", **kwargs)
 
-    role: Literal["user", "assistant"] = "assistant"
 
-    def __init__(self, content: str | CONTENT_TYPES, **kwargs: Any):
-        super().__init__(content=content, **kwargs)
-
-
-message_validator = TypeAdapter[UserMessage | AssistantMessage](
-    UserMessage | AssistantMessage
-)
+message_validator = TypeAdapter[Message](Message)
 
 SyncPromptResult = (
     str | Message | dict[str, Any] | Sequence[str | Message | dict[str, Any]]
@@ -71,10 +64,13 @@ class Prompt(BaseModel):
     description: str | None = Field(
         None, description="Description of what the prompt does"
     )
+    tags: Annotated[set[str], BeforeValidator(_convert_set_defaults)] = Field(
+        default_factory=set, description="Tags for the prompt"
+    )
     arguments: list[PromptArgument] | None = Field(
         None, description="Arguments that can be passed to the prompt"
     )
-    fn: Callable[..., PromptResult | Awaitable[PromptResult]] = Field(exclude=True)
+    fn: Callable[..., PromptResult | Awaitable[PromptResult]]
 
     @classmethod
     def from_function(
@@ -82,6 +78,7 @@ class Prompt(BaseModel):
         fn: Callable[..., PromptResult | Awaitable[PromptResult]],
         name: str | None = None,
         description: str | None = None,
+        tags: set[str] | None = None,
     ) -> "Prompt":
         """Create a Prompt from a function.
 
@@ -120,6 +117,7 @@ class Prompt(BaseModel):
             description=description or fn.__doc__ or "",
             arguments=arguments,
             fn=fn,
+            tags=tags or set(),
         )
 
     async def render(self, arguments: dict[str, Any] | None = None) -> list[Message]:
@@ -152,7 +150,7 @@ class Prompt(BaseModel):
                         messages.append(message_validator.validate_python(msg))
                     elif isinstance(msg, str):
                         content = TextContent(type="text", text=msg)
-                        messages.append(UserMessage(content=content))
+                        messages.append(Message(role="user", content=content))
                     else:
                         content = json.dumps(pydantic_core.to_jsonable_python(msg))
                         messages.append(Message(role="user", content=content))
@@ -164,3 +162,15 @@ class Prompt(BaseModel):
             return messages
         except Exception as e:
             raise ValueError(f"Error rendering prompt {self.name}: {e}")
+
+    def copy(self, updates: dict[str, Any] | None = None) -> Self:
+        """Copy the prompt with optional updates."""
+        data = self.model_dump()
+        if updates:
+            data.update(updates)
+        return type(self)(**data)
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, Prompt):
+            return False
+        return self.model_dump() == other.model_dump()

fastmcp/prompts/prompt_manager.py

@@ -1,8 +1,11 @@
 """Prompt management functionality."""
 
+from collections.abc import Awaitable, Callable
 from typing import Any
 
-from fastmcp.prompts.base import Message, Prompt
+from fastmcp.exceptions import PromptError
+from fastmcp.prompts.prompt import Message, Prompt, PromptResult
+from fastmcp.settings import DuplicateBehavior
 from fastmcp.utilities.logging import get_logger
 
 logger = get_logger(__name__)
@@ -11,9 +14,9 @@ logger = get_logger(__name__)
 class PromptManager:
     """Manages FastMCP prompts."""
 
-    def __init__(self, warn_on_duplicate_prompts: bool = True):
+    def __init__(self, duplicate_behavior: DuplicateBehavior = DuplicateBehavior.WARN):
         self._prompts: dict[str, Prompt] = {}
-        self.warn_on_duplicate_prompts = warn_on_duplicate_prompts
+        self.duplicate_behavior = duplicate_behavior
 
     def get_prompt(self, name: str) -> Prompt | None:
         """Get prompt by name."""
@@ -23,18 +26,32 @@ class PromptManager:
         """List all registered prompts."""
         return list(self._prompts.values())
 
-    def add_prompt(
+    def add_prompt_from_fn(
         self,
-        prompt: Prompt,
+        fn: Callable[..., PromptResult | Awaitable[PromptResult]],
+        name: str | None = None,
+        description: str | None = None,
+        tags: set[str] | None = None,
     ) -> Prompt:
+        """Create a prompt from a function."""
+        prompt = Prompt.from_function(fn, name=name, description=description, tags=tags)
+        return self.add_prompt(prompt)
+
+    def add_prompt(self, prompt: Prompt) -> Prompt:
         """Add a prompt to the manager."""
 
         # Check for duplicates
         existing = self._prompts.get(prompt.name)
         if existing:
-            if self.warn_on_duplicate_prompts:
+            if self.duplicate_behavior == DuplicateBehavior.WARN:
                 logger.warning(f"Prompt already exists: {prompt.name}")
-            return existing
+                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
         return prompt
@@ -45,7 +62,7 @@ class PromptManager:
         """Render a prompt by name with arguments."""
         prompt = self.get_prompt(name)
         if not prompt:
-            raise ValueError(f"Unknown prompt: {name}")
+            raise PromptError(f"Unknown prompt: {name}")
 
         return await prompt.render(arguments)
 
@@ -64,11 +81,11 @@ class PromptManager:
                    the imported prompt would be available as "weather/forecast_prompt"
         """
         for name, prompt in manager._prompts.items():
-            # Create prefixed name - we keep the original name in the Prompt object
+            # Create prefixed name
             prefixed_name = f"{prefix}{name}" if prefix else name
 
-            # Log the import
-            logger.debug(f"Importing prompt with name {name} as {prefixed_name}")
+            new_prompt = prompt.copy(updates=dict(name=prefixed_name))
 
             # Store the prompt with the prefixed name
-            self._prompts[prefixed_name] = prompt
+            self.add_prompt(new_prompt)
+            logger.debug(f'Imported prompt "{name}" as "{prefixed_name}"')

fastmcp/resources/__init__.py

@@ -1,6 +1,5 @@
-from .base import Resource
-from .resource_manager import ResourceManager
-from .templates import ResourceTemplate
+from .resource import Resource
+from .template import ResourceTemplate
 from .types import (
     BinaryResource,
     DirectoryResource,
@@ -9,6 +8,7 @@ from .types import (
     HttpResource,
     TextResource,
 )
+from .resource_manager import ResourceManager
 
 __all__ = [
     "Resource",

fastmcp/resources/{base.py → resource.py}

@@ -1,17 +1,21 @@
 """Base classes and interfaces for FastMCP resources."""
 
 import abc
-from typing import Annotated
+from typing import Annotated, Any
 
 from pydantic import (
     AnyUrl,
     BaseModel,
+    BeforeValidator,
     ConfigDict,
     Field,
     UrlConstraints,
     ValidationInfo,
     field_validator,
 )
+from typing_extensions import Self
+
+from fastmcp.utilities.types import _convert_set_defaults
 
 
 class Resource(BaseModel, abc.ABC):
@@ -26,6 +30,9 @@ class Resource(BaseModel, abc.ABC):
     description: str | None = Field(
         description="Description of the resource", default=None
     )
+    tags: Annotated[set[str], BeforeValidator(_convert_set_defaults)] = Field(
+        default_factory=set, description="Tags for the resource"
+    )
     mime_type: str = Field(
         default="text/plain",
         description="MIME type of the resource content",
@@ -46,3 +53,15 @@ class Resource(BaseModel, abc.ABC):
     async def read(self) -> str | bytes:
         """Read the resource content."""
         pass
+
+    def copy(self, updates: dict[str, Any] | None = None) -> Self:
+        """Copy the resource with optional updates."""
+        data = self.model_dump()
+        if updates:
+            data.update(updates)
+        return type(self)(**data)
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, Resource):
+            return False
+        return self.model_dump() == other.model_dump()