fastmcp 2.2.7__py3-none-any.whl → 2.2.8__py3-none-any.whl

fastmcp/client/client.py

@@ -286,7 +286,7 @@ class Client:
 
     async def get_prompt(
         self, name: str, arguments: dict[str, str] | None = None
-    ) -> list[mcp.types.PromptMessage]:
+    ) -> mcp.types.GetPromptResult:
         """Retrieve a rendered prompt message list from the server.
 
         Args:
@@ -294,13 +294,14 @@ class Client:
             arguments (dict[str, str] | None, optional): Arguments to pass to the prompt. Defaults to None.
 
         Returns:
-            list[mcp.types.PromptMessage]: A list of prompt messages.
+            mcp.types.GetPromptResult: The complete response object from the protocol,
+                containing the prompt messages and any additional metadata.
 
         Raises:
             RuntimeError: If called while the client is not connected.
         """
         result = await self.get_prompt_mcp(name=name, arguments=arguments)
-        return result.messages
+        return result
 
     # --- Completion ---
 

fastmcp/prompts/__init__.py

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

fastmcp/prompts/prompt.py

@@ -4,17 +4,19 @@ from __future__ import annotations as _annotations
 
 import inspect
 from collections.abc import Awaitable, Callable, Sequence
-from typing import TYPE_CHECKING, Annotated, Any, Literal
+from typing import TYPE_CHECKING, Annotated, Any
 
 import pydantic_core
-from mcp.types import EmbeddedResource, ImageContent, TextContent
+from mcp.types import EmbeddedResource, ImageContent, PromptMessage, Role, 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.json_schema import prune_params
 from fastmcp.utilities.types import (
     _convert_set_defaults,
-    is_class_member_of_type,
+    find_kwarg_by_type,
+    get_cached_typeadapter,
 )
 
 if TYPE_CHECKING:
@@ -26,32 +28,24 @@ if TYPE_CHECKING:
 CONTENT_TYPES = TextContent | ImageContent | EmbeddedResource
 
 
-class Message(BaseModel):
-    """Base class for all prompt messages."""
+def Message(
+    content: str | CONTENT_TYPES, role: Role | None = None, **kwargs: Any
+) -> PromptMessage:
+    """A user-friendly constructor for PromptMessage."""
+    if isinstance(content, str):
+        content = TextContent(type="text", text=content)
+    if role is None:
+        role = "user"
+    return PromptMessage(content=content, role=role, **kwargs)
 
-    role: Literal["user", "assistant"]
-    content: CONTENT_TYPES
 
-    def __init__(self, content: str | CONTENT_TYPES, **kwargs: Any):
-        if isinstance(content, str):
-            content = TextContent(type="text", text=content)
-        super().__init__(content=content, **kwargs)
-
-
-def UserMessage(content: str | CONTENT_TYPES, **kwargs: Any) -> Message:
-    """A message from the user."""
-    return Message(content=content, role="user", **kwargs)
-
-
-def AssistantMessage(content: str | CONTENT_TYPES, **kwargs: Any) -> Message:
-    """A message from the assistant."""
-    return Message(content=content, role="assistant", **kwargs)
-
-
-message_validator = TypeAdapter[Message](Message)
+message_validator = TypeAdapter[PromptMessage](PromptMessage)
 
 SyncPromptResult = (
-    str | Message | dict[str, Any] | Sequence[str | Message | dict[str, Any]]
+    str
+    | PromptMessage
+    | dict[str, Any]
+    | Sequence[str | PromptMessage | dict[str, Any]]
 )
 PromptResult = SyncPromptResult | Awaitable[SyncPromptResult]
 
@@ -109,35 +103,32 @@ class Prompt(BaseModel):
 
         if func_name == "<lambda>":
             raise ValueError("You must provide a name for lambda functions")
+            # Reject functions with *args or **kwargs
+        sig = inspect.signature(fn)
+        for param in sig.parameters.values():
+            if param.kind == inspect.Parameter.VAR_POSITIONAL:
+                raise ValueError("Functions with *args are not supported as prompts")
+            if param.kind == inspect.Parameter.VAR_KEYWORD:
+                raise ValueError("Functions with **kwargs are not supported as prompts")
+
+        type_adapter = get_cached_typeadapter(fn)
+        parameters = type_adapter.json_schema()
 
         # Auto-detect context parameter if not provided
         if context_kwarg is None:
