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

fastmcp/client/transports.py

@@ -6,7 +6,7 @@ import os
 import shutil
 import sys
 import warnings
-from collections.abc import AsyncIterator
+from collections.abc import AsyncIterator, Callable
 from pathlib import Path
 from typing import Any, Literal, TextIO, TypeVar, cast, overload
 
@@ -36,6 +36,7 @@ from fastmcp.client.auth.oauth import OAuth
 from fastmcp.mcp_config import MCPConfig, infer_transport_type_from_url
 from fastmcp.server.dependencies import get_http_headers
 from fastmcp.server.server import FastMCP
+from fastmcp.server.tasks.capabilities import get_task_capabilities
 from fastmcp.utilities.logging import get_logger
 from fastmcp.utilities.mcp_server_config.v1.environments.uv import UVEnvironment
 
@@ -254,6 +255,8 @@ class StreamableHttpTransport(ClientTransport):
             sse_read_timeout = datetime.timedelta(seconds=float(sse_read_timeout))
         self.sse_read_timeout = sse_read_timeout
 
+        self._get_session_id_cb: Callable[[], str | None] | None = None
+
     def _set_auth(self, auth: httpx.Auth | Literal["oauth"] | str | None):
         if auth == "oauth":
             auth = OAuth(self.url, httpx_client_factory=self.httpx_client_factory)
@@ -287,12 +290,25 @@ class StreamableHttpTransport(ClientTransport):
             auth=self.auth,
             **client_kwargs,
         ) as transport:
-            read_stream, write_stream, _ = transport
+            read_stream, write_stream, get_session_id = transport
+            self._get_session_id_cb = get_session_id
             async with ClientSession(
                 read_stream, write_stream, **session_kwargs
             ) as session:
                 yield session
 
+    def get_session_id(self) -> str | None:
+        if self._get_session_id_cb:
+            try:
+                return self._get_session_id_cb()
+            except Exception:
+                return None
+        return None
+
+    async def close(self):
+        # Reset the session id callback
+        self._get_session_id_cb = None
+
     def __repr__(self) -> str:
         return f"<StreamableHttpTransport(url='{self.url}')>"
 
@@ -375,7 +391,8 @@ class StdioTransport(ClientTransport):
                 env=self.env,
                 cwd=self.cwd,
                 log_file=self.log_file,
-                session_kwargs=session_kwargs,
+                # TODO(ty): remove when ty supports Unpack[TypedDict] inference
+                session_kwargs=session_kwargs,  # type: ignore[arg-type]
                 ready_event=self._ready_event,
                 stop_event=self._stop_event,
                 session_future=session_future,
@@ -849,16 +866,25 @@ class FastMCPTransport(ClientTransport):
             client_read, client_write = client_streams
             server_read, server_write = server_streams
 
-            # Create a cancel scope for the server task
+            # Capture exceptions to re-raise after task group cleanup.
+            # anyio task groups can suppress exceptions when cancel_scope.cancel()
+            # is called during cleanup, so we capture and re-raise manually.
+            exception_to_raise: BaseException | None = None
+
             async with (
                 anyio.create_task_group() as tg,
                 _enter_server_lifespan(server=self.server),
             ):
+                # Build experimental capabilities
+                experimental_capabilities = get_task_capabilities()
+
                 tg.start_soon(
                     lambda: self.server._mcp_server.run(
                         server_read,
                         server_write,
-                        self.server._mcp_server.create_initialization_options(),
+                        self.server._mcp_server.create_initialization_options(
+                            experimental_capabilities=experimental_capabilities
+                        ),
                         raise_exceptions=self.raise_exceptions,
                     )
                 )
@@ -870,9 +896,15 @@ class FastMCPTransport(ClientTransport):
                         **session_kwargs,
                     ) as client_session:
                         yield client_session
+                except BaseException as e:
+                    exception_to_raise = e
                 finally:
                     tg.cancel_scope.cancel()
 
+            # Re-raise after task group has exited cleanly
+            if exception_to_raise is not None:
+                raise exception_to_raise
+
     def __repr__(self) -> str:
         return f"<FastMCPTransport(server='{self.server.name}')>"
 

fastmcp/contrib/component_manager/component_service.py

@@ -105,16 +105,8 @@ class ComponentService:
         # 2. Check mounted servers using the filtered protocol path.
         for mounted in reversed(self._server._mounted_servers):
             if mounted.prefix:
