fastmcp 2.8.1__py3-none-any.whl → 2.9.1__py3-none-any.whl

fastmcp/prompts/prompt.py

@@ -3,15 +3,16 @@
 from __future__ import annotations as _annotations
 
 import inspect
+import json
 from abc import ABC, abstractmethod
 from collections.abc import Awaitable, Callable, Sequence
-from typing import TYPE_CHECKING, Any
+from typing import Any
 
 import pydantic_core
 from mcp.types import Prompt as MCPPrompt
 from mcp.types import PromptArgument as MCPPromptArgument
 from mcp.types import PromptMessage, Role, TextContent
-from pydantic import Field, TypeAdapter, validate_call
+from pydantic import Field, TypeAdapter
 
 from fastmcp.exceptions import PromptError
 from fastmcp.server.dependencies import get_context
@@ -25,10 +26,6 @@ from fastmcp.utilities.types import (
     get_cached_typeadapter,
 )
 
-if TYPE_CHECKING:
-    pass
-
-
 logger = get_logger(__name__)
 
 
@@ -73,6 +70,22 @@ class Prompt(FastMCPComponent, ABC):
         default=None, description="Arguments that can be passed to the prompt"
     )
 
+    def enable(self) -> None:
+        super().enable()
+        try:
+            context = get_context()
+            context._queue_prompt_list_changed()  # type: ignore[private-use]
+        except RuntimeError:
+            pass  # No context available
+
+    def disable(self) -> None:
+        super().disable()
+        try:
+            context = get_context()
+            context._queue_prompt_list_changed()  # type: ignore[private-use]
+        except RuntimeError:
+            pass  # No context available
+
     def to_mcp_prompt(self, **overrides: Any) -> MCPPrompt:
         """Convert the prompt to an MCP prompt."""
         arguments = [
@@ -155,7 +168,7 @@ class FunctionPrompt(Prompt):
             if param.kind == inspect.Parameter.VAR_KEYWORD:
                 raise ValueError("Functions with **kwargs are not supported as prompts")
 
-        description = description or fn.__doc__
+        description = description or inspect.getdoc(fn)
 
         # if the fn is a callable class, we need to get the __call__ method from here out
         if not inspect.isroutine(fn):
@@ -181,17 +194,43 @@ class FunctionPrompt(Prompt):
         arguments: list[PromptArgument] = []
         if "properties" in parameters:
             for param_name, param in parameters["properties"].items():
+                arg_description = param.get("description")
+
+                # For non-string parameters, append JSON schema info to help users
+                # understand the expected format when passing as strings (MCP requirement)
+                if param_name in sig.parameters:
+                    sig_param = sig.parameters[param_name]
+                    if (
+                        sig_param.annotation != inspect.Parameter.empty
+                        and sig_param.annotation is not str
+                        and param_name != context_kwarg
+                    ):
+                        # Get the JSON schema for this specific parameter type
+                        try:
+                            param_adapter = get_cached_typeadapter(sig_param.annotation)
+                            param_schema = param_adapter.json_schema()
+
+                            # Create compact schema representation
+                            schema_str = json.dumps(param_schema, separators=(",", ":"))
+
+                            # Append schema info to description
+                            schema_note = f"Provide as a JSON string matching the following schema: {schema_str}"
+                            if arg_description:
+                                arg_description = f"{arg_description}\n\n{schema_note}"
+                            else:
+                                arg_description = schema_note
+                        except Exception:
+                            # If schema generation fails, skip enhancement
+                            pass
+
                 arguments.append(
                     PromptArgument(
                         name=param_name,
-                        description=param.get("description"),
+                        description=arg_description,
                         required=param_name in parameters.get("required", []),
                     )
                 )
 
-        # ensure the arguments are properly cast
-        fn = validate_call(fn)
-
         return cls(
             name=func_name,
             description=description,
@@ -201,6 +240,60 @@ class FunctionPrompt(Prompt):
             fn=fn,
         )
 
+    def _convert_string_arguments(self, kwargs: dict[str, Any]) -> dict[str, Any]:
+        """Convert string arguments to expected types based on function signature."""
+        from fastmcp.server.context import Context
+
+        sig = inspect.signature(self.fn)
+        converted_kwargs = {}
+
+        # Find context parameter name if any
+        context_param_name = find_kwarg_by_type(self.fn, kwarg_type=Context)
+
+        for param_name, param_value in kwargs.items():
+            if param_name in sig.parameters:
+                param = sig.parameters[param_name]
+
+                # Skip Context parameters - they're handled separately
+                if param_name == context_param_name:
+                    converted_kwargs[param_name] = param_value
+                    continue
+
+                # If parameter has no annotation or annotation is str, pass as-is
+                if (
+                    param.annotation == inspect.Parameter.empty
+                    or param.annotation is str
+                ):
+                    converted_kwargs[param_name] = param_value
+                # If argument is not a string, pass as-is (already properly typed)
+                elif not isinstance(param_value, str):
+                    converted_kwargs[param_name] = param_value
+                else:
+                    # Try to convert string argument using type adapter
+                    try:
+                        adapter = get_cached_typeadapter(param.annotation)
+                        # Try JSON parsing first for complex types
+                        try:
+                            converted_kwargs[param_name] = adapter.validate_json(
+                                param_value
+                            )
+                        except (ValueError, TypeError, pydantic_core.ValidationError):
+                            # Fallback to direct validation
+                            converted_kwargs[param_name] = adapter.validate_python(
+                                param_value
+                            )
+                    except (ValueError, TypeError, pydantic_core.ValidationError) as e:
+                        # If conversion fails, provide informative error
+                        raise PromptError(
+                            f"Could not convert argument '{param_name}' with value '{param_value}' "
+                            f"to expected type {param.annotation}. Error: {e}"
+                        )
+            else:
+                # Parameter not in function signature, pass as-is
+                converted_kwargs[param_name] = param_value
+
+        return converted_kwargs
+
     async def render(
         self,
         arguments: dict[str, Any] | None = None,
@@ -223,6 +316,9 @@ class FunctionPrompt(Prompt):
             if context_kwarg and context_kwarg not in kwargs:
                 kwargs[context_kwarg] = get_context()
 
+            # Convert string arguments to expected types when needed
+            kwargs = self._convert_string_arguments(kwargs)
+
             # Call function and check if result is a coroutine
             result = self.fn(**kwargs)
             if inspect.iscoroutine(result):
@@ -259,6 +355,6 @@ class FunctionPrompt(Prompt):
                     raise PromptError("Could not convert prompt result to message.")
 
             return messages
-        except Exception as e:
-            logger.exception(f"Error rendering prompt {self.name}: {e}")
+        except Exception:
+            logger.exception(f"Error rendering prompt {self.name}")
             raise PromptError(f"Error rendering prompt {self.name}.")

fastmcp/prompts/prompt_manager.py

@@ -13,7 +13,7 @@ from fastmcp.settings import DuplicateBehavior
 from fastmcp.utilities.logging import get_logger
 
 if TYPE_CHECKING:
-    pass
+    from fastmcp.server.server import MountedServer
 
 logger = get_logger(__name__)
 
@@ -27,6 +27,7 @@ class PromptManager:
         mask_error_details: bool | None = None,
     ):
         self._prompts: dict[str, Prompt] = {}
+        self._mounted_servers: list[MountedServer] = []
         self.mask_error_details = mask_error_details or settings.mask_error_details
 
         # Default to "warn" if None is provided
@@ -41,15 +42,74 @@ class PromptManager:
 
         self.duplicate_behavior = duplicate_behavior
 
-    def get_prompt(self, key: str) -> Prompt:
+    def mount(self, server: MountedServer) -> None:
+        """Adds a mounted server as a source for prompts."""
+        self._mounted_servers.append(server)
+
+    async def _load_prompts(self, *, via_server: bool = False) -> dict[str, Prompt]:
+        """
+        The single, consolidated recursive method for fetching prompts. The 'via_server'
+        parameter determines the communication path.
+
+        - via_server=False: Manager-to-manager path for complete, unfiltered inventory
+        - via_server=True: Server-to-server path for filtered MCP requests
+        """
+        all_prompts: dict[str, Prompt] = {}
+
+        for mounted in self._mounted_servers:
+            try:
+                if via_server:
+                    # Use the server-to-server filtered path
+                    child_results = await mounted.server._list_prompts()
+                else:
+                    # Use the manager-to-manager unfiltered path
+                    child_results = await mounted.server._prompt_manager.list_prompts()
+
+                # The combination logic is the same for both paths
+                child_dict = {p.key: p for p in child_results}
+                if mounted.prefix:
+                    for prompt in child_dict.values():
+                        prefixed_prompt = prompt.with_key(
+                            f"{mounted.prefix}_{prompt.key}"
+                        )
+                        all_prompts[prefixed_prompt.key] = prefixed_prompt
+                else:
+                    all_prompts.update(child_dict)
+            except Exception as e:
+                # Skip failed mounts silently, matches existing behavior
+                logger.warning(
+                    f"Failed to get prompts from mounted server '{mounted.prefix}': {e}"
+                )
+                continue
+
+        # Finally, add local prompts, which always take precedence
+        all_prompts.update(self._prompts)
+        return all_prompts
+
+    async def has_prompt(self, key: str) -> bool:
+        """Check if a prompt exists."""
+        prompts = await self.get_prompts()
+        return key in prompts
+
+    async def get_prompt(self, key: str) -> Prompt:
         """Get prompt by key."""
-        if key in self._prompts:
-            return self._prompts[key]
+        prompts = await self.get_prompts()
+        if key in prompts:
+            return prompts[key]
         raise NotFoundError(f"Unknown prompt: {key}")
 
-    def get_prompts(self) -> dict[str, Prompt]:
-        """Get all registered prompts, indexed by registered key."""
-        return self._prompts
+    async def get_prompts(self) -> dict[str, Prompt]:
+        """
+        Gets the complete, unfiltered inventory of all prompts.
+        """
+        return await self._load_prompts(via_server=False)
+
+    async def list_prompts(self) -> list[Prompt]:
+        """
+        Lists all prompts, applying protocol filtering.
+        """
+        prompts_dict = await self._load_prompts(via_server=True)
+        return list(prompts_dict.values())
 
     def add_prompt_from_fn(
         self,
@@ -71,24 +131,22 @@ class PromptManager:
         )
         return self.add_prompt(prompt)  # type: ignore
 
-    def add_prompt(self, prompt: Prompt, key: str | None = None) -> Prompt:
+    def add_prompt(self, prompt: Prompt) -> Prompt:
         """Add a prompt to the manager."""
-        key = key or prompt.name
-
         # Check for duplicates
-        existing = self._prompts.get(key)
+        existing = self._prompts.get(prompt.key)
         if existing:
             if self.duplicate_behavior == "warn":
-                logger.warning(f"Prompt already exists: {key}")
-                self._prompts[key] = prompt
+                logger.warning(f"Prompt already exists: {prompt.key}")
+                self._prompts[prompt.key] = prompt
             elif self.duplicate_behavior == "replace":
-                self._prompts[key] = prompt
+                self._prompts[prompt.key] = prompt
             elif self.duplicate_behavior == "error":
-                raise ValueError(f"Prompt already exists: {key}")
+                raise ValueError(f"Prompt already exists: {prompt.key}")
             elif self.duplicate_behavior == "ignore":
                 return existing
         else:
-            self._prompts[key] = prompt
+            self._prompts[prompt.key] = prompt
         return prompt
 
     async def render_prompt(
@@ -96,30 +154,48 @@ class PromptManager:
         name: str,
         arguments: dict[str, Any] | None = None,
     ) -> GetPromptResult:
-        """Render a prompt by name with arguments."""
-        prompt = self.get_prompt(name)
-        if not prompt:
-            raise NotFoundError(f"Unknown prompt: {name}")
-
-        try:
-            messages = await prompt.render(arguments)
-            return GetPromptResult(description=prompt.description, messages=messages)
-
-        # Pass through PromptErrors as-is
-        except PromptError as e:
-            logger.exception(f"Error rendering prompt {name!r}: {e}")
-            raise e
-
-        # Handle other exceptions
-        except Exception as e:
-            logger.exception(f"Error rendering prompt {name!r}: {e}")
-            if self.mask_error_details:
-                # Mask internal details
-                raise PromptError(f"Error rendering prompt {name!r}")
-            else:
-                # Include original error details
-                raise PromptError(f"Error rendering prompt {name!r}: {e}")
-
-    def has_prompt(self, key: str) -> bool:
-        """Check if a prompt exists."""
-        return key in self._prompts
+        """
+        Internal API for servers: Finds and renders a prompt, respecting the
+        filtered protocol path.
+        """
+        # 1. Check local prompts first. The server will have already applied its filter.
+        if name in self._prompts:
+            prompt = await self.get_prompt(name)
+            if not prompt:
+                raise NotFoundError(f"Unknown prompt: {name}")
+
+            try:
+                messages = await prompt.render(arguments)
+                return GetPromptResult(
+                    description=prompt.description, messages=messages
+                )
+
+            # Pass through PromptErrors as-is
+            except PromptError as e:
+                logger.exception(f"Error rendering prompt {name!r}")
+                raise e
+
+            # Handle other exceptions
+            except Exception as e:
+                logger.exception(f"Error rendering prompt {name!r}")
+                if self.mask_error_details:
+                    # Mask internal details
+                    raise PromptError(f"Error rendering prompt {name!r}") from e
+                else:
+                    # Include original error details
+                    raise PromptError(f"Error rendering prompt {name!r}: {e}") from e
+
+        # 2. Check mounted servers using the filtered protocol path.
+        for mounted in reversed(self._mounted_servers):
+            prompt_key = name
+            if mounted.prefix:
+                if name.startswith(f"{mounted.prefix}_"):
+                    prompt_key = name.removeprefix(f"{mounted.prefix}_")
+                else:
+                    continue
+            try:
+                return await mounted.server._get_prompt(prompt_key, arguments)
+            except NotFoundError:
+                continue
+
+        raise NotFoundError(f"Unknown prompt: {name}")

fastmcp/resources/resource.py

@@ -44,6 +44,22 @@ class Resource(FastMCPComponent, abc.ABC):
         pattern=r"^[a-zA-Z0-9]+/[a-zA-Z0-9\-+.]+$",
     )
 
