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

fastmcp/cli/cli.py

@@ -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/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 .prompt 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/prompt.py

@@ -8,7 +8,6 @@ from typing import Annotated, Any, Literal
 import pydantic_core
 from mcp.types import EmbeddedResource, ImageContent, TextContent
 from pydantic import BaseModel, BeforeValidator, Field, TypeAdapter, validate_call
-from typing_extensions import Self
 
 from fastmcp.utilities.types import _convert_set_defaults
 
@@ -27,27 +26,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]]
@@ -160,7 +149,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))
@@ -173,13 +162,6 @@ class Prompt(BaseModel):
         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

fastmcp/prompts/prompt_manager.py

@@ -1,8 +1,10 @@
 """Prompt management functionality."""
 
+import copy
 from collections.abc import Awaitable, Callable
 from typing import Any
 
+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
@@ -61,7 +63,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)
 
@@ -83,7 +85,8 @@ class PromptManager:
             # Create prefixed name
             prefixed_name = f"{prefix}{name}" if prefix else name
 
-            new_prompt = prompt.copy(updates=dict(name=prefixed_name))
+            new_prompt = copy.copy(prompt)
+            new_prompt.name = prefixed_name
 
             # Store the prompt with the prefixed name
             self.add_prompt(new_prompt)

fastmcp/resources/__init__.py

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

fastmcp/resources/resource.py

@@ -1,7 +1,7 @@
 """Base classes and interfaces for FastMCP resources."""
 
 import abc