-            if inspect.ismethod(fn) and hasattr(fn, "__func__"):
-                sig = inspect.signature(fn.__func__)
-            else:
-                sig = inspect.signature(fn)
-            for param_name, param in sig.parameters.items():
-                if is_class_member_of_type(param.annotation, Context):
-                    context_kwarg = param_name
-                    break
-
-        # Get schema from TypeAdapter - will fail if function isn't properly typed
-        parameters = TypeAdapter(fn).json_schema()
+            context_kwarg = find_kwarg_by_type(fn, kwarg_type=Context)
+        if context_kwarg:
+            parameters = prune_params(parameters, params=[context_kwarg])
 
         # Convert parameters to PromptArguments
         arguments: list[PromptArgument] = []
         if "properties" in parameters:
             for param_name, param in parameters["properties"].items():
-                # Skip context parameter
-                if param_name == context_kwarg:
-                    continue
-
-                required = param_name in parameters.get("required", [])
                 arguments.append(
                     PromptArgument(
                         name=param_name,
                         description=param.get("description"),
-                        required=required,
+                        required=param_name in parameters.get("required", []),
                     )
                 )
 
@@ -157,7 +148,7 @@ class Prompt(BaseModel):
         self,
         arguments: dict[str, Any] | None = None,
         context: Context[ServerSessionT, LifespanContextT] | None = None,
-    ) -> list[Message]:
+    ) -> list[PromptMessage]:
         """Render the prompt with arguments."""
         # Validate required arguments
         if self.arguments:
@@ -183,21 +174,28 @@ class Prompt(BaseModel):
                 result = [result]
 
             # Convert result to messages
-            messages: list[Message] = []
-            for msg in result:  # type: ignore[reportUnknownVariableType]
+            messages: list[PromptMessage] = []
+            for msg in result:
                 try:
-                    if isinstance(msg, Message):
+                    if isinstance(msg, PromptMessage):
                         messages.append(msg)
-                    elif isinstance(msg, dict):
-                        messages.append(message_validator.validate_python(msg))
                     elif isinstance(msg, str):
-                        content = TextContent(type="text", text=msg)
-                        messages.append(Message(role="user", content=content))
+                        messages.append(
+                            PromptMessage(
+                                role="user",
+                                content=TextContent(type="text", text=msg),
+                            )
+                        )
                     else:
                         content = pydantic_core.to_json(
                             msg, fallback=str, indent=2
                         ).decode()
-                        messages.append(Message(role="user", content=content))
+                        messages.append(
+                            PromptMessage(
+                                role="user",
+                                content=TextContent(type="text", text=content),
+                            )
+                        )
                 except Exception:
                     raise ValueError(
                         f"Could not convert prompt result to message: {msg}"

fastmcp/prompts/prompt_manager.py

@@ -5,8 +5,10 @@ from __future__ import annotations as _annotations
 from collections.abc import Awaitable, Callable
 from typing import TYPE_CHECKING, Any
 
+from mcp import GetPromptResult
+
 from fastmcp.exceptions import NotFoundError
-from fastmcp.prompts.prompt import Message, Prompt, PromptResult
+from fastmcp.prompts.prompt import Prompt, PromptResult
 from fastmcp.settings import DuplicateBehavior
 from fastmcp.utilities.logging import get_logger
 
@@ -81,13 +83,18 @@ class PromptManager:
         name: str,
         arguments: dict[str, Any] | None = None,
         context: Context[ServerSessionT, LifespanContextT] | None = None,
-    ) -> list[Message]:
+    ) -> GetPromptResult:
         """Render a prompt by name with arguments."""
         prompt = self.get_prompt(name)
         if not prompt:
             raise NotFoundError(f"Unknown prompt: {name}")
 
