fastmcp 2.12.5__py3-none-any.whl → 2.14.0__py3-none-any.whl

fastmcp/experimental/sampling/handlers/openai.py

@@ -21,10 +21,10 @@ try:
         ChatCompletionUserMessageParam,
     )
     from openai.types.shared.chat_model import ChatModel
-except ImportError:
+except ImportError as e:
     raise ImportError(
         "The `openai` package is not installed. Please install `fastmcp[openai]` or add `openai` to your dependencies manually."
-    )
+    ) from e
 
 from typing_extensions import override
 
@@ -164,7 +164,7 @@ class OpenAISamplingHandler(BaseLLMSamplingHandler):
     ) -> ChatModel:
         for model_option in self._iter_models_from_preferences(model_preferences):
             if model_option in get_args(ChatModel):
-                chosen_model: ChatModel = model_option  # pyright: ignore[reportAssignmentType]
+                chosen_model: ChatModel = model_option  # type: ignore[assignment]
                 return chosen_model
 
         return self.default_model

fastmcp/experimental/server/openapi/__init__.py

@@ -1,38 +1,37 @@
-"""OpenAPI server implementation for FastMCP - refactored for better maintainability."""
+"""Deprecated: Import from fastmcp.server.openapi instead."""
 
-# Import from server
-from .server import FastMCPOpenAPI
+import warnings
 
