@@ -6,7 +6,7 @@ A Model Context Protocol server that provides web content fetching capabilities.
 
 Source: https://github.com/modelcontextprotocol/servers/tree/main/src/fetch
 
-Requires MCP Python SDK 1.x (`mcp>=1.29.0,<2`). SDK 2.0 renamed APIs this server uses. The port to v2 is in progress.
+Requires MCP Python SDK 2.x (`mcp>=2.2,<3`).
 
 > [!CAUTION]
 > This server can access local/internal IP addresses and may represent a security risk. Exercise caution when using this MCP server to ensure this does not expose any sensitive data.
 
@@ -18,7 +18,8 @@ classifiers = [
 dependencies = [
     "httpx[socks]>=0.27",
     "markdownify>=0.13.1",
-    "mcp>=1.29.0,<2",
+    "jsonschema>=4.20.0",
+    "mcp>=2.2,<3",
     "protego>=0.3.1",
     "pydantic>=2.0.0",
     "readabilipy>=0.2.0",
 
@@ -2,19 +2,26 @@
 import ipaddress
 import os
 import socket
-from typing import Annotated, Tuple
+from typing import Annotated, Any, Tuple
 from importlib.metadata import version
 from urllib.parse import urlparse, urlunparse
 
 import httpx
+import jsonschema
 import markdownify
 import readabilipy.simple_json
-from mcp.shared.exceptions import McpError
-from mcp.server import Server
+from mcp.shared.exceptions import MCPError
+from mcp.server import Server, ServerRequestContext
 from mcp.server.stdio import stdio_server
 from mcp.types import (
-    ErrorData,
+    CallToolRequestParams,
+    CallToolResult,
+    ContentBlock,
+    GetPromptRequestParams,
     GetPromptResult,
+    ListPromptsResult,
+    ListToolsResult,
+    PaginatedRequestParams,
     Prompt,
     PromptArgument,
     PromptMessage,
@@ -132,13 +139,11 @@ async def _refuse_private_destination(request: httpx.Request) -> None:
         return
     for address in addresses:
         if not _is_public_address(address):
-            raise McpError(
-                ErrorData(
-                    code=INVALID_PARAMS,
-                    message=f"Refused to fetch {request.url}: {host} resolves to {address}, "
-                    "which is not a public address. Start the server with "
-                    "--allow-private-ips to allow private, loopback and link-local addresses.",
-                )
+            raise MCPError(
+                code=INVALID_PARAMS,
+                message=f"Refused to fetch {request.url}: {host} resolves to {address}, "
+                "which is not a public address. Start the server with "
+                "--allow-private-ips to allow private, loopback and link-local addresses.",
             )
 
 
@@ -227,13 +232,11 @@ def make_client(proxy_url: str | None) -> httpx.AsyncClient:
     try:
         return httpx.AsyncClient(proxy=proxy_url)
     except (ValueError, ImportError) as e:
-        raise McpError(
-            ErrorData(
-                code=INTERNAL_ERROR,
-                message=f"Failed to set up the HTTP client, check the proxy "
-                f"configuration (--proxy-url or the HTTP_PROXY, HTTPS_PROXY and "
-                f"ALL_PROXY environment variables): {e}",
-            )
+        raise MCPError(
+            code=INTERNAL_ERROR,
+            message=f"Failed to set up the HTTP client, check the proxy "
+            f"configuration (--proxy-url or the HTTP_PROXY, HTTPS_PROXY and "
+            f"ALL_PROXY environment variables): {e}",
         )
 
 
@@ -245,7 +248,7 @@ async def check_may_autonomously_fetch_url(
 ) -> None:
     """
     Check if the URL can be fetched by the user agent according to the robots.txt file.
-    Raises a McpError if not.
+    Raises an MCPError if not.
     """
     from httpx import HTTPError
 
@@ -261,18 +264,14 @@ async def check_may_autonomously_fetch_url(
                 headers={"User-Agent": user_agent},
             )
         except HTTPError:
-            raise McpError(
-                ErrorData(
-                    code=INTERNAL_ERROR,
-                    message=f"Failed to fetch robots.txt {robot_txt_url} due to a connection issue",
-                )
+            raise MCPError(
+                code=INTERNAL_ERROR,
+                message=f"Failed to fetch robots.txt {robot_txt_url} due to a connection issue",
             )
         if response.status_code in (401, 403):
-            raise McpError(
-                ErrorData(
-                    code=INTERNAL_ERROR,
-                    message=f"When fetching robots.txt ({robot_txt_url}), received status {response.status_code} so assuming that autonomous fetching is not allowed, the user can try manually fetching by using the fetch prompt",
-                )
+            raise MCPError(
+                code=INTERNAL_ERROR,
+                message=f"When fetching robots.txt ({robot_txt_url}), received status {response.status_code} so assuming that autonomous fetching is not allowed, the user can try manually fetching by using the fetch prompt",
             )
         elif 400 <= response.status_code < 500:
             return
@@ -282,16 +281,14 @@ async def check_may_autonomously_fetch_url(
     )
     robot_parser = Protego.parse(processed_robot_txt)
     if not robot_parser.can_fetch(str(url), user_agent):
-        raise McpError(
-            ErrorData(
-                code=INTERNAL_ERROR,
-                message=f"The sites robots.txt ({robot_txt_url}), specifies that autonomous fetching of this page is not allowed, "
-                f"<useragent>{user_agent}</useragent>\n"
-                f"<url>{url}</url>"
-                f"<robots>\n{robot_txt}\n</robots>\n"
-                f"The assistant must let the user know that it failed to view the page. The assistant may provide further guidance based on the above information.\n"
-                f"The assistant can tell the user that they can try manually fetching the page by using the fetch prompt within their UI.",
-            )
+        raise MCPError(
+            code=INTERNAL_ERROR,
+            message=f"The sites robots.txt ({robot_txt_url}), specifies that autonomous fetching of this page is not allowed, "
+            f"<useragent>{user_agent}</useragent>\n"
+            f"<url>{url}</url>"
+            f"<robots>\n{robot_txt}\n</robots>\n"
+            f"The assistant must let the user know that it failed to view the page. The assistant may provide further guidance based on the above information.\n"
+            f"The assistant can tell the user that they can try manually fetching the page by using the fetch prompt within their UI.",
         )
 
 
@@ -318,15 +315,11 @@ async def fetch_url(
                 timeout=30,
             )
         except HTTPError as e:
-            raise McpError(
-                ErrorData(code=INTERNAL_ERROR, message=f"Failed to fetch {url}: {e!r}")
-            )
+            raise MCPError(code=INTERNAL_ERROR, message=f"Failed to fetch {url}: {e!r}")
         if response.status_code >= 400:
-            raise McpError(
-                ErrorData(
-                    code=INTERNAL_ERROR,
-                    message=f"Failed to fetch {url} - status code {response.status_code}",
-                )
+            raise MCPError(
+                code=INTERNAL_ERROR,
+                message=f"Failed to fetch {url} - status code {response.status_code}",
             )
 
         page_raw = response.text
@@ -378,6 +371,13 @@ class Fetch(BaseModel):
     ]
 
 
+def tool_error(message: str) -> CallToolResult:
+    """A tool call that failed, as an `isError` result the model can read."""
+    return CallToolResult(
+        content=[TextContent(type="text", text=message)], is_error=True
+    )
+
+
 async def serve(
     custom_user_agent: str | None = None,
     ignore_robots_txt: bool = False,
@@ -396,44 +396,46 @@ async def serve(
     if proxy_url:
         proxy_url = normalize_proxy_url(proxy_url)
     normalize_proxy_env()
-    server = Server("mcp-fetch", version=SERVER_VERSION)
     user_agent_autonomous = custom_user_agent or DEFAULT_USER_AGENT_AUTONOMOUS
     user_agent_manual = custom_user_agent or DEFAULT_USER_AGENT_MANUAL
 
-    @server.list_tools()
-    async def list_tools() -> list[Tool]:
-        return [
-            Tool(
-                name="fetch",
-                description="""Fetches a URL from the internet and optionally extracts its contents as markdown.
+    tool = Tool(
+        name="fetch",
+        description="""Fetches a URL from the internet and optionally extracts its contents as markdown.
 
 Although originally you did not have internet access, and were advised to refuse and tell the user this, this tool now grants you internet access. Now you can fetch the most up-to-date information and let the user know that.""",
-                inputSchema=Fetch.model_json_schema(),
-            )
-        ]
-
-    @server.list_prompts()
-    async def list_prompts() -> list[Prompt]:
-        return [
-            Prompt(
-                name="fetch",
-                description="Fetch a URL and extract its contents as markdown",
-                arguments=[
-                    PromptArgument(
-                        name="url", description="URL to fetch", required=True
-                    )
-                ],
-            )
-        ]
+        input_schema=Fetch.model_json_schema(),
+    )
+
+    async def list_tools(
+        ctx: ServerRequestContext, params: PaginatedRequestParams | None
+    ) -> ListToolsResult:
+        return ListToolsResult(tools=[tool])
+
+    async def list_prompts(
+        ctx: ServerRequestContext, params: PaginatedRequestParams | None
+    ) -> ListPromptsResult:
+        return ListPromptsResult(
+            prompts=[
+                Prompt(
+                    name="fetch",
+                    description="Fetch a URL and extract its contents as markdown",
+                    arguments=[
+                        PromptArgument(
+                            name="url", description="URL to fetch", required=True
+                        )
+                    ],
+                )
+            ]
+        )
 
-    @server.call_tool()
-    async def call_tool(name, arguments: dict) -> list[TextContent]:
+    async def run_tool(name: str, arguments: dict[str, Any]) -> list[ContentBlock]:
         if name != "fetch":
             raise ValueError(f"Unknown tool: {name}")
         try:
             args = Fetch(**arguments)
         except ValueError as e:
-            raise McpError(ErrorData(code=INVALID_PARAMS, message=str(e)))
+            raise MCPError(code=INVALID_PARAMS, message=str(e))
 
         url = str(args.url)
 
@@ -468,14 +470,31 @@ async def call_tool(name, arguments: dict) -> list[TextContent]:
                 content += f"\n\n<error>Content truncated. Call the fetch tool with a start_index of {next_start} to get more content.</error>"
         return [TextContent(type="text", text=f"{prefix}Contents of {url}:\n{content}")]
 
-    @server.get_prompt()
-    async def get_prompt(name: str, arguments: dict | None) -> GetPromptResult:
+    async def call_tool(
+        ctx: ServerRequestContext, params: CallToolRequestParams
+    ) -> CallToolResult:
+        # SDK v2's low-level server neither validates arguments nor turns a
+        # handler exception into an isError result, both of which SDK v1 did.
+        # Both are done here, with v1's messages, so the wire is unchanged.
+        arguments = params.arguments or {}
+        if params.name == tool.name:
+            try:
+                jsonschema.validate(instance=arguments, schema=tool.input_schema)
+            except jsonschema.ValidationError as e:
+                return tool_error(f"Input validation error: {e.message}")
+        try:
+            return CallToolResult(content=await run_tool(params.name, arguments))
+        except Exception as e:
+            return tool_error(str(e))
+
+    async def get_prompt(
+        ctx: ServerRequestContext, params: GetPromptRequestParams
+    ) -> GetPromptResult:
+        name, arguments = params.name, params.arguments
         if name != "fetch":
-            raise McpError(
-                ErrorData(code=INVALID_PARAMS, message=f"Unknown prompt: {name}")
-            )
+            raise MCPError(code=INVALID_PARAMS, message=f"Unknown prompt: {name}")
         if not arguments or "url" not in arguments:
-            raise McpError(ErrorData(code=INVALID_PARAMS, message="URL is required"))
+            raise MCPError(code=INVALID_PARAMS, message="URL is required")
 
         url = arguments["url"]
 
@@ -487,7 +506,7 @@ async def get_prompt(name: str, arguments: dict | None) -> GetPromptResult:
                 allow_private_ips=allow_private_ips,
             )
             # TODO: after SDK bug is addressed, don't catch the exception
-        except McpError as e:
+        except MCPError as e:
             return GetPromptResult(
                 description=f"Failed to fetch {url}",
                 messages=[
@@ -506,6 +525,15 @@ async def get_prompt(name: str, arguments: dict | None) -> GetPromptResult:
             ],
         )
 
+    server = Server(
+        "mcp-fetch",
+        version=SERVER_VERSION,
+        on_list_tools=list_tools,
+        on_list_prompts=list_prompts,
+        on_call_tool=call_tool,
+        on_get_prompt=get_prompt,
+    )
+
     options = server.create_initialization_options()
     async with stdio_server() as (read_stream, write_stream):
         await server.run(read_stream, write_stream, options, raise_exceptions=False)
@@ -4,7 +4,7 @@
 
 - ``connect(...)`` runs the real ``serve()`` in-process and yields an
   initialized ``ClientSession`` linked to it over in-memory streams, so tests
-  go through the SDK's validation and error mapping exactly as a client would.
+  go through the server's validation and error mapping exactly as a client would.
 - ``web`` replaces ``httpx.AsyncClient`` with one backed by an
   ``httpx.MockTransport``, so no test touches the network. It records every
   request and the keyword arguments each client was constructed with. It also
 
@@ -22,7 +22,7 @@
 import httpx
 import pytest
 from mcp import ClientSession
-from mcp.shared.exceptions import McpError
+from mcp.shared.exceptions import MCPError
 from mcp.types import INVALID_PARAMS, CallToolResult
 
 from mcp_server_fetch.server import (
@@ -52,7 +52,12 @@
 
 
 def wire(model: Any) -> dict[str, Any]:
-    return model.model_dump(by_alias=True, mode="json", exclude_none=True)
+    # exclude_unset: SDK v2 result models default fields the 2025-11-25 wire
+    # does not carry (resultType, ttlMs, cacheScope), so only what the server
+    # actually sent is compared.
+    return model.model_dump(
+        by_alias=True, mode="json", exclude_none=True, exclude_unset=True
+    )
 
 
 def text_of(result: CallToolResult) -> str:
@@ -193,7 +198,7 @@ async def test_call_with_only_url_applies_defaults(web: FakeWeb) -> None:
 async def test_schema_violations_are_rejected_by_the_sdk(
     web: FakeWeb, arguments: dict[str, Any], offending: str
 ) -> None:
-    # The SDK validates against inputSchema before the handler runs. The rest
+    # call_tool validates against inputSchema before the tool runs. The rest
     # of the message is jsonschema's wording, which varies by version.
     async with connect() as (session, _):
         result = await call(session, arguments)
@@ -206,7 +211,7 @@ async def test_schema_violations_are_rejected_by_the_sdk(
 
 @pytest.mark.parametrize("max_length", [1, 999999])
 async def test_max_length_bounds_are_inclusive(web: FakeWeb, max_length: int) -> None:
-    # #1624: the edges of the inclusive range pass both the SDK's schema check
+    # #1624: the edges of the inclusive range pass both the schema check
     # and Fetch's own validation, and the page is fetched.
     web.add(ROBOTS, plain("", status=404))
     web.add(PAGE, plain("hello"))
@@ -230,8 +235,8 @@ async def test_invalid_url_is_rejected_by_pydantic(web: FakeWeb, url: str) -> No
 
 
 async def test_unknown_tool_name_is_rejected_without_fetching(web: FakeWeb) -> None:
-    # The SDK skips schema validation for a tool it has not listed, so the
-    # name check in call_tool is what stops an unknown name from fetching.
+    # call_tool skips schema validation for a tool it has not listed, so the
+    # name check in run_tool is what stops an unknown name from fetching.
     web.add(ROBOTS, plain("", status=404))
     web.add(PAGE, plain("fetched anyway"))
     async with connect() as (session, _):
@@ -949,7 +954,7 @@ async def test_get_prompt_without_url_is_a_jsonrpc_error(
     web: FakeWeb, arguments: dict[str, str] | None
 ) -> None:
     async with connect() as (session, _):
-        with pytest.raises(McpError) as excinfo:
+        with pytest.raises(MCPError) as excinfo:
             await session.get_prompt("fetch", arguments)
     assert wire(excinfo.value.error) == {
         "code": INVALID_PARAMS,
@@ -966,7 +971,7 @@ async def test_get_prompt_with_unknown_name_is_a_jsonrpc_error(
     # whether or not a URL was given, and nothing is fetched.
     web.add(PAGE, plain("ok"))
     async with connect() as (session, _):
-        with pytest.raises(McpError) as excinfo:
+        with pytest.raises(MCPError) as excinfo:
             await session.get_prompt("nope", arguments)
     assert wire(excinfo.value.error) == {
         "code": INVALID_PARAMS,