Integrate FastMCP

This commit integrates FastMCP, a high-level MCP server implementation originally written by Jeremiah Lowin,
into the official MCP SDK. It also updates dependencies and adds new dev dependencies.
It moves the existing SDK into a .lowlevel .

src/mcp/server/fastmcp/tools/base.py

@@ -0,0 +1,82 @@
+import mcp.server.fastmcp
+from mcp.server.fastmcp.exceptions import ToolError
+from mcp.server.fastmcp.utilities.func_metadata import func_metadata, FuncMetadata
+from pydantic import BaseModel, Field
+
+
+import inspect
+from typing import TYPE_CHECKING, Any, Callable
+
+if TYPE_CHECKING:
+    from mcp.server.fastmcp.server import Context
+
+
+class Tool(BaseModel):
+    """Internal tool registration info."""
+
+    fn: Callable = Field(exclude=True)
+    name: str = Field(description="Name of the tool")
+    description: str = Field(description="Description of what the tool does")
+    parameters: dict = Field(description="JSON schema for tool parameters")
+    fn_metadata: FuncMetadata = Field(
+        description="Metadata about the function including a pydantic model for tool arguments"
+    )
+    is_async: bool = Field(description="Whether the tool is async")
+    context_kwarg: str | None = Field(
+        None, description="Name of the kwarg that should receive context"
+    )
+
+    @classmethod
+    def from_function(
+        cls,
+        fn: Callable,
+        name: str | None = None,
+        description: str | None = None,
+        context_kwarg: str | None = None,
+    ) -> "Tool":
+        """Create a Tool from a function."""
+        func_name = name or fn.__name__
+
+        if func_name == "<lambda>":
+            raise ValueError("You must provide a name for lambda functions")
+
+        func_doc = description or fn.__doc__ or ""
+        is_async = inspect.iscoroutinefunction(fn)
+
+        # Find context parameter if it exists
+        if context_kwarg is None:
+            sig = inspect.signature(fn)
+            for param_name, param in sig.parameters.items():
+                if param.annotation is mcp.server.fastmcp.Context:
+                    context_kwarg = param_name
+                    break
+
+        func_arg_metadata = func_metadata(
+            fn,
+            skip_names=[context_kwarg] if context_kwarg is not None else [],
+        )
+        parameters = func_arg_metadata.arg_model.model_json_schema()
+
+        return cls(
+            fn=fn,
+            name=func_name,
+            description=func_doc,
+            parameters=parameters,
+            fn_metadata=func_arg_metadata,
+            is_async=is_async,
+            context_kwarg=context_kwarg,
+        )
+
+    async def run(self, arguments: dict, context: "Context | None" = None) -> Any:
+        """Run the tool with arguments."""
+        try:
+            return await self.fn_metadata.call_fn_with_arg_validation(
+                self.fn,
+                self.is_async,
+                arguments,
+                {self.context_kwarg: context}
+                if self.context_kwarg is not None
+                else None,
+            )
+        except Exception as e:
+            raise ToolError(f"Error executing tool {self.name}: {e}") from e