Resolve type hints for callable-object tools in resolver detection

find_resolved_parameters called typing.get_type_hints on the callable
directly, which raises for a callable instance (an object with __call__),
breaking tool registration for callable objects. Resolve hints off __call__
and tolerate unresolvable hints, mirroring find_context_parameter.

Author: Kludex

src/mcp/server/mcpserver/resolve.py

@@ -85,16 +85,30 @@ def __init__(self, fn: Callable[..., Any], params: dict[str, _ParamPlan], is_asy
         self.is_async = is_async
 
 
+def _type_hints(fn: Callable[..., Any]) -> dict[str, Any]:
+    """Resolve type hints for a function or a callable object.
+
+    `typing.get_type_hints` raises on a callable *instance*; fall back to its
+    `__call__`. Returns an empty mapping when hints cannot be resolved, matching
+    `find_context_parameter`'s tolerance so callables without annotations (or with
+    unresolvable ones) simply have no resolved parameters.
+    """
+    target = fn if inspect.isroutine(fn) else getattr(type(fn), "__call__", fn)
+    try:
+        return typing.get_type_hints(target, include_extras=True)
+    except Exception:
+        return {}
+
+
 def find_resolved_parameters(fn: Callable[..., Any]) -> dict[str, tuple[Resolve, bool]]:
     """Find parameters of `fn` annotated `Annotated[_, Resolve(...)]`.
 
     Returns a mapping of parameter name to `(Resolve, wants_union)`, where
     `wants_union` is True when the annotated type is an `ElicitationResult` member
     (the consumer wants the full outcome rather than the unwrapped model).
     """
-    hints = typing.get_type_hints(fn, include_extras=True)
     resolved: dict[str, tuple[Resolve, bool]] = {}
-    for name, annotation in hints.items():
+    for name, annotation in _type_hints(fn).items():
         if get_origin(annotation) is not Annotated:
             continue
         type_arg, *metadata = get_args(annotation)
@@ -130,7 +144,7 @@ def analyze(fn: Callable[..., Any], stack: tuple[int, ...]) -> None:
         if key in plans:
             return
 
-        hints = typing.get_type_hints(fn, include_extras=True)
+        hints = _type_hints(fn)
         sig = inspect.signature(fn)
         params: dict[str, _ParamPlan] = {}
         nested: list[Callable[..., Any]] = []

tests/server/mcpserver/test_resolve.py

@@ -17,6 +17,7 @@
     Resolve,
 )
 from mcp.server.mcpserver.exceptions import InvalidSignature
+from mcp.server.mcpserver.resolve import find_resolved_parameters
 from mcp.server.mcpserver.tools.base import Tool
 from mcp.types import ElicitRequestParams, ElicitResult, TextContent
 
@@ -254,6 +255,14 @@ async def tool(value: Annotated[Login, Resolve(a)]) -> str:
         Tool.from_function(tool)
 
 
+def test_find_resolved_parameters_tolerates_unresolvable_hints():
+    def fn(x: int) -> int:
+        return x  # pragma: no cover
+
+    fn.__annotations__["x"] = "DoesNotExist"
+    assert find_resolved_parameters(fn) == {}
+
+
 def test_unresolvable_resolver_param_raises_at_registration():
     async def login(mystery: int) -> Login:
         return Login(username="x")  # pragma: no cover