fastmcp 2.13.3__py3-none-any.whl → 2.14.1__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
 
@@ -23,7 +23,7 @@ from mcp.client.session import (
 )
 from mcp.client.sse import sse_client
 from mcp.client.stdio import stdio_client
-from mcp.client.streamable_http import streamablehttp_client
+from mcp.client.streamable_http import streamable_http_client
 from mcp.server.fastmcp import FastMCP as FastMCP1Server
 from mcp.shared._httpx_utils import McpHttpClientFactory
 from mcp.shared.memory import create_client_server_memory_streams
@@ -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
 
@@ -65,6 +66,7 @@ class SessionKwargs(TypedDict, total=False):
 
     read_timeout_seconds: datetime.timedelta | None
     sampling_callback: SamplingFnT | None
+    sampling_capabilities: mcp.types.SamplingCapability | None
     list_roots_callback: ListRootsFnT | None
     logging_callback: LoggingFnT | None
     elicitation_callback: ElicitationFnT | None
@@ -250,10 +252,22 @@ class StreamableHttpTransport(ClientTransport):
         self.httpx_client_factory = httpx_client_factory
         self._set_auth(auth)
 
+        if sse_read_timeout is not None:
+            if fastmcp.settings.deprecation_warnings:
+                warnings.warn(
+                    "The `sse_read_timeout` parameter is deprecated and no longer used. "
+                    "The new streamable_http_client API does not support this parameter. "
+                    "Use `read_timeout_seconds` in session_kwargs or configure timeout on "
+                    "the httpx client via `httpx_client_factory` instead.",
+                    DeprecationWarning,
+                    stacklevel=2,
+                )
         if isinstance(sse_read_timeout, int | float):
             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)
@@ -265,34 +279,55 @@ class StreamableHttpTransport(ClientTransport):
     async def connect_session(
         self, **session_kwargs: Unpack[SessionKwargs]
     ) -> AsyncIterator[ClientSession]:
-        client_kwargs: dict[str, Any] = {}
-
-        # load headers from an active HTTP request, if available. This will only be true
+        # Load headers from an active HTTP request, if available. This will only be true
         # if the client is used in a FastMCP Proxy, in which case the MCP client headers
         # need to be forwarded to the remote server.
-        client_kwargs["headers"] = get_http_headers() | self.headers
+        headers = get_http_headers() | self.headers
 
-        # sse_read_timeout has a default value set, so we can't pass None without overriding it
-        # instead we simply leave the kwarg out if it's not provided
-        if self.sse_read_timeout is not None:
-            client_kwargs["sse_read_timeout"] = self.sse_read_timeout
+        # Build httpx client configuration
+        httpx_client_kwargs: dict[str, Any] = {
+            "headers": headers,
+            "auth": self.auth,
+            "follow_redirects": True,
+        }
+
+        # Configure timeout if provided (convert timedelta to seconds for httpx)
         if session_kwargs.get("read_timeout_seconds") is not None:
-            client_kwargs["timeout"] = session_kwargs.get("read_timeout_seconds")
+            read_timeout_seconds = cast(
+                datetime.timedelta, session_kwargs.get("read_timeout_seconds")
+            )
+            httpx_client_kwargs["timeout"] = read_timeout_seconds.total_seconds()
 
+        # Create httpx client from factory or use default
         if self.httpx_client_factory is not None:
-            client_kwargs["httpx_client_factory"] = self.httpx_client_factory
+            http_client = self.httpx_client_factory(**httpx_client_kwargs)
+        else:
+            http_client = httpx.AsyncClient(**httpx_client_kwargs)
 
