fastmcp 2.14.2__py3-none-any.whl → 2.14.4__py3-none-any.whl

fastmcp/cli/cli.py

@@ -28,6 +28,7 @@ from fastmcp.utilities.inspect import (
 )
 from fastmcp.utilities.logging import get_logger
 from fastmcp.utilities.mcp_server_config import MCPServerConfig
+from fastmcp.utilities.version_check import check_for_newer_version
 
 logger = get_logger("cli")
 console = Console()
@@ -122,6 +123,14 @@ def version(
     else:
         console.print(g)
 
+        # Check for updates (not included in --copy output)
+        if newer_version := check_for_newer_version():
+            console.print()
+            console.print(
+                f"[bold]🎉 FastMCP update available:[/bold] [green]{newer_version}[/green]"
+            )
+            console.print("[dim]Run: pip install --upgrade fastmcp[/dim]")
+
 
 @app.command
 async def dev(

fastmcp/client/auth/oauth.py

@@ -105,10 +105,13 @@ class TokenStorageAdapter(TokenStorage):
 
     @override
     async def set_tokens(self, tokens: OAuthToken) -> None:
+        # Don't set TTL based on access token expiry - the refresh token may be
+        # valid much longer. Use 1 year as a reasonable upper bound; the OAuth
+        # provider handles actual token expiry/refresh logic.
         await self._storage_oauth_token.put(
             key=self._get_token_cache_key(),
             value=tokens,
-            ttl=tokens.expires_in,
+            ttl=60 * 60 * 24 * 365,  # 1 year
         )
 
     @override

fastmcp/client/transports.py

@@ -25,7 +25,7 @@ from mcp.client.sse import sse_client
 from mcp.client.stdio import stdio_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._httpx_utils import McpHttpClientFactory, create_mcp_http_client
 from mcp.shared.memory import create_client_server_memory_streams
 from pydantic import AnyUrl
 from typing_extensions import TypedDict, Unpack
@@ -36,7 +36,6 @@ 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
 
@@ -284,25 +283,31 @@ class StreamableHttpTransport(ClientTransport):
         # need to be forwarded to the remote server.
         headers = get_http_headers() | self.headers
 
-        # 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)
+        # Configure timeout if provided, preserving MCP's 30s connect default
+        timeout: httpx.Timeout | None = None
         if session_kwargs.get("read_timeout_seconds") is not None:
             read_timeout_seconds = cast(
                 datetime.timedelta, session_kwargs.get("read_timeout_seconds")
             )
-            httpx_client_kwargs["timeout"] = read_timeout_seconds.total_seconds()
+            timeout = httpx.Timeout(30.0, read=read_timeout_seconds.total_seconds())
 
-        # Create httpx client from factory or use default
+        # Create httpx client from factory or use default with MCP-appropriate timeouts
+        # create_mcp_http_client uses 30s connect/5min read timeout by default,
+        # and always enables follow_redirects
         if self.httpx_client_factory is not None:
-            http_client = self.httpx_client_factory(**httpx_client_kwargs)
+            # Factory clients get the full kwargs for backwards compatibility
+            http_client = self.httpx_client_factory(
+                headers=headers,
+                auth=self.auth,
+                follow_redirects=True,
+                **({"timeout": timeout} if timeout else {}),
+            )
         else:
-            http_client = httpx.AsyncClient(**httpx_client_kwargs)
+            http_client = create_mcp_http_client(
+                headers=headers,
+                timeout=timeout,
+                auth=self.auth,
+            )
 
         # Ensure httpx client is closed after use
         async with (
@@ -894,16 +899,11 @@ class FastMCPTransport(ClientTransport):
                 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(
-                            experimental_capabilities=experimental_capabilities
-                        ),
+                        self.server._mcp_server.create_initialization_options(),
                         raise_exceptions=self.raise_exceptions,
                     )
                 )

fastmcp/server/auth/oauth_proxy.py

@@ -1221,12 +1221,24 @@ class OAuthProxy(OAuthProvider):
         # - 1 year if no refresh token (likely API-key-style token like GitHub OAuth Apps)
         if "expires_in" in idp_tokens:
             expires_in = int(idp_tokens["expires_in"])
+            logger.debug(
+                "Access token TTL: %d seconds (from IdP expires_in)", expires_in
+            )
         elif self._fallback_access_token_expiry_seconds is not None:
             expires_in = self._fallback_access_token_expiry_seconds
+            logger.debug(
+                "Access token TTL: %d seconds (using configured fallback)", expires_in
+            )
         elif idp_tokens.get("refresh_token"):
             expires_in = DEFAULT_ACCESS_TOKEN_EXPIRY_SECONDS
+            logger.debug(
+                "Access token TTL: %d seconds (default, has refresh token)", expires_in
+            )
         else:
             expires_in = DEFAULT_ACCESS_TOKEN_EXPIRY_NO_REFRESH_SECONDS
+            logger.debug(
+                "Access token TTL: %d seconds (default, no refresh token)", expires_in
+            )
 
         # Calculate refresh token expiry if provided by upstream
         # Some providers include refresh_expires_in, some don't
@@ -1266,8 +1278,9 @@ class OAuthProxy(OAuthProvider):
         await self._upstream_token_store.put(
             key=upstream_token_id,
             value=upstream_token_set,
-            ttl=refresh_expires_in
-            or expires_in,  # Auto-expire when refresh token, or access token expires
+            ttl=max(
+                refresh_expires_in or 0, expires_in, 1
+            ),  # Keep until longest-lived token expires (min 1s for safety)
         )
         logger.debug("Stored encrypted upstream tokens (jti=%s)", access_jti[:8])
 
@@ -1467,10 +1480,21 @@ class OAuthProxy(OAuthProvider):
         # (user override still applies if set)
         if "expires_in" in token_response:
             new_expires_in = int(token_response["expires_in"])
+            logger.debug(
+                "Refreshed access token TTL: %d seconds (from IdP expires_in)",
+                new_expires_in,
+            )
         elif self._fallback_access_token_expiry_seconds is not None:
             new_expires_in = self._fallback_access_token_expiry_seconds
+            logger.debug(
+                "Refreshed access token TTL: %d seconds (using configured fallback)",
+                new_expires_in,
+            )
         else:
             new_expires_in = DEFAULT_ACCESS_TOKEN_EXPIRY_SECONDS
+            logger.debug(
+                "Refreshed access token TTL: %d seconds (default)", new_expires_in
+            )
         upstream_token_set.access_token = token_response["access_token"]
         upstream_token_set.expires_at = time.time() + new_expires_in
 
@@ -1504,15 +1528,18 @@ class OAuthProxy(OAuthProvider):
                 )
 
         upstream_token_set.raw_token_data = token_response
