fix: wrapped annotations handling in func_metadata

Use the original function's __globals__ for type hint resolution
when dealing with wrapped functions. This ensures that any type hints
defined in the original function's module are correctly resolved.

This also includes adding common typing names for resiliency.

Fixes #1391

Author: stevenh

src/mcp/server/fastmcp/utilities/func_metadata.py

@@ -470,18 +470,27 @@ def try_eval_type(value: Any, globalns: dict[str, Any], localns: dict[str, Any])
 
 def _get_typed_signature(call: Callable[..., Any]) -> inspect.Signature:
     """Get function signature while evaluating forward references"""
+
     signature = inspect.signature(call)
-    globalns = getattr(call, "__globals__", {})
+    try:
+        type_hints = get_type_hints(call, include_extras=True)
+    except TypeError:
+        # get_type_hints doesn't handle callable objects.
+        type_hints = {}
+
+    def resolve_annotation(name: str, annotation: Any) -> Any:
+        return type_hints.get(name, annotation) if isinstance(annotation, str) else annotation
+
     typed_params = [
         inspect.Parameter(
             name=param.name,
             kind=param.kind,
             default=param.default,
-            annotation=_get_typed_annotation(param.annotation, globalns),
+            annotation=resolve_annotation(param.name, param.annotation),
         )
         for param in signature.parameters.values()
     ]
-    typed_return = _get_typed_annotation(signature.return_annotation, globalns)
+    typed_return = resolve_annotation("return", signature.return_annotation)
     typed_signature = inspect.Signature(typed_params, return_annotation=typed_return)
     return typed_signature
 

tests/server/fastmcp/test_func_metadata.py

@@ -14,6 +14,8 @@
 
 from mcp.server.fastmcp.utilities.func_metadata import func_metadata
 
+from .test_wrapped import wrapped_function
+
 
 class SomeInputModelA(BaseModel):
     pass
@@ -1094,3 +1096,20 @@ def func_with_reserved_json(
     assert result["json"] == {"nested": "data"}
     assert result["model_dump"] == [1, 2, 3]
     assert result["normal"] == "plain string"
+
+
+@pytest.mark.anyio
+async def test_wrapped_annotations_func() -> None:
+    """Test that func_metadata works with wrapped annotations functions."""
+    meta = func_metadata(wrapped_function)
+
+    result = await meta.call_fn_with_arg_validation(
+        wrapped_function,
+        fn_is_async=False,
+        arguments_to_validate={
+            "literal": "test",
+        },
+        arguments_to_pass_directly=None,
+    )
+
+    assert result == "test"

tests/server/fastmcp/test_instrument.py

@@ -0,0 +1,21 @@
+from collections.abc import Callable
+from functools import wraps
+from typing import TypeVar
+
+from typing_extensions import ParamSpec
+
+P = ParamSpec("P")
+R = TypeVar("R")
+
+
+def instrument(func: Callable[P, R]) -> Callable[P, R]:
+    """
+    Example decorator that logs before/after the call
+    while preserving the original function's type signature.
+    """
+
+    @wraps(func)
+    def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
+        return func(*args, **kwargs)
+
+    return wrapper

tests/server/fastmcp/test_wrapped.py

@@ -0,0 +1,10 @@
+from __future__ import annotations
+
+from typing import Literal
+
+from .test_instrument import instrument
+
+
+@instrument
+def wrapped_function(literal: Literal["test"] | None = None) -> Literal["test"] | None:
+    return literal