fix: remove deprecation code

Author: maxisbey

src/mcp/server/lowlevel/func_inspection.py

@@ -1,72 +1,54 @@
 import inspect
-import warnings
 from collections.abc import Callable
 from typing import Any, TypeVar, get_type_hints
 
-
-def issue_deprecation_warning(func: Callable[..., Any], request_type: type) -> None:
-    """
-    Issue a deprecation warning for handlers that don't use the new request parameter style.
-    """
-    func_name = getattr(func, "__name__", str(func))
-    warnings.warn(
-        f"Handler '{func_name}' should accept a '{request_type.__name__}' parameter. "
-        "Support for handlers without this parameter will be removed in a future version.",
-        DeprecationWarning,
-        stacklevel=4,
-    )
-
-
 T = TypeVar("T")
 R = TypeVar("R")
 
 
-def create_call_wrapper(func: Callable[..., R], request_type: type[T]) -> tuple[Callable[[T], R], bool]:
+def create_call_wrapper(func: Callable[..., R], request_type: type[T]) -> Callable[[T], R]:
     """
     Create a wrapper function that knows how to call func with the request object.
 
-    Returns a tuple of (wrapper_func, should_deprecate):
-    - wrapper_func: A function that takes the request and calls func appropriately
-    - should_deprecate: True if a deprecation warning should be issued
+    Returns a wrapper function that takes the request and calls func appropriately.
 
     The wrapper handles three calling patterns:
     1. Positional-only parameter typed as request_type (no default): func(req)
     2. Positional/keyword parameter typed as request_type (no default): func(**{param_name: req})
-    3. No request parameter or parameter with default (deprecated): func()
+    3. No request parameter or parameter with default: func()
     """
     try:
         sig = inspect.signature(func)
         type_hints = get_type_hints(func)
     except (ValueError, TypeError, NameError):
-        # Can't inspect signature or resolve type hints, assume no request parameter (deprecated)
-        return lambda _: func(), True
+        return lambda _: func()
 
     # Check for positional-only parameter typed as request_type
     for param_name, param in sig.parameters.items():
         if param.kind == inspect.Parameter.POSITIONAL_ONLY:
             param_type = type_hints.get(param_name)
             if param_type == request_type:
-                # Check if it has a default - if so, treat as old style (deprecated)
+                # Check if it has a default - if so, treat as old style
                 if param.default is not inspect.Parameter.empty:
-                    return lambda _: func(), True
+                    return lambda _: func()
                 # Found positional-only parameter with correct type and no default
-                return lambda req: func(req), False
+                return lambda req: func(req)
 
     # Check for any positional/keyword parameter typed as request_type
     for param_name, param in sig.parameters.items():
         if param.kind in (inspect.Parameter.POSITIONAL_OR_KEYWORD, inspect.Parameter.KEYWORD_ONLY):
             param_type = type_hints.get(param_name)
             if param_type == request_type:
-                # Check if it has a default - if so, treat as old style (deprecated)
+                # Check if it has a default - if so, treat as old style
                 if param.default is not inspect.Parameter.empty:
-                    return lambda _: func(), True
+                    return lambda _: func()
 
                 # Found keyword parameter with correct type and no default
                 # Need to capture param_name in closure properly
                 def make_keyword_wrapper(name: str) -> Callable[[Any], Any]:
                     return lambda req: func(**{name: req})
 
-                return make_keyword_wrapper(param_name), False
+                return make_keyword_wrapper(param_name)
 
-    # No request parameter found - use old style (deprecated)
-    return lambda _: func(), True
+    # No request parameter found - use old style
+    return lambda _: func()

src/mcp/server/lowlevel/server.py

@@ -236,11 +236,7 @@ def decorator(
         ):
             logger.debug("Registering handler for PromptListRequest")
 
-            # Create wrapper that knows how to call func with the request
-            wrapper, _ = create_call_wrapper(func, types.ListPromptsRequest)
-
-            # if should_deprecate:
-            #     issue_deprecation_warning(func, types.ListPromptsRequest)
+            wrapper = create_call_wrapper(func, types.ListPromptsRequest)
 
             async def handler(req: types.ListPromptsRequest):
                 result = await wrapper(req)
@@ -278,12 +274,7 @@ def decorator(
         ):
             logger.debug("Registering handler for ListResourcesRequest")
 
-            # Create wrapper that knows how to call func with the request
-            wrapper, _ = create_call_wrapper(func, types.ListResourcesRequest)
-
-            # TODO: Decide whether we want this sort of deprecation in a later PR
-            # if should_deprecate:
-            #     issue_deprecation_warning(func, types.ListResourcesRequest)
+            wrapper = create_call_wrapper(func, types.ListResourcesRequest)
 
             async def handler(req: types.ListResourcesRequest):
                 result = await wrapper(req)
@@ -416,12 +407,7 @@ def decorator(
         ):
             logger.debug("Registering handler for ListToolsRequest")
 
-            # Create wrapper that knows how to call func with the request
-            wrapper, _ = create_call_wrapper(func, types.ListToolsRequest)
-
-            # TODO: Decide whether we want this sort of deprecation in a later PR
-            # if should_deprecate:
-            #     issue_deprecation_warning(func, types.ListToolsRequest)
+            wrapper = create_call_wrapper(func, types.ListToolsRequest)
 
             async def handler(req: types.ListToolsRequest):
                 result = await wrapper(req)