+    def enable(self) -> None:
+        super().enable()
+        try:
+            context = get_context()
+            context._queue_resource_list_changed()  # type: ignore[private-use]
+        except RuntimeError:
+            pass  # No context available
+
+    def disable(self) -> None:
+        super().disable()
+        try:
+            context = get_context()
+            context._queue_resource_list_changed()  # type: ignore[private-use]
+        except RuntimeError:
+            pass  # No context available
+
     @staticmethod
     def from_function(
         fn: Callable[[], Any],
@@ -101,6 +117,16 @@ class Resource(FastMCPComponent, abc.ABC):
     def __repr__(self) -> str:
         return f"{self.__class__.__name__}(uri={self.uri!r}, name={self.name!r}, description={self.description!r}, tags={self.tags})"
 
+    @property
+    def key(self) -> str:
+        """
+        The key of the component. This is used for internal bookkeeping
+        and may reflect e.g. prefixes or other identifiers. You should not depend on
+        keys having a certain value, as the same tool loaded from different
+        hierarchies of servers may have different keys.
+        """
+        return self._key or str(self.uri)
+
 
 class FunctionResource(Resource):
     """A resource that defers data loading by wrapping a function.
@@ -135,7 +161,7 @@ class FunctionResource(Resource):
             fn=fn,
             uri=uri,
             name=name or fn.__name__,
-            description=description or fn.__doc__,
+            description=description or inspect.getdoc(fn),
             mime_type=mime_type or "text/plain",
             tags=tags or set(),
             enabled=enabled if enabled is not None else True,