-# Import from routing
-from .routing import (
+from fastmcp.server.openapi import (
+    ComponentFn,
+    DEFAULT_ROUTE_MAPPINGS,
+    FastMCPOpenAPI,
     MCPType,
+    OpenAPIResource,
+    OpenAPIResourceTemplate,
+    OpenAPITool,
     RouteMap,
     RouteMapFn,
-    ComponentFn,
-    DEFAULT_ROUTE_MAPPINGS,
     _determine_route_type,
 )
 
-# Import from components
-from .components import (
-    OpenAPITool,
-    OpenAPIResource,
-    OpenAPIResourceTemplate,
+# Deprecated in 2.14 when OpenAPI support was promoted out of experimental
+warnings.warn(
+    "Importing from fastmcp.experimental.server.openapi is deprecated. "
+    "Import from fastmcp.server.openapi instead.",
+    DeprecationWarning,
+    stacklevel=2,
 )
 
-# Export public symbols - maintaining backward compatibility
 __all__ = [
-    # Server
+    "DEFAULT_ROUTE_MAPPINGS",
+    "ComponentFn",
     "FastMCPOpenAPI",
-    # Routing
     "MCPType",
+    "OpenAPIResource",
+    "OpenAPIResourceTemplate",
+    "OpenAPITool",
     "RouteMap",
     "RouteMapFn",
-    "ComponentFn",
-    "DEFAULT_ROUTE_MAPPINGS",
     "_determine_route_type",
-    # Components
-    "OpenAPITool",
-    "OpenAPIResource",
-    "OpenAPIResourceTemplate",
 ]

fastmcp/experimental/utilities/openapi/__init__.py

@@ -1,68 +1,37 @@
-"""OpenAPI utilities for FastMCP - refactored for better maintainability."""
+"""Deprecated: Import from fastmcp.utilities.openapi instead."""
 
-# Import from models
-from .models import (
+import warnings
+
+from fastmcp.utilities.openapi import (
     HTTPRoute,
     HttpMethod,
-    JsonSchema,
     ParameterInfo,
     ParameterLocation,
     RequestBodyInfo,
     ResponseInfo,
-)
-
-# Import from parser
-from .parser import parse_openapi_to_http_routes
-
-# Import from formatters
-from .formatters import (
-    format_array_parameter,
-    format_deep_object_parameter,
-    format_description_with_responses,
-    format_json_for_description,
+    extract_output_schema_from_responses,
     format_simple_description,
-    generate_example_from_schema,
-)
-
-# Import from schemas
-from .schemas import (
+    parse_openapi_to_http_routes,
     _combine_schemas,
-    extract_output_schema_from_responses,
-    clean_schema_for_display,
-    _make_optional_parameter_nullable,
 )
 
-# Import from json_schema_converter
-from .json_schema_converter import (
-    convert_openapi_schema_to_json_schema,
-    convert_schema_definitions,
+# Deprecated in 2.14 when OpenAPI support was promoted out of experimental
+warnings.warn(
+    "Importing from fastmcp.experimental.utilities.openapi is deprecated. "
+    "Import from fastmcp.utilities.openapi instead.",
+    DeprecationWarning,
+    stacklevel=2,
 )
 
-# Export public symbols - maintaining backward compatibility
 __all__ = [
-    # Models
     "HTTPRoute",
+    "HttpMethod",
     "ParameterInfo",
+    "ParameterLocation",
     "RequestBodyInfo",
     "ResponseInfo",
-    "HttpMethod",
-    "ParameterLocation",
-    "JsonSchema",
-    # Parser
-    "parse_openapi_to_http_routes",
-    # Formatters
-    "format_array_parameter",
-    "format_deep_object_parameter",
-    "format_description_with_responses",
-    "format_json_for_description",
-    "format_simple_description",
-    "generate_example_from_schema",
-    # Schemas
     "_combine_schemas",
     "extract_output_schema_from_responses",
-    "clean_schema_for_display",
-    "_make_optional_parameter_nullable",
-    # JSON Schema Converter
-    "convert_openapi_schema_to_json_schema",
-    "convert_schema_definitions",
+    "format_simple_description",
+    "parse_openapi_to_http_routes",
 ]

fastmcp/mcp_config.py

@@ -101,7 +101,7 @@ class _TransformingMCPServerMixin(FastMCPBaseModel):
             ClientTransport,  # pyright: ignore[reportUnusedImport]
         )
 
-        transport: ClientTransport = super().to_transport()  # pyright: ignore[reportUnknownMemberType, reportAttributeAccessIssue, reportUnknownVariableType]
+        transport: ClientTransport = super().to_transport()  # pyright: ignore[reportUnknownMemberType, reportAttributeAccessIssue, reportUnknownVariableType]  # ty: ignore[unresolved-attribute]
         transport = cast(ClientTransport, transport)
 
         client: Client[ClientTransport] = Client(transport=transport, name=client_name)
@@ -288,9 +288,8 @@ class MCPConfig(BaseModel):
     @classmethod
     def from_file(cls, file_path: Path) -> Self:
         """Load configuration from JSON file."""
-        if file_path.exists():
-            if content := file_path.read_text().strip():
-                return cls.model_validate_json(content)
+        if file_path.exists() and (content := file_path.read_text().strip()):
+            return cls.model_validate_json(content)
 
         raise ValueError(f"No MCP servers defined in the config: {file_path}")
 

fastmcp/prompts/__init__.py

@@ -2,8 +2,8 @@ from .prompt import Prompt, PromptMessage, Message
 from .prompt_manager import PromptManager
 
 __all__ = [
+    "Message",
     "Prompt",
     "PromptManager",
     "PromptMessage",
-    "Message",
 ]

fastmcp/prompts/prompt.py

@@ -4,24 +4,23 @@ 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 Any
+from typing import Annotated, Any
 
 import pydantic_core
-from mcp.types import ContentBlock, PromptMessage, Role, TextContent
+from mcp.types import ContentBlock, Icon, PromptMessage, Role, TextContent
 from mcp.types import Prompt as MCPPrompt
 from mcp.types import PromptArgument as MCPPromptArgument
 from pydantic import Field, TypeAdapter
 
 from fastmcp.exceptions import PromptError
-from fastmcp.server.dependencies import get_context
+from fastmcp.server.dependencies import get_context, without_injected_parameters
+from fastmcp.server.tasks.config import TaskConfig
 from fastmcp.utilities.components import FastMCPComponent
 from fastmcp.utilities.json_schema import compress_schema
 from fastmcp.utilities.logging import get_logger
 from fastmcp.utilities.types import (
     FastMCPBaseModel,
-    find_kwarg_by_type,
     get_cached_typeadapter,
 )
 
@@ -62,7 +61,7 @@ class PromptArgument(FastMCPBaseModel):
     )
 
 
-class Prompt(FastMCPComponent, ABC):
+class Prompt(FastMCPComponent):
     """A prompt template that can be rendered with parameters."""
 
     arguments: list[PromptArgument] | None = Field(
@@ -106,6 +105,7 @@ class Prompt(FastMCPComponent, ABC):
             description=overrides.get("description", self.description),
             arguments=arguments,
             title=overrides.get("title", self.title),
+            icons=overrides.get("icons", self.icons),
             _meta=overrides.get(
                 "_meta", self.get_meta(include_fastmcp_meta=include_fastmcp_meta)
             ),
@@ -117,9 +117,11 @@ class Prompt(FastMCPComponent, ABC):
         name: str | None = None,
         title: str | None = None,
         description: str | None = None,
+        icons: list[Icon] | None = None,
         tags: set[str] | None = None,
         enabled: bool | None = None,
         meta: dict[str, Any] | None = None,
+        task: bool | TaskConfig | None = None,
     ) -> FunctionPrompt:
         """Create a Prompt from a function.
 
@@ -134,24 +136,33 @@ class Prompt(FastMCPComponent, ABC):
             name=name,
             title=title,
             description=description,
+            icons=icons,
             tags=tags,
             enabled=enabled,
             meta=meta,
+            task=task,
         )
 
-    @abstractmethod
     async def render(
         self,
         arguments: dict[str, Any] | None = None,
     ) -> list[PromptMessage]:
-        """Render the prompt with arguments."""
-        raise NotImplementedError("Prompt.render() must be implemented by subclasses")
+        """Render the prompt with arguments.
+
+        This method is not implemented in the base Prompt class and must be
+        implemented by subclasses.
+        """
+        raise NotImplementedError("Subclasses must implement render()")
 
 
 class FunctionPrompt(Prompt):
     """A prompt that is a function."""
 
     fn: Callable[..., PromptResult | Awaitable[PromptResult]]
+    task_config: Annotated[
+        TaskConfig,
+        Field(description="Background task execution configuration (SEP-1686)."),
+    ] = Field(default_factory=lambda: TaskConfig(mode="forbidden"))
 
     @classmethod
     def from_function(
@@ -160,9 +171,11 @@ class FunctionPrompt(Prompt):
         name: str | None = None,
         title: str | None = None,
         description: str | None = None,
+        icons: list[Icon] | None = None,
         tags: set[str] | None = None,
         enabled: bool | None = None,
         meta: dict[str, Any] | None = None,
+        task: bool | TaskConfig | None = None,
     ) -> FunctionPrompt:
         """Create a Prompt from a function.
 
@@ -172,7 +185,6 @@ class FunctionPrompt(Prompt):
         - A dict (converted to a message)
         - A sequence of any of the above
         """
-        from fastmcp.server.context import Context
 
         func_name = name or getattr(fn, "__name__", None) or fn.__class__.__name__
 
@@ -188,25 +200,27 @@ class FunctionPrompt(Prompt):
 
         description = description or inspect.getdoc(fn)
 
+        # Normalize task to TaskConfig and validate
+        if task is None:
+            task_config = TaskConfig(mode="forbidden")
+        elif isinstance(task, bool):
+            task_config = TaskConfig.from_bool(task)
+        else:
+            task_config = task
+        task_config.validate_function(fn, func_name)
+
         # if the fn is a callable class, we need to get the __call__ method from here out
         if not inspect.isroutine(fn):
             fn = fn.__call__
         # if the fn is a staticmethod, we need to work with the underlying function
         if isinstance(fn, staticmethod):
-            fn = fn.__func__
+            fn = fn.__func__  # type: ignore[assignment]
 
-        type_adapter = get_cached_typeadapter(fn)
+        # Wrap fn to handle dependency resolution internally
+        wrapped_fn = without_injected_parameters(fn)
+        type_adapter = get_cached_typeadapter(wrapped_fn)
         parameters = type_adapter.json_schema()
-
-        # Auto-detect context parameter if not provided
-
-        context_kwarg = find_kwarg_by_type(fn, kwarg_type=Context)
-        if context_kwarg:
-            prune_params = [context_kwarg]
-        else:
-            prune_params = None
-
-        parameters = compress_schema(parameters, prune_params=prune_params)
+        parameters = compress_schema(parameters, prune_titles=True)
 
         # Convert parameters to PromptArguments
         arguments: list[PromptArgument] = []
@@ -221,7 +235,6 @@ class FunctionPrompt(Prompt):
                     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:
@@ -253,40 +266,32 @@ class FunctionPrompt(Prompt):
             name=func_name,
             title=title,
             description=description,
+            icons=icons,
             arguments=arguments,
             tags=tags or set(),
             enabled=enabled if enabled is not None else True,
-            fn=fn,
+            fn=wrapped_fn,
             meta=meta,
+            task_config=task_config,
         )
 
     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
+        from fastmcp.server.dependencies import without_injected_parameters
 
-        sig = inspect.signature(self.fn)
+        wrapper_fn = without_injected_parameters(self.fn)
+        sig = inspect.signature(wrapper_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):
+                ) or not isinstance(param_value, str):
                     converted_kwargs[param_name] = param_value
                 else:
                     # Try to convert string argument using type adapter
@@ -307,7 +312,7 @@ class FunctionPrompt(Prompt):
                         raise PromptError(
                             f"Could not convert argument '{param_name}' with value '{param_value}' "
                             f"to expected type {param.annotation}. Error: {e}"
-                        )
+                        ) from e
             else:
                 # Parameter not in function signature, pass as-is
                 converted_kwargs[param_name] = param_value
@@ -319,8 +324,6 @@ class FunctionPrompt(Prompt):
         arguments: dict[str, Any] | None = None,
     ) -> list[PromptMessage]:
         """Render the prompt with arguments."""
-        from fastmcp.server.context import Context
-
         # Validate required arguments
         if self.arguments:
             required = {arg.name for arg in self.arguments if arg.required}
@@ -330,16 +333,14 @@ class FunctionPrompt(Prompt):
                 raise ValueError(f"Missing required arguments: {missing}")
 
         try:
-            # Prepare arguments with context
+            # Prepare arguments
             kwargs = arguments.copy() if arguments else {}
-            context_kwarg = find_kwarg_by_type(self.fn, kwarg_type=Context)
-            if context_kwarg and context_kwarg not in kwargs:
-                kwargs[context_kwarg] = get_context()
 
-            # Convert string arguments to expected types when needed
+            # Convert string arguments to expected types BEFORE validation
             kwargs = self._convert_string_arguments(kwargs)
 
-            # Call function and check if result is a coroutine
+            # self.fn is wrapped by without_injected_parameters which handles
+            # dependency resolution internally
             result = self.fn(**kwargs)
             if inspect.isawaitable(result):
                 result = await result
@@ -369,10 +370,12 @@ class FunctionPrompt(Prompt):
                                 content=TextContent(type="text", text=content),
                             )
                         )
-                except Exception:
-                    raise PromptError("Could not convert prompt result to message.")
+                except Exception as e:
+                    raise PromptError(
+                        "Could not convert prompt result to message."
+                    ) from e
 
             return messages
-        except Exception:
+        except Exception as e:
             logger.exception(f"Error rendering prompt {self.name}")
-            raise PromptError(f"Error rendering prompt {self.name}.")
+            raise PromptError(f"Error rendering prompt {self.name}.") from e

fastmcp/prompts/prompt_manager.py

@@ -2,7 +2,7 @@ from __future__ import annotations as _annotations
 
 import warnings
 from collections.abc import Awaitable, Callable
-from typing import TYPE_CHECKING, Any
+from typing import Any
 
 from mcp import GetPromptResult
 
@@ -12,9 +12,6 @@ from fastmcp.prompts.prompt import FunctionPrompt, Prompt, PromptResult
 from fastmcp.settings import DuplicateBehavior
 from fastmcp.utilities.logging import get_logger
 
-if TYPE_CHECKING:
-    from fastmcp.server.server import MountedServer
-
 logger = get_logger(__name__)
 
 
@@ -27,7 +24,6 @@ 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
@@ -42,52 +38,6 @@ class PromptManager:
 
         self.duplicate_behavior = duplicate_behavior
 
-    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.model_copy(
-                            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 server: {mounted.server.name!r}, mounted at: {mounted.prefix!r}: {e}"
-                )
-                if settings.mounted_components_raise_on_load_error:
-                    raise
-                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()
@@ -102,16 +52,9 @@ class PromptManager:
 
     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.
+        Gets the complete, unfiltered inventory of local prompts.
         """
-        prompts_dict = await self._load_prompts(via_server=True)
-        return list(prompts_dict.values())
+        return dict(self._prompts)
 
     def add_prompt_from_fn(
         self,
@@ -160,44 +103,16 @@ class PromptManager:
         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}")
+        prompt = await self.get_prompt(name)
+        try:
+            messages = await prompt.render(arguments)
+            return GetPromptResult(description=prompt.description, messages=messages)
+        except PromptError as e:
+            logger.exception(f"Error rendering prompt {name!r}")
+            raise e
+        except Exception as e:
+            logger.exception(f"Error rendering prompt {name!r}")
+            if self.mask_error_details:
+                raise PromptError(f"Error rendering prompt {name!r}") from e
+            else:
+                raise PromptError(f"Error rendering prompt {name!r}: {e}") from e

fastmcp/resources/__init__.py

@@ -10,13 +10,13 @@ from .types import (
 from .resource_manager import ResourceManager
 
 __all__ = [
-    "Resource",
-    "TextResource",
     "BinaryResource",
-    "FunctionResource",
+    "DirectoryResource",
     "FileResource",
+    "FunctionResource",
     "HttpResource",
-    "DirectoryResource",
-    "ResourceTemplate",
+    "Resource",
     "ResourceManager",
+    "ResourceTemplate",
+    "TextResource",
 ]