+        # Calculate refresh TTL for storage
+        refresh_ttl = new_refresh_expires_in or (
+            int(upstream_token_set.refresh_token_expires_at - time.time())
+            if upstream_token_set.refresh_token_expires_at
+            else 60 * 60 * 24 * 30  # Default to 30 days if unknown
+        )
         await self._upstream_token_store.put(
             key=upstream_token_set.upstream_token_id,
             value=upstream_token_set,
-            ttl=new_refresh_expires_in
-            or (
-                int(upstream_token_set.refresh_token_expires_at - time.time())
-                if upstream_token_set.refresh_token_expires_at
-                else 60 * 60 * 24 * 30  # Default to 30 days if unknown
-            ),  # Auto-expire when refresh token expires
+            ttl=max(
+                refresh_ttl, new_expires_in, 1
+            ),  # Keep until longest-lived token expires (min 1s for safety)
         )
 
         # Issue new minimal FastMCP access token (just a reference via JTI)
@@ -1549,7 +1576,7 @@ class OAuthProxy(OAuthProvider):
         )
 
         # Store new refresh token JTI mapping with aligned expiry
-        refresh_ttl = new_refresh_expires_in or 60 * 60 * 24 * 30
+        # (reuse refresh_ttl calculated above for upstream token store)
         await self._jti_mapping_store.put(
             key=new_refresh_jti,
             value=JTIMapping(
@@ -1622,7 +1649,10 @@ class OAuthProxy(OAuthProvider):
             # 2. Look up upstream token via JTI mapping
             jti_mapping = await self._jti_mapping_store.get(key=jti)
             if not jti_mapping:
-                logger.debug("JTI mapping not found: %s", jti)
+                logger.info(
+                    "JTI mapping not found (token may have expired): jti=%s...",
+                    jti[:16],
+                )
                 return None
 
             upstream_token_set = await self._upstream_token_store.get(
@@ -1865,6 +1895,11 @@ class OAuthProxy(OAuthProvider):
                 logger.debug(
                     f"Successfully exchanged IdP code for tokens (transaction: {txn_id}, PKCE: {bool(proxy_code_verifier)})"
                 )
+                logger.debug(
+                    "IdP token response: expires_in=%s, has_refresh_token=%s",
+                    idp_tokens.get("expires_in"),
+                    "refresh_token" in idp_tokens,
+                )
 
             except Exception as e:
                 logger.error("IdP token exchange failed: %s", e)

fastmcp/server/context.py

@@ -185,10 +185,24 @@ class Context:
         self._tokens.append(token)
 
         # Set current server for dependency injection (use weakref to avoid reference cycles)
-        from fastmcp.server.dependencies import _current_server
+        from fastmcp.server.dependencies import (
+            _current_docket,
+            _current_server,
+            _current_worker,
+        )
 
         self._server_token = _current_server.set(weakref.ref(self.fastmcp))
 
+        # Set docket/worker from server instance for this request's context.
+        # This ensures ContextVars work even in environments (like Lambda) where
+        # lifespan ContextVars don't propagate to request handlers.
+        server = self.fastmcp
+        if server._docket is not None:
+            self._docket_token = _current_docket.set(server._docket)
+
+        if server._worker is not None:
+            self._worker_token = _current_worker.set(server._worker)
+
         return self
 
     async def __aexit__(self, exc_type, exc_val, exc_tb) -> None:
@@ -196,10 +210,20 @@ class Context:
         # Flush any remaining notifications before exiting
         await self._flush_notifications()
 
-        # Reset server token
-        if hasattr(self, "_server_token"):
-            from fastmcp.server.dependencies import _current_server
+        # Reset server/docket/worker tokens
+        from fastmcp.server.dependencies import (
+            _current_docket,
+            _current_server,
+            _current_worker,
+        )
 
+        if hasattr(self, "_worker_token"):
+            _current_worker.reset(self._worker_token)
+            delattr(self, "_worker_token")
+        if hasattr(self, "_docket_token"):
+            _current_docket.reset(self._docket_token)
+            delattr(self, "_docket_token")
+        if hasattr(self, "_server_token"):
             _current_server.reset(self._server_token)
             delattr(self, "_server_token")
 

fastmcp/server/http.py

@@ -21,7 +21,6 @@ from starlette.types import Lifespan, Receive, Scope, Send
 
 from fastmcp.server.auth import AuthProvider
 from fastmcp.server.auth.middleware import RequireAuthMiddleware
-from fastmcp.server.tasks.capabilities import get_task_capabilities
 from fastmcp.utilities.logging import get_logger
 
 if TYPE_CHECKING:
@@ -160,15 +159,10 @@ def create_sse_app(
     # Create handler for SSE connections
     async def handle_sse(scope: Scope, receive: Receive, send: Send) -> Response:
         async with sse.connect_sse(scope, receive, send) as streams:
-            # Build experimental capabilities
-            experimental_capabilities = get_task_capabilities()
-
             await server._mcp_server.run(
                 streams[0],
                 streams[1],
-                server._mcp_server.create_initialization_options(
-                    experimental_capabilities=experimental_capabilities
-                ),
+                server._mcp_server.create_initialization_options(),
             )
         return Response()
 

fastmcp/server/low_level.py

@@ -163,6 +163,31 @@ class LowLevelServer(_Server[LifespanResultT, RequestT]):
             **kwargs,
         )
 
+    def get_capabilities(
+        self,
+        notification_options: NotificationOptions,
+        experimental_capabilities: dict[str, dict[str, Any]],
+    ) -> mcp.types.ServerCapabilities:
+        """Override to set capabilities.tasks as a first-class field per SEP-1686.
+
+        This ensures task capabilities appear in capabilities.tasks instead of
+        capabilities.experimental.tasks, which is required by the MCP spec and
+        enables proper task detection by clients like VS Code Copilot 1.107+.
+        """
+        from fastmcp.server.tasks.capabilities import get_task_capabilities
+
+        # Get base capabilities from SDK (pass empty dict for experimental)
+        # since we'll set tasks as a first-class field instead
+        capabilities = super().get_capabilities(
+            notification_options,
+            experimental_capabilities or {},
+        )
+
+        # Set tasks as a first-class field (not experimental) per SEP-1686
+        capabilities.tasks = get_task_capabilities()
+
+        return capabilities
+
     async def run(
         self,
         read_stream: MemoryObjectReceiveStream[SessionMessage | Exception],

fastmcp/server/server.py

@@ -75,7 +75,6 @@ from fastmcp.server.http import (
 )
 from fastmcp.server.low_level import LowLevelServer
 from fastmcp.server.middleware import Middleware, MiddlewareContext
-from fastmcp.server.tasks.capabilities import get_task_capabilities
 from fastmcp.server.tasks.config import TaskConfig
 from fastmcp.server.tasks.handlers import (
     handle_prompt_as_task,
@@ -197,8 +196,9 @@ class FastMCP(Generic[LifespanResultT]):
         # Resolve server default for background task support
         self._support_tasks_by_default: bool = tasks if tasks is not None else False
 
-        # Docket instance (set during lifespan for cross-task access)
+        # Docket and Worker instances (set during lifespan for cross-task access)
         self._docket = None
+        self._worker = None
 
         self._additional_http_routes: list[BaseRoute] = []
         self._mounted_servers: list[MountedServer] = []
@@ -468,6 +468,8 @@ class FastMCP(Generic[LifespanResultT]):
 
                     # Create and start Worker
                     async with Worker(docket, **worker_kwargs) as worker:  # type: ignore[arg-type]
+                        # Store on server instance for cross-context access
+                        self._worker = worker
                         # Set Worker in ContextVar so CurrentWorker can access it
                         worker_token = _current_worker.set(worker)
                         try:
@@ -480,13 +482,11 @@ class FastMCP(Generic[LifespanResultT]):
                                     await worker_task
                         finally:
                             _current_worker.reset(worker_token)
+                            self._worker = None
                 finally:
-                    # Reset ContextVar
                     _current_docket.reset(docket_token)
-                    # Clear instance attribute
                     self._docket = None
         finally:
-            # Reset server ContextVar
             _current_server.reset(server_token)
 
     async def _register_mounted_server_functions(
@@ -564,6 +564,8 @@ class FastMCP(Generic[LifespanResultT]):
     @asynccontextmanager
     async def _lifespan_manager(self) -> AsyncIterator[None]:
         if self._lifespan_result_set:
+            # Lifespan already ran - ContextVars will be set by Context.__aenter__
+            # at request time, so we just yield here.
             yield
             return
 
@@ -2505,9 +2507,6 @@ class FastMCP(Generic[LifespanResultT]):
                         f"Starting MCP server {self.name!r} with transport 'stdio'"
                     )
 
-                    # Build experimental capabilities
-                    experimental_capabilities = get_task_capabilities()
-
                     await self._mcp_server.run(
                         read_stream,
                         write_stream,
@@ -2515,7 +2514,6 @@ class FastMCP(Generic[LifespanResultT]):
                             notification_options=NotificationOptions(
                                 tools_changed=True
                             ),
-                            experimental_capabilities=experimental_capabilities,
                         ),
                     )
 

fastmcp/server/tasks/capabilities.py

@@ -1,22 +1,30 @@
 """SEP-1686 task capabilities declaration."""
 
-from typing import Any
+from mcp.types import (
+    ServerTasksCapability,
+    ServerTasksRequestsCapability,
+    TasksCallCapability,
+    TasksCancelCapability,
+    TasksListCapability,
+    TasksToolsCapability,
+)
 
 
-def get_task_capabilities() -> dict[str, Any]:
-    """Return the SEP-1686 task capabilities structure.
+def get_task_capabilities() -> ServerTasksCapability:
+    """Return the SEP-1686 task capabilities.
 
-    This is the standard capabilities map advertised to clients,
-    declaring support for list, cancel, and request operations.
+    Returns task capabilities as a first-class ServerCapabilities field,
+    declaring support for list, cancel, and request operations per SEP-1686.
+
+    Note: prompts/resources are passed via extra_data since the SDK types
+    don't include them yet (FastMCP supports them ahead of the spec).
     """
-    return {
-        "tasks": {
-            "list": {},
-            "cancel": {},
-            "requests": {
-                "tools": {"call": {}},
-                "prompts": {"get": {}},
-                "resources": {"read": {}},
-            },
-        }
-    }
+    return ServerTasksCapability(
+        list=TasksListCapability(),
+        cancel=TasksCancelCapability(),
+        requests=ServerTasksRequestsCapability(
+            tools=TasksToolsCapability(call=TasksCallCapability()),
+            prompts={"get": {}},  # type: ignore[call-arg]  # extra_data for forward compat
+            resources={"read": {}},  # type: ignore[call-arg]  # extra_data for forward compat
+        ),
+    )

fastmcp/server/tasks/handlers.py

@@ -56,6 +56,7 @@ async def handle_tool_as_task(
     ctx = get_context()
     session_id = ctx.session_id
 
+    # Get Docket from ContextVar (set by Context.__aenter__ at request time)
     docket = _current_docket.get()
     if docket is None:
         raise McpError(
@@ -72,13 +73,15 @@ async def handle_tool_as_task(
     tool = await server.get_tool(tool_name)
 
     # Store task key mapping and creation timestamp in Redis for protocol handlers
-    redis_key = f"fastmcp:task:{session_id}:{server_task_id}"
-    created_at_key = f"fastmcp:task:{session_id}:{server_task_id}:created_at"
+    task_meta_key = docket.key(f"fastmcp:task:{session_id}:{server_task_id}")
+    created_at_key = docket.key(
+        f"fastmcp:task:{session_id}:{server_task_id}:created_at"
+    )
     ttl_seconds = int(
         docket.execution_ttl.total_seconds() + TASK_MAPPING_TTL_BUFFER_SECONDS
     )
     async with docket.redis() as redis:
-        await redis.set(redis_key, task_key, ex=ttl_seconds)
+        await redis.set(task_meta_key, task_key, ex=ttl_seconds)
         await redis.set(created_at_key, created_at, ex=ttl_seconds)
 
     # Send notifications/tasks/created per SEP-1686 (mandatory)
@@ -165,6 +168,7 @@ async def handle_prompt_as_task(
     ctx = get_context()
     session_id = ctx.session_id
 
+    # Get Docket from ContextVar (set by Context.__aenter__ at request time)
     docket = _current_docket.get()
     if docket is None:
         raise McpError(
@@ -181,13 +185,15 @@ async def handle_prompt_as_task(
     prompt = await server.get_prompt(prompt_name)
 
     # Store task key mapping and creation timestamp in Redis for protocol handlers
-    redis_key = f"fastmcp:task:{session_id}:{server_task_id}"
-    created_at_key = f"fastmcp:task:{session_id}:{server_task_id}:created_at"
+    task_meta_key = docket.key(f"fastmcp:task:{session_id}:{server_task_id}")
+    created_at_key = docket.key(
+        f"fastmcp:task:{session_id}:{server_task_id}:created_at"
+    )
     ttl_seconds = int(
         docket.execution_ttl.total_seconds() + TASK_MAPPING_TTL_BUFFER_SECONDS
     )
     async with docket.redis() as redis:
-        await redis.set(redis_key, task_key, ex=ttl_seconds)
+        await redis.set(task_meta_key, task_key, ex=ttl_seconds)
         await redis.set(created_at_key, created_at, ex=ttl_seconds)
 
     # Send notifications/tasks/created per SEP-1686 (mandatory)
@@ -272,12 +278,13 @@ async def handle_resource_as_task(
     ctx = get_context()
     session_id = ctx.session_id
 
+    # Get Docket from ContextVar (set by Context.__aenter__ at request time)
     docket = _current_docket.get()
     if docket is None:
         raise McpError(
             ErrorData(
                 code=INTERNAL_ERROR,
-                message="Background tasks require Docket",
+                message="Background tasks require a running FastMCP server context",
             )
         )
 
@@ -285,13 +292,15 @@ async def handle_resource_as_task(
     task_key = build_task_key(session_id, server_task_id, "resource", str(uri))
 
     # Store task key mapping and creation timestamp in Redis for protocol handlers
-    redis_key = f"fastmcp:task:{session_id}:{server_task_id}"
-    created_at_key = f"fastmcp:task:{session_id}:{server_task_id}:created_at"
+    task_meta_key = docket.key(f"fastmcp:task:{session_id}:{server_task_id}")
+    created_at_key = docket.key(
+        f"fastmcp:task:{session_id}:{server_task_id}:created_at"
+    )
     ttl_seconds = int(
         docket.execution_ttl.total_seconds() + TASK_MAPPING_TTL_BUFFER_SECONDS
     )
     async with docket.redis() as redis:
-        await redis.set(redis_key, task_key, ex=ttl_seconds)
+        await redis.set(task_meta_key, task_key, ex=ttl_seconds)
         await redis.set(created_at_key, created_at, ex=ttl_seconds)
 
     # Send notifications/tasks/created per SEP-1686 (mandatory)

fastmcp/server/tasks/protocol.py

@@ -77,10 +77,12 @@ async def tasks_get_handler(server: FastMCP, params: dict[str, Any]) -> GetTaskR
             )
 
         # Look up full task key and creation timestamp from Redis
-        redis_key = f"fastmcp:task:{session_id}:{client_task_id}"
-        created_at_key = f"fastmcp:task:{session_id}:{client_task_id}:created_at"
+        task_meta_key = docket.key(f"fastmcp:task:{session_id}:{client_task_id}")
+        created_at_key = docket.key(
+            f"fastmcp:task:{session_id}:{client_task_id}:created_at"
+        )
         async with docket.redis() as redis:
-            task_key_bytes = await redis.get(redis_key)
+            task_key_bytes = await redis.get(task_meta_key)
             created_at_bytes = await redis.get(created_at_key)
 
         task_key = None if task_key_bytes is None else task_key_bytes.decode("utf-8")
@@ -176,9 +178,9 @@ async def tasks_result_handler(server: FastMCP, params: dict[str, Any]) -> Any:
             )
 
         # Look up full task key from Redis
-        redis_key = f"fastmcp:task:{session_id}:{client_task_id}"
+        task_meta_key = docket.key(f"fastmcp:task:{session_id}:{client_task_id}")
         async with docket.redis() as redis:
-            task_key_bytes = await redis.get(redis_key)
+            task_key_bytes = await redis.get(task_meta_key)
 
         task_key = None if task_key_bytes is None else task_key_bytes.decode("utf-8")
 
@@ -309,10 +311,12 @@ async def tasks_cancel_handler(
             )
 
         # Look up full task key and creation timestamp from Redis
-        redis_key = f"fastmcp:task:{session_id}:{client_task_id}"
-        created_at_key = f"fastmcp:task:{session_id}:{client_task_id}:created_at"
+        task_meta_key = docket.key(f"fastmcp:task:{session_id}:{client_task_id}")
+        created_at_key = docket.key(
+            f"fastmcp:task:{session_id}:{client_task_id}:created_at"
+        )
         async with docket.redis() as redis:
-            task_key_bytes = await redis.get(redis_key)
+            task_key_bytes = await redis.get(task_meta_key)
             created_at_bytes = await redis.get(created_at_key)
 
         task_key = None if task_key_bytes is None else task_key_bytes.decode("utf-8")

fastmcp/server/tasks/subscriptions.py

@@ -70,7 +70,7 @@ async def subscribe_to_task_updates(
                 )
 
     except Exception as e:
-        logger.warning(f"Subscription task failed for {task_id}: {e}", exc_info=True)
+        logger.error(f"subscribe_to_task_updates failed for {task_id}: {e}")
 
 
 async def _send_status_notification(
@@ -101,8 +101,7 @@ async def _send_status_notification(
     key_parts = parse_task_key(task_key)
     session_id = key_parts["session_id"]
 
-    # Retrieve createdAt timestamp from Redis
-    created_at_key = f"fastmcp:task:{session_id}:{task_id}:created_at"
+    created_at_key = docket.key(f"fastmcp:task:{session_id}:{task_id}:created_at")
     async with docket.redis() as redis:
         created_at_bytes = await redis.get(created_at_key)
 
@@ -175,8 +174,7 @@ async def _send_progress_notification(
     key_parts = parse_task_key(task_key)
     session_id = key_parts["session_id"]
 
-    # Retrieve createdAt timestamp from Redis
-    created_at_key = f"fastmcp:task:{session_id}:{task_id}:created_at"
+    created_at_key = docket.key(f"fastmcp:task:{session_id}:{task_id}:created_at")
     async with docket.redis() as redis:
         created_at_bytes = await redis.get(created_at_key)
 

fastmcp/settings.py

@@ -392,6 +392,21 @@ class Settings(BaseSettings):
         ),
     ] = True
 
+    check_for_updates: Annotated[
+        Literal["stable", "prerelease", "off"],
+        Field(
+            description=inspect.cleandoc(
+                """
+                Controls update checking when displaying the CLI banner.
+                - "stable": Check for stable releases only (default)
+                - "prerelease": Also check for pre-release versions (alpha, beta, rc)
+                - "off": Disable update checking entirely
+                Set via FASTMCP_CHECK_FOR_UPDATES environment variable.
+                """
+            ),
+        ),
+    ] = "stable"
+
     @property
     def server_auth_class(self) -> AuthProvider | None:
         from fastmcp.utilities.types import get_cached_typeadapter

fastmcp/utilities/cli.py

@@ -17,6 +17,7 @@ from fastmcp.utilities.logging import get_logger
 from fastmcp.utilities.mcp_server_config import MCPServerConfig
 from fastmcp.utilities.mcp_server_config.v1.sources.filesystem import FileSystemSource
 from fastmcp.utilities.types import get_cached_typeadapter
+from fastmcp.utilities.version_check import check_for_newer_version
 
 if TYPE_CHECKING:
     from fastmcp import FastMCP
@@ -200,6 +201,9 @@ LOGO_ASCII_4 = (
 def log_server_banner(server: FastMCP[Any]) -> None:
     """Creates and logs a formatted banner with server information and logo."""
 
+    # Check for updates (non-blocking, fails silently)
+    newer_version = check_for_newer_version()
+
     # Create the logo text
     # Use Text with no_wrap and markup disabled to preserve ANSI escape codes
     logo_text = Text.from_ansi(LOGO_ASCII_4, no_wrap=True)
@@ -231,8 +235,10 @@ def log_server_banner(server: FastMCP[Any]) -> None:
 
     # v3 notice banner (shown below main panel)
     v3_line1 = Text("✨ FastMCP 3.0 is coming!", style="bold")
-    v3_line2 = Text(
-        "Pin fastmcp<3 in production, then upgrade when you're ready.", style="dim"
+    v3_line2 = Text.assemble(
+        ("Pin ", "dim"),
+        ("`fastmcp < 3`", "dim bold"),
+        (" in production, then upgrade when you're ready.", "dim"),
     )
     v3_notice = Panel(
         Group(Align.center(v3_line1), Align.center(v3_line2)),
@@ -250,5 +256,26 @@ def log_server_banner(server: FastMCP[Any]) -> None:
     )
 
     console = Console(stderr=True)
-    # Center both panels
-    console.print(Group("\n", Align.center(panel), Align.center(v3_notice), "\n"))
+
+    # Build output elements
+    output_elements: list[Align | Panel | str] = ["\n", Align.center(panel)]
+    output_elements.append(Align.center(v3_notice))
+
+    # Add update notice if a newer version is available (shown last for visibility)
+    if newer_version:
+        update_line1 = Text.assemble(
+            ("🎉 Update available: ", "bold"),
+            (newer_version, "bold green"),
+        )
+        update_line2 = Text("Run: pip install --upgrade fastmcp", style="dim")
+        update_notice = Panel(
+            Group(Align.center(update_line1), Align.center(update_line2)),
+            border_style="blue",
+            padding=(0, 2),
+            width=80,
+        )
+        output_elements.append(Align.center(update_notice))
+
+    output_elements.append("\n")
+
+    console.print(Group(*output_elements))

fastmcp/utilities/json_schema.py

@@ -3,6 +3,130 @@ from __future__ import annotations
 from collections import defaultdict
 from typing import Any
 
+from jsonref import JsonRefError, replace_refs
+
+
+def dereference_refs(schema: dict[str, Any]) -> dict[str, Any]:
+    """Resolve all $ref references in a JSON schema by inlining definitions.
+
+    This function resolves $ref references that point to $defs, replacing them
+    with the actual definition content while preserving sibling keywords (like
+    description, default, examples) that Pydantic places alongside $ref.
+
+    This is necessary because some MCP clients (e.g., VS Code Copilot) don't
+    properly handle $ref in tool input schemas.
+
+    For self-referencing/circular schemas where full dereferencing is not possible,
+    this function falls back to resolving only the root-level $ref while preserving
+    $defs for nested references.
+
+    Args:
+        schema: JSON schema dict that may contain $ref references
+
+    Returns:
+        A new schema dict with $ref resolved where possible and $defs removed
+        when no longer needed
+
+    Example:
+        >>> schema = {
+        ...     "$defs": {"Category": {"enum": ["a", "b"], "type": "string"}},
+        ...     "properties": {"cat": {"$ref": "#/$defs/Category", "default": "a"}}
+        ... }
+        >>> resolved = dereference_refs(schema)
+        >>> # Result: {"properties": {"cat": {"enum": ["a", "b"], "type": "string", "default": "a"}}}
+    """
+    try:
+        # Use jsonref to resolve all $ref references
+        # proxies=False returns plain dicts (not proxy objects)
+        # lazy_load=False resolves immediately
+        dereferenced = replace_refs(schema, proxies=False, lazy_load=False)
+
+        # Merge sibling keywords that were lost during dereferencing
+        # Pydantic puts description, default, examples as siblings to $ref
+        defs = schema.get("$defs", {})
+        merged = _merge_ref_siblings(schema, dereferenced, defs)
+        # Type assertion: top-level schema is always a dict
+        assert isinstance(merged, dict)
+        dereferenced = merged
+
+        # Remove $defs since all references have been resolved
+        if "$defs" in dereferenced:
+            dereferenced = {k: v for k, v in dereferenced.items() if k != "$defs"}
+
+        return dereferenced
+
+    except JsonRefError:
+        # Self-referencing/circular schemas can't be fully dereferenced
+        # Fall back to resolving only root-level $ref (for MCP spec compliance)
+        return resolve_root_ref(schema)
+
+
+def _merge_ref_siblings(
+    original: Any,
+    dereferenced: Any,
+    defs: dict[str, Any],
+    visited: set[str] | None = None,
+) -> Any:
+    """Merge sibling keywords from original $ref nodes into dereferenced schema.
+
+    When jsonref resolves $ref, it replaces the entire node with the referenced
+    definition, losing any sibling keywords like description, default, or examples.
+    This function walks both trees in parallel and merges those siblings back.
+
+    Args:
+        original: The original schema with $ref and potential siblings
+        dereferenced: The schema after jsonref processing
+        defs: The $defs from the original schema, for looking up referenced definitions
+        visited: Set of definition names already being processed (prevents cycles)
+
+    Returns:
+        The dereferenced schema with sibling keywords restored
+    """
+    if visited is None:
+        visited = set()
+
+    if isinstance(original, dict) and isinstance(dereferenced, dict):
+        # Check if original had a $ref
+        if "$ref" in original:
+            ref = original["$ref"]
+            siblings = {k: v for k, v in original.items() if k not in ("$ref", "$defs")}
+
+            # Look up the referenced definition to process its nested siblings
+            if isinstance(ref, str) and ref.startswith("#/$defs/"):
+                def_name = ref.split("/")[-1]
+                # Prevent infinite recursion on circular references
+                if def_name in defs and def_name not in visited:
+                    # Recursively process the definition's content for nested siblings
+                    dereferenced = _merge_ref_siblings(
+                        defs[def_name], dereferenced, defs, visited | {def_name}
+                    )
+
+            if siblings:
+                # Merge local siblings, which take precedence
+                merged = dict(dereferenced)
+                merged.update(siblings)
+                return merged
+            return dereferenced
+
+        # Recurse into nested structures
+        result = {}
+        for key, value in dereferenced.items():
+            if key in original:
+                result[key] = _merge_ref_siblings(original[key], value, defs, visited)
+            else:
+                result[key] = value
+        return result
+
+    elif isinstance(original, list) and isinstance(dereferenced, list):
+        # Process list items in parallel
+        min_len = min(len(original), len(dereferenced))
+        return [
+            _merge_ref_siblings(o, d, defs, visited)
+            for o, d in zip(original[:min_len], dereferenced[:min_len], strict=False)
+        ] + dereferenced[min_len:]
+
+    return dereferenced
+
 
 def resolve_root_ref(schema: dict[str, Any]) -> dict[str, Any]:
     """Resolve $ref at root level to meet MCP spec requirements.
@@ -43,7 +167,7 @@ def resolve_root_ref(schema: dict[str, Any]) -> dict[str, Any]:
     return schema
 
 
-def _prune_param(schema: dict, param: str) -> dict:
+def _prune_param(schema: dict[str, Any], param: str) -> dict[str, Any]:
     """Return a new schema with *param* removed from `properties`, `required`,
     and (if no longer referenced) `$defs`.
     """
@@ -65,11 +189,11 @@ def _prune_param(schema: dict, param: str) -> dict:
 
 
 def _single_pass_optimize(
-    schema: dict,
+    schema: dict[str, Any],
     prune_titles: bool = False,
     prune_additional_properties: bool = False,
     prune_defs: bool = True,
-) -> dict:
+) -> dict[str, Any]:
     """
     Optimize JSON schemas in a single traversal for better performance.
 
@@ -238,12 +362,12 @@ def _single_pass_optimize(
 
 
 def compress_schema(
-    schema: dict,
+    schema: dict[str, Any],
     prune_params: list[str] | None = None,
     prune_defs: bool = True,
     prune_additional_properties: bool = True,
     prune_titles: bool = False,
-) -> dict:
+) -> dict[str, Any]:
     """
     Remove the given parameters from the schema.
 

fastmcp/utilities/version_check.py

@@ -0,0 +1,153 @@
+"""Version checking utilities for FastMCP."""
+
+from __future__ import annotations
+
+import json
+import time
+from pathlib import Path
+
+import httpx
+from packaging.version import Version
+
+from fastmcp.utilities.logging import get_logger
+
+logger = get_logger(__name__)
+
+PYPI_URL = "https://pypi.org/pypi/fastmcp/json"
+CACHE_TTL_SECONDS = 60 * 60 * 12  # 12 hours
+REQUEST_TIMEOUT_SECONDS = 2.0
+
+
+def _get_cache_path(include_prereleases: bool = False) -> Path:
+    """Get the path to the version cache file."""
+    import fastmcp
+
+    suffix = "_prerelease" if include_prereleases else ""
+    return fastmcp.settings.home / f"version_cache{suffix}.json"
+
+
+def _read_cache(include_prereleases: bool = False) -> tuple[str | None, float]:
+    """Read cached version info.
+
+    Returns:
+        Tuple of (cached_version, cache_timestamp) or (None, 0) if no cache.
+    """
+    cache_path = _get_cache_path(include_prereleases)
+    if not cache_path.exists():
+        return None, 0
+
+    try:
+        data = json.loads(cache_path.read_text())
+        return data.get("latest_version"), data.get("timestamp", 0)
+    except (json.JSONDecodeError, OSError):
+        return None, 0
+
+
+def _write_cache(latest_version: str, include_prereleases: bool = False) -> None:
+    """Write version info to cache."""
+    cache_path = _get_cache_path(include_prereleases)
+    try:
+        cache_path.parent.mkdir(parents=True, exist_ok=True)
+        cache_path.write_text(
+            json.dumps({"latest_version": latest_version, "timestamp": time.time()})
+        )
+    except OSError:
+        # Silently ignore cache write failures
+        pass
+
+
+def _fetch_latest_version(include_prereleases: bool = False) -> str | None:
+    """Fetch the latest version from PyPI.
+
+    Args:
+        include_prereleases: If True, include pre-release versions (alpha, beta, rc).
+
+    Returns:
+        The latest version string, or None if the fetch failed.
+    """
+    try:
+        response = httpx.get(PYPI_URL, timeout=REQUEST_TIMEOUT_SECONDS)
+        response.raise_for_status()
+        data = response.json()
+
+        releases = data.get("releases", {})
+        if not releases:
+            return None
+
+        versions = []
+        for version_str in releases:
+            try:
+                v = Version(version_str)
+                # Skip prereleases if not requested
+                if not include_prereleases and v.is_prerelease:
+                    continue
+                versions.append(v)
+            except ValueError:
+                logger.debug(f"Skipping invalid version string: {version_str}")
+                continue
+
+        if not versions:
+            return None
+
+        return str(max(versions))
+
+    except (httpx.HTTPError, json.JSONDecodeError, KeyError):
+        return None
+
+
+def get_latest_version(include_prereleases: bool = False) -> str | None:
+    """Get the latest version of FastMCP from PyPI, using cache when available.
+
+    Args:
+        include_prereleases: If True, include pre-release versions.
+
+    Returns:
+        The latest version string, or None if unavailable.
+    """
+    # Check cache first
+    cached_version, cache_timestamp = _read_cache(include_prereleases)
+    if cached_version and (time.time() - cache_timestamp) < CACHE_TTL_SECONDS:
+        return cached_version
+
+    # Fetch from PyPI
+    latest_version = _fetch_latest_version(include_prereleases)
+
+    # Update cache if we got a valid version
+    if latest_version:
+        _write_cache(latest_version, include_prereleases)
+        return latest_version
+
+    # Return stale cache if available
+    return cached_version
+
+
+def check_for_newer_version() -> str | None:
+    """Check if a newer version of FastMCP is available.
+
+    Returns:
+        The latest version string if newer than current, None otherwise.
+    """
+    import fastmcp
+
+    setting = fastmcp.settings.check_for_updates
+    if setting == "off":
+        return None
+
+    include_prereleases = setting == "prerelease"
+    latest_version = get_latest_version(include_prereleases)
+    if not latest_version:
+        return None
+
+    try:
+        current = Version(fastmcp.__version__)
+        latest = Version(latest_version)
+
+        if latest > current:
+            return latest_version
+    except ValueError:
+        logger.debug(
+            f"Could not compare versions: current={fastmcp.__version__!r}, "
+            f"latest={latest_version!r}"
+        )
+
+    return None

{fastmcp-2.14.2.dist-info → fastmcp-2.14.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastmcp
-Version: 2.14.2
+Version: 2.14.4
 Summary: The fast, Pythonic way to build MCP servers and clients.
 Project-URL: Homepage, https://gofastmcp.com
 Project-URL: Repository, https://github.com/jlowin/fastmcp
@@ -22,13 +22,15 @@ Requires-Dist: authlib>=1.6.5
 Requires-Dist: cyclopts>=4.0.0
 Requires-Dist: exceptiongroup>=1.2.2
 Requires-Dist: httpx>=0.28.1
+Requires-Dist: jsonref>=1.1.0
 Requires-Dist: jsonschema-path>=0.3.4
 Requires-Dist: mcp<2.0,>=1.24.0
 Requires-Dist: openapi-pydantic>=0.5.1
+Requires-Dist: packaging>=20.0
 Requires-Dist: platformdirs>=4.0.0
 Requires-Dist: py-key-value-aio[disk,keyring,memory]<0.4.0,>=0.3.0
 Requires-Dist: pydantic[email]>=2.11.7
-Requires-Dist: pydocket>=0.16.3
+Requires-Dist: pydocket<0.17.0,>=0.16.6
 Requires-Dist: pyperclip>=1.9.0
 Requires-Dist: python-dotenv>=1.1.0
 Requires-Dist: rich>=13.9.4

{fastmcp-2.14.2.dist-info → fastmcp-2.14.4.dist-info}/RECORD

@@ -3,10 +3,10 @@ fastmcp/dependencies.py,sha256=Un5S30WHJbAiIdjVjEeaQC7UcEVEkkyjf4EF7l4FYq0,513
 fastmcp/exceptions.py,sha256=-krEavxwddQau6T7MESCR4VjKNLfP9KHJrU1p3y72FU,744
 fastmcp/mcp_config.py,sha256=YXZ0piljrxFgPYEwYSwPw6IiPwU3Cwp2VzlT9CWxutc,11397
 fastmcp/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-fastmcp/settings.py,sha256=565ICavv2ms1lCvGV4XS6VXIYJZyB0os3Ifsr03A6YA,13307
+fastmcp/settings.py,sha256=IL3r6kyGzy3WW4evL4BwDfBGNNArbCnwnGmKlOHTr8Y,13888
 fastmcp/cli/__init__.py,sha256=Bo7WQWPBRQ6fqbYYPfbadefpXgl2h9gkdMaqTazGWyw,49
 fastmcp/cli/__main__.py,sha256=cGU_smvfctQI9xEY13u7tTEwwUI4AUieikXXA7ykYhA,69
-fastmcp/cli/cli.py,sha256=HQ7MpR_7sB-bgQKG1XOd8epS2RIv_CqdYdHT8mZLszI,28242
+fastmcp/cli/cli.py,sha256=Bedska9lyo7NuMUb4G0hvBK3OzG7BMTnA756s72rdq8,28664
 fastmcp/cli/run.py,sha256=HeaiHYcVY17JpHg4UjnIHkP5ttU0PNd1bZIL3brif8A,7047
 fastmcp/cli/tasks.py,sha256=B57vy76d3ybdi4wmlODRCCFrte1GmhLKqYixzRkGUuw,3791
 fastmcp/cli/install/__init__.py,sha256=FUrwjMVaxONgz1qO7suzJNz1xosRfR3TOHlr3Z77JXA,797
@@ -25,10 +25,10 @@ fastmcp/client/oauth_callback.py,sha256=3xqL5_HD1QS9eGfw31HzoVF94QQelq_0TTqS7qWD
 fastmcp/client/progress.py,sha256=WjLLDbUKMsx8DK-fqO7AGsXb83ak-6BMrLvzzznGmcI,1043
 fastmcp/client/roots.py,sha256=Uap1RSr3uEeQRZTHkEttkhTI2fOA8IeDcRSggtZp9aY,2568
 fastmcp/client/tasks.py,sha256=zjiTfvjU9NaA4e3XTBGHsqvSfBRR19UqZMIUhJ_nQTo,19480
-fastmcp/client/transports.py,sha256=ZRxHTgNYK6_D_2GNa15cfGMNP-naZ0A9q8oc2jfgX8A,43231
+fastmcp/client/transports.py,sha256=iFoivucnJb0LoDVu9HbEgWta3KcxRjM3arR4ebZOZco,43291
 fastmcp/client/auth/__init__.py,sha256=4DNsfp4iaQeBcpds0JDdMn6Mmfud44stWLsret0sVKY,91
 fastmcp/client/auth/bearer.py,sha256=MFEFqcH6u_V86msYiOsEFKN5ks1V9BnBNiPsPLHUTqo,399
-fastmcp/client/auth/oauth.py,sha256=8B1HTPoPhEFQUZBfuhR6jqq4CHu6BDATVowC3ayZmg8,12513
+fastmcp/client/auth/oauth.py,sha256=PXtWFFSqR29QZ_ZYk74EIRHdj_qOGP2yerXb0HDw2ns,12745
 fastmcp/client/sampling/__init__.py,sha256=jaquyp7c5lz4mczv0d5Skl153uWrnXVcS4qCmbjLKRY,2208
 fastmcp/client/sampling/handlers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fastmcp/client/sampling/handlers/anthropic.py,sha256=LjxTYzIWOnbJwJDHJOkRybW0dXBcyt2c7B4sCaG3uLM,14318
@@ -61,19 +61,19 @@ fastmcp/resources/resource_manager.py,sha256=yG3EieKY9DqIcYTIFJkSJlRoXeffV6mTOnW
 fastmcp/resources/template.py,sha256=MSAK46bYk74nqJTQ923xb4KETlof9clfg_QaqLrJX_Y,15495
 fastmcp/resources/types.py,sha256=efFLGD1Xc5Xq3sxlPaZ_8gtJ2UOixueTBV4KQTi4cOU,4936
 fastmcp/server/__init__.py,sha256=qxNmIJcqsrpxpUvCv0mhdEAaUn1UZd1xLd8XRoWUlfY,119
-fastmcp/server/context.py,sha256=nd0bME6I7aB9RlKiESNBay97P8yDHJJ-IcjVCbkc7bc,42256
+fastmcp/server/context.py,sha256=vivwwI4u7RuaYMivQ0IlqqHDQxZo682ZMckt-5muC3A,43187
 fastmcp/server/dependencies.py,sha256=gRc60PhEvna9rlqMW-ZlYNszPlUeEeOWT5winYGNH2A,20928
 fastmcp/server/elicitation.py,sha256=CmHi_SERmhEcNjwnM90_HGihUKlCM3RPGHI0uns2t7M,17912
 fastmcp/server/event_store.py,sha256=ZiBbrUQHw9--G8lzK1qLZmUAF2le2XchFen4pGbFKsE,6170
-fastmcp/server/http.py,sha256=_HjMSYWH8mfKugDODU4iV0AhKDU2VRc40tS56L6i-_s,12737
-fastmcp/server/low_level.py,sha256=o3jDf5SuZBQeurhLWRzaSVCnvrmaKMH_w-TbHk6BuZ4,7963
+fastmcp/server/http.py,sha256=mQnb9moDqgzqgo-H30Qii6EcOSMhPjrh4rL3zr5ES4g,12469
+fastmcp/server/low_level.py,sha256=afTlucPVSOaG9N68D8CGZh4oU1tc9g_IpLfX7crZB4o,9000
 fastmcp/server/proxy.py,sha256=bsgVkcdlRtVK3bB4EeVKrq4PLjIoUvWN_hgzr1hq8yE,26837
-fastmcp/server/server.py,sha256=3RmmJT2vM-ycXces_L6ORSQqlQvzMVITu37dCgqp-Ao,121385
+fastmcp/server/server.py,sha256=HCUJBE0E47gOx_f1o6XJn5U-JChc_wlKtFK5EIDnNjc,121332
 fastmcp/server/auth/__init__.py,sha256=MTZvDKEUMqjs9-raRN0h8Zjx8pWFXs_iSRbB1UqBUqU,527
 fastmcp/server/auth/auth.py,sha256=Bvm98USOP0A0yTckKCN7yHJHS4JgCG804W5cQx6GgO4,20430
 fastmcp/server/auth/jwt_issuer.py,sha256=lJYvrpC1ygI4jkoJlL_nTH6m7FKdTw2lbEycKo4eHLY,7197
 fastmcp/server/auth/middleware.py,sha256=xwj3fUCLSlJK6n1Ehp-FN1qnjKqEz8b7LGAGMTqQ8Hk,3284
-fastmcp/server/auth/oauth_proxy.py,sha256=c5BAyT07t3vZtfD9wCoN4f8hnSD1F5e0kCMqlUuO_00,93364
+fastmcp/server/auth/oauth_proxy.py,sha256=pEvYQAhTRT6eiIkK4eG5VnlOIr7fnHSEDO803ULCP5Q,94785
 fastmcp/server/auth/oidc_proxy.py,sha256=gU_RgBbVMj-9vn0TSRTmT1YaT19VFmJLpARcIXn208k,17969
 fastmcp/server/auth/redirect_validation.py,sha256=Jlhela9xpTbw4aWnQ04A5Z-TW0HYOC3f9BMsq3NXx1Q,2000
 fastmcp/server/auth/handlers/authorize.py,sha256=1zrmXqRUhjiWSHgUhfj0CcCkj3uSlGkTnxHzaic0xYs,11617
@@ -110,31 +110,32 @@ fastmcp/server/sampling/__init__.py,sha256=u9jDHSE_yz6kTzbFqIOXqnM0PfIAiP-peAjHJ
 fastmcp/server/sampling/run.py,sha256=1FIg9TMcvilQcgW0i00xlpgd7Yz6b814ntG3ihtFo6g,10469
 fastmcp/server/sampling/sampling_tool.py,sha256=YltN7-NcMXUk6cFbuOQmuJ980bmQyh83qgFo0TogP5Q,3311
 fastmcp/server/tasks/__init__.py,sha256=VizXvmXgA3SvrApQ6PSz4z1TPA9B6uROvmWeGSYOJ0I,530
-fastmcp/server/tasks/capabilities.py,sha256=-8QMBjs6HZuQdUNmOrNEBvJs-opGptIyxOODU0TGGFE,574
+fastmcp/server/tasks/capabilities.py,sha256=ut7PrKFUPu9FAO9IzqmoS2iQ7ByQWZOAqsMXxyS34dI,1074
 fastmcp/server/tasks/config.py,sha256=msPkUuxnZKuqSj21Eh8m5Cwq0htwUzTCeoWsnbvKGkk,3006
 fastmcp/server/tasks/converters.py,sha256=ON7c8gOMjBYiQoyk_vkymI8J01ccoYzizDwtgIIqIZQ,6701
-fastmcp/server/tasks/handlers.py,sha256=8wiDiP6tHj8E3iMEIpjZmoiY_k1wgQg-F59KwGk56X8,12489
+fastmcp/server/tasks/handlers.py,sha256=1KTyfPgpQ-6YRfiK3s10sqa2pkRB0tR6ZZzb55KLZDk,12884
 fastmcp/server/tasks/keys.py,sha256=w9diycj0N6ViVqe6stxUS9vg2H94bl_614Bu5kNRM-k,3011
-fastmcp/server/tasks/protocol.py,sha256=g97D4k1U8ua_UBTyoqFXcPp5rf6KvuiY5d6mx5KMIPY,12222
-fastmcp/server/tasks/subscriptions.py,sha256=iehPO2zx80aRIqKHCFj9kuR5NVMqYSkIepMXBifQFWw,6692
+fastmcp/server/tasks/protocol.py,sha256=1wmpubpLb5URzz9JMrPSKmoRRtvrYJ_SW16DROAvXQo,12350
+fastmcp/server/tasks/subscriptions.py,sha256=cNJptdgkofJ6Gg8ae92MAkr95aZewxl--l8BE1_ZJ1U,6615
 fastmcp/tools/__init__.py,sha256=XGcaMkBgwr-AHzbNjyjdb3ATgp5TQ0wzSq0nsrBD__E,201
 fastmcp/tools/tool.py,sha256=_l0HEnuTyYxm_xNWYxO2seRnzb6NunvjnEsWQIeKBDY,23394
 fastmcp/tools/tool_manager.py,sha256=_SSHYgKygZaJ86B2pncmBm2Kbj0NLIDrpphsc9qgB3M,5788
 fastmcp/tools/tool_transform.py,sha256=m1XDYuu_BDPxpH3yRNdT3jCca9KmVSO-Jd00BK4F5rw,38099
 fastmcp/utilities/__init__.py,sha256=-imJ8S-rXmbXMWeDamldP-dHDqAPg_wwmPVz-LNX14E,31
 fastmcp/utilities/auth.py,sha256=ZVHkNb4YBpLE1EmmFyhvFB2qfWDZdEYNH9TRI9jylOE,1140
-fastmcp/utilities/cli.py,sha256=qjZtF9LvReKDOaLDIzcWWErMpWUBA8-Uvml8H4upuqs,11515
+fastmcp/utilities/cli.py,sha256=QPYbVJnH0oNmGbo-vg-3nhqr-zJYSxJfsF7r2n9uQXc,12455
 fastmcp/utilities/components.py,sha256=fF4M9cdqbZTlDAZ0hltcTTg_8IU2jNSzOyH4oqH49ig,6087
 fastmcp/utilities/exceptions.py,sha256=7Z9j5IzM5rT27BC1Mcn8tkS-bjqCYqMKwb2MMTaxJYU,1350
 fastmcp/utilities/http.py,sha256=1ns1ymBS-WSxbZjGP6JYjSO52Wa_ls4j4WbnXiupoa4,245
 fastmcp/utilities/inspect.py,sha256=3wYUuQH1xCCCdzZwALHNqaRABH6iqpA43dIXEhqVb5Q,18030
-fastmcp/utilities/json_schema.py,sha256=H8RNucfulnXqYjCzRrlaWCBfToHmJGc7M32VJu5q7Eo,10587
+fastmcp/utilities/json_schema.py,sha256=rhSub4bxP_ACW8VJu1SoQCbL32wQNV8PUJlzt1uUR5g,15701
 fastmcp/utilities/json_schema_type.py,sha256=5cf1ZeHzqirrGx62kznqmgAWk0uCc29REVKcDRBeJX0,22348
 fastmcp/utilities/logging.py,sha256=61wVk5yQ62km3K8kZtkKtT_3EN26VL85GYW0aMtnwKA,7175
 fastmcp/utilities/mcp_config.py,sha256=lVllZtAXZ3Zy78D40aXN-S5fs-ms0lgryL1tY2WzwCY,1783
 fastmcp/utilities/tests.py,sha256=VIsYPpk07tXvE02yK_neBUeZgu5YtbUlK6JJNzU-6lQ,9229
 fastmcp/utilities/types.py,sha256=7c56m736JjbKY-YP7RLWPZcsW5Z7mikpByKaDQ5IJwg,17586
 fastmcp/utilities/ui.py,sha256=gcnha7Vj4xEBxdrS83EZlKpN_43AQzcgiZFEvkTqzqg,14252
+fastmcp/utilities/version_check.py,sha256=zjY2HaSW4f09Gjun3V6TLyaeJC_ZPPf16VvQAdDigO8,4419
 fastmcp/utilities/mcp_server_config/__init__.py,sha256=hHBxEwRsrgN0Q-1bvj28X6UVGDpfG6dt3yfSBGsOY80,791
 fastmcp/utilities/mcp_server_config/v1/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fastmcp/utilities/mcp_server_config/v1/mcp_server_config.py,sha256=1B3J7sRR0GcOW6FcSNNTTTOtEePNhUKc7Y0xEDk-wao,15497
@@ -153,8 +154,8 @@ fastmcp/utilities/openapi/json_schema_converter.py,sha256=PxaYpgHBsdDTT0XSP6s4RZ
 fastmcp/utilities/openapi/models.py,sha256=-kfndwZSe92tVtKAgOuFn5rk1tN7oydCZKtLOEMEalA,2805
 fastmcp/utilities/openapi/parser.py,sha256=qsa68Ro1c8ov77kdEP20IwZqD74E4IGKjtfeIkn3HdE,34338
 fastmcp/utilities/openapi/schemas.py,sha256=UXHHjkJyDp1WwJ8kowYt79wnwdbDwAbUFfqwcIY6mIM,23359
-fastmcp-2.14.2.dist-info/METADATA,sha256=pKt4x3lDwdG_CrWNz0oKxcuCYizqMuhFpUjK1vQsdCQ,20771
-fastmcp-2.14.2.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-fastmcp-2.14.2.dist-info/entry_points.txt,sha256=ff8bMtKX1JvXyurMibAacMSKbJEPmac9ffAKU9mLnM8,44
-fastmcp-2.14.2.dist-info/licenses/LICENSE,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
-fastmcp-2.14.2.dist-info/RECORD,,
+fastmcp-2.14.4.dist-info/METADATA,sha256=R9PnAzkKHt-74_BnjfswvaVfvKdrjLvizrwLj2SUgJA,20840
+fastmcp-2.14.4.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+fastmcp-2.14.4.dist-info/entry_points.txt,sha256=ff8bMtKX1JvXyurMibAacMSKbJEPmac9ffAKU9mLnM8,44
+fastmcp-2.14.4.dist-info/licenses/LICENSE,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
+fastmcp-2.14.4.dist-info/RECORD,,