-        return await prompt.render(arguments, context=context)
+        messages = await prompt.render(arguments, context=context)
+
+        return GetPromptResult(
+            description=prompt.description,
+            messages=messages,
+        )
 
     def has_prompt(self, key: str) -> bool:
         """Check if a prompt exists."""

fastmcp/resources/template.py

@@ -22,7 +22,7 @@ from pydantic import (
 from fastmcp.resources.types import FunctionResource, Resource
 from fastmcp.utilities.types import (
     _convert_set_defaults,
-    is_class_member_of_type,
+    find_kwarg_by_type,
 )
 
 if TYPE_CHECKING:
@@ -109,23 +109,25 @@ class ResourceTemplate(BaseModel):
         if func_name == "<lambda>":
             raise ValueError("You must provide a name for lambda functions")
 
+        # Reject functions with *args
+        # (**kwargs is allowed because the URI will define the parameter names)
+        sig = inspect.signature(fn)
+        for param in sig.parameters.values():
+            if param.kind == inspect.Parameter.VAR_POSITIONAL:
+                raise ValueError(
+                    "Functions with *args are not supported as resource templates"
+                )
+
         # Auto-detect context parameter if not provided
         if context_kwarg is None:
-            if inspect.ismethod(fn) and hasattr(fn, "__func__"):
-                sig = inspect.signature(fn.__func__)
-            else:
-                sig = inspect.signature(fn)
-            for param_name, param in sig.parameters.items():
-                if is_class_member_of_type(param.annotation, Context):
-                    context_kwarg = param_name
-                    break
+            context_kwarg = find_kwarg_by_type(fn, kwarg_type=Context)
 
         # Validate that URI params match function params
         uri_params = set(re.findall(r"{(\w+)(?:\*)?}", uri_template))
         if not uri_params:
             raise ValueError("URI template must contain at least one parameter")
 
-        func_params = set(inspect.signature(fn).parameters.keys())
+        func_params = set(sig.parameters.keys())
         if context_kwarg:
             func_params.discard(context_kwarg)
 
@@ -133,20 +135,26 @@ class ResourceTemplate(BaseModel):
         required_params = {
             p
             for p in func_params
-            if inspect.signature(fn).parameters[p].default is inspect.Parameter.empty
+            if sig.parameters[p].default is inspect.Parameter.empty
+            and sig.parameters[p].kind != inspect.Parameter.VAR_KEYWORD
+            and p != context_kwarg
         }
-        if context_kwarg and context_kwarg in required_params:
-            required_params.discard(context_kwarg)
 
+        # Check if required parameters are a subset of the URI parameters
         if not required_params.issubset(uri_params):
             raise ValueError(
-                f"URI parameters {uri_params} must be a subset of the required function arguments: {required_params}"
+                f"Required function arguments {required_params} must be a subset of the URI parameters {uri_params}"
             )
 
-        if not uri_params.issubset(func_params):
-            raise ValueError(
-                f"URI parameters {uri_params} must be a subset of the function arguments: {func_params}"
-            )
+        # Check if the URI parameters are a subset of the function parameters (skip if **kwargs present)
+        if not any(
+            param.kind == inspect.Parameter.VAR_KEYWORD
+            for param in sig.parameters.values()
+        ):
+            if not uri_params.issubset(func_params):
+                raise ValueError(
+                    f"URI parameters {uri_params} must be a subset of the function arguments: {func_params}"
+                )
 
         # Get schema from TypeAdapter - will fail if function isn't properly typed
         parameters = TypeAdapter(fn).json_schema()

fastmcp/server/openapi.py

@@ -18,7 +18,6 @@ from fastmcp.resources import Resource, ResourceTemplate
 from fastmcp.server.server import FastMCP
 from fastmcp.tools.tool import Tool, _convert_to_content
 from fastmcp.utilities import openapi
-from fastmcp.utilities.func_metadata import func_metadata
 from fastmcp.utilities.logging import get_logger
 from fastmcp.utilities.openapi import (
     _combine_schemas,
@@ -123,8 +122,6 @@ class OpenAPITool(Tool):
         name: str,
         description: str,
         parameters: dict[str, Any],
-        fn_metadata: Any,
-        is_async: bool = True,
         tags: set[str] = set(),
         timeout: float | None = None,
         annotations: ToolAnnotations | None = None,
@@ -135,8 +132,6 @@ class OpenAPITool(Tool):
             description=description,
             parameters=parameters,
             fn=self._execute_request,  # We'll use an instance method instead of a global function
-            fn_metadata=fn_metadata,
-            is_async=is_async,
             context_kwarg="context",  # Default context keyword argument
             tags=tags,
             annotations=annotations,
@@ -553,8 +548,6 @@ class FastMCPOpenAPI(FastMCP):
             name=tool_name,
             description=enhanced_description,
             parameters=combined_schema,
-            fn_metadata=func_metadata(_openapi_passthrough),
-            is_async=True,
             tags=set(route.tags or []),
             timeout=self._timeout,
         )

fastmcp/server/proxy.py

@@ -19,12 +19,11 @@ from pydantic.networks import AnyUrl
 
 from fastmcp.client import Client
 from fastmcp.exceptions import NotFoundError
-from fastmcp.prompts import Message, Prompt
+from fastmcp.prompts import Prompt, PromptMessage
 from fastmcp.resources import Resource, ResourceTemplate
 from fastmcp.server.context import Context
 from fastmcp.server.server import FastMCP
 from fastmcp.tools.tool import Tool
-from fastmcp.utilities.func_metadata import func_metadata
 from fastmcp.utilities.logging import get_logger
 
 if TYPE_CHECKING:
@@ -53,8 +52,6 @@ class ProxyTool(Tool):
             description=tool.description,
             parameters=tool.inputSchema,
             fn=_proxy_passthrough,
-            fn_metadata=func_metadata(_proxy_passthrough),
-            is_async=True,
         )
 
     async def run(
@@ -178,10 +175,10 @@ class ProxyPrompt(Prompt):
         self,
         arguments: dict[str, Any],
         context: Context[ServerSessionT, LifespanContextT] | None = None,
-    ) -> list[Message]:
+    ) -> list[PromptMessage]:
         async with self._client:
             result = await self._client.get_prompt(self.name, arguments)