-                if has_resource_prefix(
-                    key,
-                    mounted.prefix,
-                    mounted.resource_prefix_format,
-                ):
-                    key = remove_resource_prefix(
-                        key,
-                        mounted.prefix,
-                        mounted.resource_prefix_format,
-                    )
+                if has_resource_prefix(key, mounted.prefix):
+                    key = remove_resource_prefix(key, mounted.prefix)
                     mounted_service = ComponentService(mounted.server)
                     mounted_resource: (
                         Resource | ResourceTemplate
@@ -148,16 +140,8 @@ class ComponentService:
         # 2. Check mounted servers using the filtered protocol path.
         for mounted in reversed(self._server._mounted_servers):
             if mounted.prefix:
-                if has_resource_prefix(
-                    key,
-                    mounted.prefix,
-                    mounted.resource_prefix_format,
-                ):
-                    key = remove_resource_prefix(
-                        key,
-                        mounted.prefix,
-                        mounted.resource_prefix_format,
-                    )
+                if has_resource_prefix(key, mounted.prefix):
+                    key = remove_resource_prefix(key, mounted.prefix)
                     mounted_service = ComponentService(mounted.server)
                     mounted_resource: (
                         Resource | ResourceTemplate

fastmcp/dependencies.py

@@ -0,0 +1,25 @@
+"""Dependency injection exports for FastMCP.
+
+This module re-exports dependency injection symbols from Docket and FastMCP
+to provide a clean, centralized import location for all dependency-related
+functionality.
+"""
+
+from docket import Depends
+
+from fastmcp.server.dependencies import (
+    CurrentContext,
+    CurrentDocket,
+    CurrentFastMCP,
+    CurrentWorker,
+    Progress,
+)
+
+__all__ = [
+    "CurrentContext",
+    "CurrentDocket",
+    "CurrentFastMCP",
+    "CurrentWorker",
+    "Depends",
+    "Progress",
+]

fastmcp/experimental/sampling/handlers/openai.py

@@ -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,26 +1,28 @@
-"""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__ = [
     "DEFAULT_ROUTE_MAPPINGS",
     "ComponentFn",

fastmcp/experimental/utilities/openapi/__init__.py

@@ -1,63 +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__ = [
     "HTTPRoute",
     "HttpMethod",
-    "JsonSchema",
     "ParameterInfo",
     "ParameterLocation",
     "RequestBodyInfo",
     "ResponseInfo",
     "_combine_schemas",
-    "_make_optional_parameter_nullable",
-    "clean_schema_for_display",
-    "convert_openapi_schema_to_json_schema",
-    "convert_schema_definitions",
     "extract_output_schema_from_responses",
-    "format_array_parameter",
-    "format_deep_object_parameter",
-    "format_description_with_responses",
-    "format_json_for_description",
     "format_simple_description",
-    "generate_example_from_schema",
     "parse_openapi_to_http_routes",
 ]

fastmcp/prompts/prompt.py

@@ -5,7 +5,7 @@ from __future__ import annotations as _annotations
 import inspect
 import json
 from collections.abc import Awaitable, Callable, Sequence
-from typing import Any
+from typing import Annotated, Any
 
 import pydantic_core
 from mcp.types import ContentBlock, Icon, PromptMessage, Role, TextContent
@@ -14,13 +14,13 @@ 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,
 )
 
@@ -121,6 +121,7 @@ class Prompt(FastMCPComponent):
         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.
 
@@ -139,6 +140,7 @@ class Prompt(FastMCPComponent):
             tags=tags,
             enabled=enabled,
             meta=meta,
+            task=task,
         )
 
     async def render(
@@ -157,6 +159,10 @@ 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(
@@ -169,6 +175,7 @@ class FunctionPrompt(Prompt):
         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.
 
@@ -178,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__
 
@@ -194,22 +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)
-        prune_params = [context_kwarg] if context_kwarg else None
-
-        parameters = compress_schema(parameters, prune_params=prune_params)
+        parameters = compress_schema(parameters, prune_titles=True)
 
         # Convert parameters to PromptArguments
         arguments: list[PromptArgument] = []
@@ -224,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:
@@ -260,29 +270,23 @@ class FunctionPrompt(Prompt):
             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
@@ -320,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}
@@ -331,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

fastmcp/resources/resource.py

@@ -19,10 +19,10 @@ from pydantic import (
 )
 from typing_extensions import Self
 
-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.types import (
-    find_kwarg_by_type,
     get_fn_name,
 )
 
@@ -42,7 +42,6 @@ class Resource(FastMCPComponent):
     mime_type: str = Field(
         default="text/plain",
         description="MIME type of the resource content",
-        pattern=r"^[a-zA-Z0-9]+/[a-zA-Z0-9\-+.]+$",
     )
     annotations: Annotated[
         Annotations | None,
@@ -78,6 +77,7 @@ class Resource(FastMCPComponent):
         enabled: bool | None = None,
         annotations: Annotations | None = None,
         meta: dict[str, Any] | None = None,
+        task: bool | TaskConfig | None = None,
     ) -> FunctionResource:
         return FunctionResource.from_function(
             fn=fn,
@@ -91,6 +91,7 @@ class Resource(FastMCPComponent):
             enabled=enabled,
             annotations=annotations,
             meta=meta,
+            task=task,
         )
 
     @field_validator("mime_type", mode="before")
@@ -169,6 +170,10 @@ class FunctionResource(Resource):
     """
 
     fn: Callable[..., Any]
+    task_config: Annotated[
+        TaskConfig,
+        Field(description="Background task execution configuration (SEP-1686)."),
+    ] = Field(default_factory=lambda: TaskConfig(mode="forbidden"))
 
     @classmethod
     def from_function(
@@ -184,12 +189,28 @@ class FunctionResource(Resource):
         enabled: bool | None = None,
         annotations: Annotations | None = None,
         meta: dict[str, Any] | None = None,
+        task: bool | TaskConfig | None = None,
     ) -> FunctionResource:
         """Create a FunctionResource from a function."""
         if isinstance(uri, str):
             uri = AnyUrl(uri)
+
+        func_name = name or get_fn_name(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)
+
+        # Wrap fn to handle dependency resolution internally
+        wrapped_fn = without_injected_parameters(fn)
+
         return cls(
-            fn=fn,
+            fn=wrapped_fn,
             uri=uri,
             name=name or get_fn_name(fn),
             title=title,
@@ -200,18 +221,14 @@ class FunctionResource(Resource):
             enabled=enabled if enabled is not None else True,
             annotations=annotations,
             meta=meta,
+            task_config=task_config,
         )
 
     async def read(self) -> str | bytes:
         """Read the resource by calling the wrapped function."""
-        from fastmcp.server.context import Context
-
-        kwargs = {}
-        context_kwarg = find_kwarg_by_type(self.fn, kwarg_type=Context)
-        if context_kwarg is not None:
-            kwargs[context_kwarg] = get_context()
-
-        result = self.fn(**kwargs)
+        # self.fn is wrapped by without_injected_parameters which handles
+        # dependency resolution internally
+        result = self.fn()
         if inspect.isawaitable(result):
             result = await result