-        async with streamablehttp_client(
-            self.url,
-            auth=self.auth,
-            **client_kwargs,
-        ) as transport:
-            read_stream, write_stream, _ = transport
+        # Ensure httpx client is closed after use
+        async with (
+            http_client,
+            streamable_http_client(self.url, http_client=http_client) as 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 +410,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 +885,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 +915,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/__init__.py

@@ -0,0 +1,5 @@
+# Re-export for backwards compatibility
+# The canonical location is now fastmcp.client.sampling.handlers
+from fastmcp.client.sampling.handlers.openai import OpenAISamplingHandler
+
+__all__ = ["OpenAISamplingHandler"]

fastmcp/experimental/sampling/handlers/openai.py

@@ -1,170 +1,5 @@
-from collections.abc import Iterator, Sequence
-from typing import get_args
+# Re-export for backwards compatibility
+# The canonical location is now fastmcp.client.sampling.handlers.openai
+from fastmcp.client.sampling.handlers.openai import OpenAISamplingHandler
 
-from mcp import ClientSession, ServerSession
-from mcp.shared.context import LifespanContextT, RequestContext
-from mcp.types import CreateMessageRequestParams as SamplingParams
-from mcp.types import (
-    CreateMessageResult,
-    ModelPreferences,
-    SamplingMessage,
-    TextContent,
-)
-
-try:
-    from openai import NOT_GIVEN, OpenAI
-    from openai.types.chat import (
-        ChatCompletion,
-        ChatCompletionAssistantMessageParam,
-        ChatCompletionMessageParam,
-        ChatCompletionSystemMessageParam,
-        ChatCompletionUserMessageParam,
-    )
-    from openai.types.shared.chat_model import ChatModel
-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
-
-from fastmcp.experimental.sampling.handlers.base import BaseLLMSamplingHandler
-
-
-class OpenAISamplingHandler(BaseLLMSamplingHandler):
-    def __init__(self, default_model: ChatModel, client: OpenAI | None = None):
-        self.client: OpenAI = client or OpenAI()
-        self.default_model: ChatModel = default_model
-
-    @override
-    async def __call__(
-        self,
-        messages: list[SamplingMessage],
-        params: SamplingParams,
-        context: RequestContext[ServerSession, LifespanContextT]
-        | RequestContext[ClientSession, LifespanContextT],
-    ) -> CreateMessageResult:
-        openai_messages: list[ChatCompletionMessageParam] = (
-            self._convert_to_openai_messages(
-                system_prompt=params.systemPrompt,
-                messages=messages,
-            )
-        )
-
-        model: ChatModel = self._select_model_from_preferences(params.modelPreferences)
-
-        response = self.client.chat.completions.create(
-            model=model,
-            messages=openai_messages,
-            temperature=params.temperature or NOT_GIVEN,
-            max_tokens=params.maxTokens,
-            stop=params.stopSequences or NOT_GIVEN,
-        )
-
-        return self._chat_completion_to_create_message_result(response)
-
-    @staticmethod
-    def _iter_models_from_preferences(
-        model_preferences: ModelPreferences | str | list[str] | None,
-    ) -> Iterator[str]:
-        if model_preferences is None:
-            return
-
-        if isinstance(model_preferences, str) and model_preferences in get_args(
-            ChatModel
-        ):
-            yield model_preferences
-
-        if isinstance(model_preferences, list):
-            yield from model_preferences
-
-        if isinstance(model_preferences, ModelPreferences):
-            if not (hints := model_preferences.hints):
-                return
-
-            for hint in hints:
-                if not (name := hint.name):
-                    continue
-
-                yield name
-
-    @staticmethod
-    def _convert_to_openai_messages(
-        system_prompt: str | None, messages: Sequence[SamplingMessage]
-    ) -> list[ChatCompletionMessageParam]:
-        openai_messages: list[ChatCompletionMessageParam] = []
-
-        if system_prompt:
-            openai_messages.append(
-                ChatCompletionSystemMessageParam(
-                    role="system",
-                    content=system_prompt,
-                )
-            )
-
-        if isinstance(messages, str):
-            openai_messages.append(
-                ChatCompletionUserMessageParam(
-                    role="user",
-                    content=messages,
-                )
-            )
-
-        if isinstance(messages, list):
-            for message in messages:
-                if isinstance(message, str):
-                    openai_messages.append(
-                        ChatCompletionUserMessageParam(
-                            role="user",
-                            content=message,
-                        )
-                    )
-                    continue
-
-                if not isinstance(message.content, TextContent):
-                    raise ValueError("Only text content is supported")
-
-                if message.role == "user":
-                    openai_messages.append(
-                        ChatCompletionUserMessageParam(
-                            role="user",
-                            content=message.content.text,
-                        )
-                    )
-                else:
-                    openai_messages.append(
-                        ChatCompletionAssistantMessageParam(
-                            role="assistant",
-                            content=message.content.text,
-                        )
-                    )
-
-        return openai_messages
-
-    @staticmethod
-    def _chat_completion_to_create_message_result(
-        chat_completion: ChatCompletion,
-    ) -> CreateMessageResult:
-        if len(chat_completion.choices) == 0:
-            raise ValueError("No response for completion")
-
-        first_choice = chat_completion.choices[0]
-
-        if content := first_choice.message.content:
-            return CreateMessageResult(
-                content=TextContent(type="text", text=content),
-                role="assistant",
-                model=chat_completion.model,
-            )
-
-        raise ValueError("No content in response from completion")
-
-    def _select_model_from_preferences(
-        self, model_preferences: ModelPreferences | str | list[str] | None
-    ) -> 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]
-                return chosen_model
-
-        return self.default_model
+__all__ = ["OpenAISamplingHandler"]

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",
 ]