-from typing import Annotated, Any
+from typing import Annotated
 
 from pydantic import (
     AnyUrl,
@@ -13,7 +13,6 @@ from pydantic import (
     ValidationInfo,
     field_validator,
 )
-from typing_extensions import Self
 
 from fastmcp.utilities.types import _convert_set_defaults
 
@@ -54,13 +53,6 @@ class Resource(BaseModel, abc.ABC):
         """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

fastmcp/resources/resource_manager.py

@@ -1,11 +1,15 @@
 """Resource manager functionality."""
 
+import copy
+import inspect
+import re
 from collections.abc import Callable
 from typing import Any
 
 from pydantic import AnyUrl
 
-from fastmcp.resources.resource import Resource
+from fastmcp.exceptions import ResourceError
+from fastmcp.resources import FunctionResource, Resource
 from fastmcp.resources.template import ResourceTemplate
 from fastmcp.settings import DuplicateBehavior
 from fastmcp.utilities.logging import get_logger
@@ -21,16 +25,86 @@ class ResourceManager:
         self._templates: dict[str, ResourceTemplate] = {}
         self.duplicate_behavior = duplicate_behavior
 
-    def add_resource(self, resource: Resource) -> Resource:
-        """Add a resource to the manager.
+    def add_resource_or_template_from_fn(
+        self,
+        fn: Callable[..., Any],
+        uri: str,
+        name: str | None = None,
+        description: str | None = None,
+        mime_type: str | None = None,
+        tags: set[str] | None = None,
+    ) -> Resource | ResourceTemplate:
+        """Add a resource or template to the manager from a function.
 
         Args:
-            resource: A Resource instance to add
+            fn: The function to register as a resource or template
+            uri: The URI for the resource or template
+            name: Optional name for the resource or template
+            description: Optional description of the resource or template
+            mime_type: Optional MIME type for the resource or template
+            tags: Optional set of tags for categorizing the resource or template
+
+        Returns:
+            The added resource or template. If a resource or template with the same URI already exists,
+            returns the existing resource or template.
+        """
+        # Check if this should be a template
+        has_uri_params = "{" in uri and "}" in uri
+        has_func_params = bool(inspect.signature(fn).parameters)
+
+        if has_uri_params and has_func_params:
+            return self.add_template_from_fn(
+                fn, uri, name, description, mime_type, tags
+            )
+        elif not has_uri_params and not has_func_params:
+            return self.add_resource_from_fn(
+                fn, uri, name, description, mime_type, tags
+            )
+        else:
+            raise ValueError(
+                "Invalid resource or template definition due to a "
+                "mismatch between URI parameters and function parameters."
+            )
+
+    def add_resource_from_fn(
+        self,
+        fn: Callable[..., Any],
+        uri: str,
+        name: str | None = None,
+        description: str | None = None,
+        mime_type: str | None = None,
+        tags: set[str] | None = None,
+    ) -> Resource:
+        """Add a resource to the manager from a function.
+
+        Args:
+            fn: The function to register as a resource
+            uri: The URI for the resource
+            name: Optional name for the resource
+            description: Optional description of the resource
+            mime_type: Optional MIME type for the resource
+            tags: Optional set of tags for categorizing the resource
 
         Returns:
             The added resource. If a resource with the same URI already exists,
             returns the existing resource.
         """
+        resource = FunctionResource(
+            uri=AnyUrl(uri),
+            name=name,
+            description=description,
+            mime_type=mime_type or "text/plain",
+            fn=fn,
+            tags=tags or set(),
+        )
+        return self.add_resource(resource)
+
+    def add_resource(self, resource: Resource) -> Resource:
+        """Add a resource to the manager.
+
+        Args:
+            resource: A Resource instance to add
+        """
         logger.debug(
             "Adding resource",
             extra={
@@ -63,6 +137,17 @@ class ResourceManager:
         tags: set[str] | None = None,
     ) -> ResourceTemplate:
         """Create a template from a function."""
+
+        # Validate that URI params match function params
+        uri_params = set(re.findall(r"{(\w+)}", uri_template))
+        func_params = set(inspect.signature(fn).parameters.keys())
+
+        if uri_params != func_params:
+            raise ValueError(
+                f"Mismatch between URI parameters {uri_params} "
+                f"and function parameters {func_params}"
+            )
+
         template = ResourceTemplate.from_function(
             fn,
             uri_template=uri_template,
@@ -122,7 +207,7 @@ class ResourceManager:
                 except Exception as e:
                     raise ValueError(f"Error creating resource from template: {e}")
 
-        raise ValueError(f"Unknown resource: {uri}")
+        raise ResourceError(f"Unknown resource: {uri}")
 
     def list_resources(self) -> list[Resource]:
         """List all registered resources."""
@@ -154,7 +239,8 @@ class ResourceManager:
             # Create prefixed URI and copy the resource with the new URI
             prefixed_uri = f"{prefix}{uri}" if prefix else uri
 
-            new_resource = resource.copy(updates=dict(uri=prefixed_uri))
+            new_resource = copy.copy(resource)
+            new_resource.uri = AnyUrl(prefixed_uri)
 
             # Store directly in resources dictionary
             self.add_resource(new_resource)
@@ -182,9 +268,8 @@ class ResourceManager:
                 f"{prefix}{uri_template}" if prefix else uri_template
             )
 
-            new_template = template.copy(
-                updates=dict(uri_template=prefixed_uri_template)
-            )
+            new_template = copy.copy(template)
+            new_template.uri_template = prefixed_uri_template
 
             # Store directly in templates dictionary
             self.add_template(new_template)

fastmcp/resources/template.py

@@ -8,7 +8,6 @@ from collections.abc import Callable
 from typing import Annotated, Any
 
 from pydantic import BaseModel, BeforeValidator, Field, TypeAdapter, validate_call
-from typing_extensions import Self
 
 from fastmcp.resources.types import FunctionResource, Resource
 from fastmcp.utilities.types import _convert_set_defaults
@@ -92,13 +91,6 @@ class ResourceTemplate(BaseModel):
         except Exception as e:
             raise ValueError(f"Error creating resource from template: {e}")
 
-    def copy(self, updates: dict[str, Any] | None = None) -> Self:
-        """Copy the resource template 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, ResourceTemplate):
             return False

fastmcp/server/context.py

@@ -118,7 +118,7 @@ class Context(BaseModel, Generic[ServerSessionT, LifespanContextT]):
         assert self._fastmcp is not None, (
             "Context is not available outside of a request"
         )
-        return await self._fastmcp.read_resource(uri)
+        return await self._fastmcp._mcp_read_resource(uri)
 
     async def log(
         self,

fastmcp/server/proxy.py

@@ -1,11 +1,11 @@
 from typing import Any, cast
 
 import mcp.types
-from mcp.types import BlobResourceContents, PromptMessage, TextResourceContents
+from mcp.types import BlobResourceContents, TextResourceContents
 
 import fastmcp
 from fastmcp.client import Client
-from fastmcp.prompts import Prompt
+from fastmcp.prompts import Message, Prompt
 from fastmcp.resources import Resource, ResourceTemplate
 from fastmcp.server.context import Context
 from fastmcp.server.server import FastMCP
@@ -142,10 +142,10 @@ class ProxyPrompt(Prompt):
             fn=_proxy_passthrough,
         )
 
-    async def render(self, arguments: dict[str, Any]) -> list[PromptMessage]:
+    async def render(self, arguments: dict[str, Any]) -> list[Message]:
         async with self._client:
             result = await self._client.get_prompt(self.name, arguments)
-        return result.messages
+        return [Message(role=m.role, content=m.content) for m in result.messages]
 
 
 class FastMCPProxy(FastMCP):