-        return [Message(role=m.role, content=m.content) for m in result]
+        return result.messages
 
 
 class FastMCPProxy(FastMCP):
@@ -294,4 +291,4 @@ class FastMCPProxy(FastMCP):
         except NotFoundError:
             async with self.client:
                 result = await self.client.get_prompt(name, arguments)
-            return GetPromptResult(messages=result)
+            return result

fastmcp/server/server.py

@@ -32,7 +32,6 @@ from mcp.types import (
     EmbeddedResource,
     GetPromptResult,
     ImageContent,
-    PromptMessage,
     TextContent,
     ToolAnnotations,
 )
@@ -504,15 +503,10 @@ class FastMCP(Generic[LifespanResultT]):
         """
         if self._prompt_manager.has_prompt(name):
             context = self.get_context()
-            messages = await self._prompt_manager.render_prompt(
+            prompt_result = await self._prompt_manager.render_prompt(
                 name, arguments=arguments or {}, context=context
             )
-
-            return GetPromptResult(
-                messages=[
-                    PromptMessage(role=m.role, content=m.content) for m in messages
-                ]
-            )
+            return prompt_result
         else:
             for server in self._mounted_servers.values():
                 if server.match_prompt(name):
@@ -826,16 +820,21 @@ class FastMCP(Generic[LifespanResultT]):
         host: str | None = None,
         port: int | None = None,
         log_level: str | None = None,
+        uvicorn_config: dict | None = None,
     ) -> None:
         """Run the server using SSE transport."""
-        app = self.sse_app()
-        app = RequestMiddleware(app)
+        uvicorn_config = uvicorn_config or {}
+        # the SSE app hangs even when a signal is sent, so we disable the timeout to make it possible to close immediately.
+        # see https://github.com/jlowin/fastmcp/issues/296
+        uvicorn_config.setdefault("timeout_graceful_shutdown", 0)
+        app = RequestMiddleware(self.sse_app())
 
         config = uvicorn.Config(
             app,
             host=host or self.settings.host,
             port=port or self.settings.port,
             log_level=log_level or self.settings.log_level.lower(),
+            **uvicorn_config,
         )
         server = uvicorn.Server(config)
         await server.serve()

fastmcp/tools/tool.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import inspect
+import json
 from collections.abc import Callable
 from typing import TYPE_CHECKING, Annotated, Any
 
@@ -10,11 +11,13 @@ from mcp.types import Tool as MCPTool
 from pydantic import BaseModel, BeforeValidator, Field
 
 from fastmcp.exceptions import ToolError
-from fastmcp.utilities.func_metadata import FuncMetadata, func_metadata
+from fastmcp.utilities.json_schema import prune_params
+from fastmcp.utilities.logging import get_logger
 from fastmcp.utilities.types import (
     Image,
     _convert_set_defaults,
-    is_class_member_of_type,
+    find_kwarg_by_type,
+    get_cached_typeadapter,
 )
 
 if TYPE_CHECKING:
@@ -23,6 +26,12 @@ if TYPE_CHECKING:
 
     from fastmcp.server import Context
 
+logger = get_logger(__name__)
+
+
+def default_serializer(data: Any) -> str:
+    return pydantic_core.to_json(data, fallback=str, indent=2).decode()
+
 
 class Tool(BaseModel):
     """Internal tool registration info."""
@@ -31,11 +40,6 @@ class Tool(BaseModel):
     name: str = Field(description="Name of the tool")
     description: str = Field(description="Description of what the tool does")
     parameters: dict[str, Any] = Field(description="JSON schema for tool parameters")
-    fn_metadata: FuncMetadata = Field(
-        description="Metadata about the function including a pydantic model for tool"
-        " arguments"
-    )
-    is_async: bool = Field(description="Whether the tool is async")
     context_kwarg: str | None = Field(
         None, description="Name of the kwarg that should receive context"
     )
@@ -63,44 +67,34 @@ class Tool(BaseModel):
         """Create a Tool from a function."""
         from fastmcp import Context
 
+        # Reject functions with *args or **kwargs
+        sig = inspect.signature(fn)
+        for param in sig.parameters.values():
+            if param.kind == inspect.Parameter.VAR_POSITIONAL:
+                raise ValueError("Functions with *args are not supported as tools")
+            if param.kind == inspect.Parameter.VAR_KEYWORD:
+                raise ValueError("Functions with **kwargs are not supported as tools")
+
         func_name = name or fn.__name__
 
         if func_name == "<lambda>":
             raise ValueError("You must provide a name for lambda functions")
 
         func_doc = description or fn.__doc__ or ""
-        is_async = inspect.iscoroutinefunction(fn)
+
+        type_adapter = get_cached_typeadapter(fn)
+        schema = type_adapter.json_schema()
 
         if context_kwarg is None:
-            if inspect.ismethod(fn) and hasattr(fn, "__func__"):
-                sig = inspect.signature(fn.__func__)
-            else:
-                sig = inspect.signature(fn)
-            for param_name, param in sig.parameters.items():
-                if is_class_member_of_type(param.annotation, Context):
-                    context_kwarg = param_name
-                    break
-
-        # Use callable typing to ensure fn is treated as a callable despite being a classmethod
-        fn_callable: Callable[..., Any] = fn
-        func_arg_metadata = func_metadata(
-            fn_callable,
-            skip_names=[context_kwarg] if context_kwarg is not None else [],
-        )
-        try:
-            parameters = func_arg_metadata.arg_model.model_json_schema()
-        except Exception as e:
-            raise TypeError(
-                f'Unable to parse parameters for function "{fn.__name__}": {e}'
-            ) from e
+            context_kwarg = find_kwarg_by_type(fn, kwarg_type=Context)
+        if context_kwarg:
+            schema = prune_params(schema, params=[context_kwarg])
 
         return cls(
-            fn=fn_callable,
+            fn=fn,
             name=func_name,
             description=func_doc,
-            parameters=parameters,
-            fn_metadata=func_arg_metadata,
-            is_async=is_async,
+            parameters=schema,
             context_kwarg=context_kwarg,
             tags=tags or set(),
             annotations=annotations,
@@ -114,17 +108,30 @@ class Tool(BaseModel):
     ) -> list[TextContent | ImageContent | EmbeddedResource]:
         """Run the tool with arguments."""
         try:
-            pass_args = (
-                {self.context_kwarg: context}
-                if self.context_kwarg is not None
-                else None
-            )
-            result = await self.fn_metadata.call_fn_with_arg_validation(
-                fn=self.fn,
-                fn_is_async=self.is_async,
-                arguments_to_validate=arguments,
-                arguments_to_pass_directly=pass_args,
+            injected_args = (
+                {self.context_kwarg: context} if self.context_kwarg is not None else {}
             )
+
+            parsed_args = arguments.copy()
+
+            # Pre-parse data from JSON in order to handle cases like `["a", "b", "c"]`
+            # being passed in as JSON inside a string rather than an actual list.
+            #
+            # Claude desktop is prone to this - in fact it seems incapable of NOT doing
+            # this. For sub-models, it tends to pass dicts (JSON objects) as JSON strings,
+            # which can be pre-parsed here.
+            for param_name in self.parameters["properties"]:
+                if isinstance(parsed_args.get(param_name, None), str):
+                    try:
+                        parsed_args[param_name] = json.loads(parsed_args[param_name])
+                    except json.JSONDecodeError:
+                        pass
+
+            type_adapter = get_cached_typeadapter(self.fn)
+            result = type_adapter.validate_python(parsed_args | injected_args)
+            if inspect.isawaitable(result):
+                result = await result
+
             return _convert_to_content(result, serializer=self.serializer)
         except Exception as e:
             raise ToolError(f"Error executing tool {self.name}: {e}") from e
@@ -182,9 +189,17 @@ def _convert_to_content(
         return other_content + mcp_types
 
     if not isinstance(result, str):
-        if serializer is not None:
-            result = serializer(result)
+        if serializer is None:
+            result = default_serializer(result)
         else:
-            result = pydantic_core.to_json(result, fallback=str, indent=2).decode()
+            try:
+                result = serializer(result)
+            except Exception as e:
+                logger.warning(
+                    "Error serializing tool result: %s",
+                    e,
+                    exc_info=True,
+                )
+                result = default_serializer(result)
 
     return [TextContent(type="text", text=result)]

fastmcp/utilities/json_schema.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+import copy
+from collections.abc import Mapping, Sequence
+
+
+def _prune_param(schema: dict, param: str) -> dict:
+    """Return a new schema with *param* removed from `properties`, `required`,
+    and (if no longer referenced) `$defs`.
+    """
+
+    # ── 1. drop from properties/required ──────────────────────────────
+    props = schema.get("properties", {})
+    removed = props.pop(param, None)
+    if removed is None:  # nothing to do
+        return schema
+    # Keep empty properties object rather than removing it entirely
+    schema["properties"] = props
+    if param in schema.get("required", []):
+        schema["required"].remove(param)
+        if not schema["required"]:
+            schema.pop("required")
+
+    # ── 2. collect all remaining local $ref targets ───────────────────
+    used_defs: set[str] = set()
+
+    def walk(node: object) -> None:  # depth-first traversal
+        if isinstance(node, Mapping):
+            ref = node.get("$ref")
+            if isinstance(ref, str) and ref.startswith("#/$defs/"):
+                used_defs.add(ref.split("/")[-1])
+            for v in node.values():
+                walk(v)
+        elif isinstance(node, Sequence) and not isinstance(node, str | bytes):
+            for v in node:
+                walk(v)
+
+    walk(schema)
+
+    # ── 3. remove orphaned definitions ────────────────────────────────
+    defs = schema.get("$defs", {})
+    for def_name in list(defs):
+        if def_name not in used_defs:
+            defs.pop(def_name)
+    if not defs:
+        schema.pop("$defs", None)
+
+    return schema
+
+
+def prune_params(schema: dict, params: list[str]) -> dict:
+    """
+    Remove the given parameters from the schema.
+
+    """
+    schema = copy.deepcopy(schema)
+    for param in params:
+        schema = _prune_param(schema, param=param)
+    return schema