Unversioned servers report an empty version

The version fallback to the installed mcp package dated to the SDK's
first initialization-options helper and reported the SDK's version as
the server's own. No spec text supports that: the schema requires the
field but says only 'the version of this implementation', and the
ecosystem expectation (spec discussion #1176) is the server's
distributed version. typescript and kotlin require an explicit
identity; go serializes an empty string for an unset version. Align
with go: version='' unless the constructor sets one, and delete the
_package_version helper.

The stamp is now fully deterministic for unversioned servers, so the
unit suites carry it literally in their expectations instead of
stripping it (tests._stamp stays for the dual-era interaction matrix,
whose era split is unrelated), and the matrix conftest's version pin
is gone. Small migration note added: this is a v1-visible behavior
change for servers that never set a version.

Author: maxisbey

docs/advanced/low-level-server.md

@@ -107,7 +107,7 @@ Call it and the result carries both representations:
 }
 ```
 
-The `_meta` block is the server's identity stamp: the SDK adds it to every 2026-era result, with the `version` taken from the constructor or the installed package. A server that must not identify itself can strip the key with a middleware, which owns the results it returns.
+The `_meta` block is the server's identity stamp: the SDK adds it to every 2026-era result, with the `version` from the constructor (a server that sets none reports an empty string). A server that must not identify itself can strip the key with a middleware, which owns the results it returns.
 
 The server never compares the two fields. This SDK's `Client` does: return `structured_content` that doesn't satisfy the `output_schema` you declared and `call_tool` raises a `RuntimeError` that starts with `Invalid structured content returned by tool search_books` and goes on to quote the `jsonschema` failure. Promising a schema is cheap; keeping it is on you. The whole ladder of return types and schemas is in **[Structured Output](../servers/structured-output.md)**.
 

docs/get-started/testing.md

@@ -59,7 +59,7 @@ async def client():  # (2)!
 @pytest.mark.anyio
 async def test_call_add_tool(client: Client):
     result = await client.call_tool("add", {"a": 1, "b": 2})
-    # Ignore the server identity stamp in `_meta`; its `version` tracks the installed package.
+    # Drop the server identity stamp in `_meta`; it is not what this test is about.
     result.meta = None
     assert result == snapshot(
         CallToolResult(

docs/migration.md

@@ -606,6 +606,14 @@ mcp = MCPServer("Demo", instructions="You answer questions about the weather.")
 
 Keep `name` positional and pass everything else by keyword.
 
+### Unversioned servers report an empty version
+
+In v1, a server constructed without a `version` reported the installed `mcp`
+package's version as its own in the `initialize` result's `serverInfo`. In v2
+it reports an empty string instead: the SDK's version is not your server's
+version. Pass `version="..."` to `Server(...)` or `MCPServer(...)` to identify
+your server properly. The field is display-only; nothing breaks either way.
+
 ### `mount_path` parameter removed from MCPServer
 
 The `mount_path` parameter has been removed from `MCPServer.__init__()`, `MCPServer.run()`, `MCPServer.run_sse_async()`, and `MCPServer.sse_app()`. It was also removed from the `Settings` class.

src/mcp/server/lowlevel/server.py

@@ -43,7 +43,6 @@ async def main():
 from contextlib import AbstractAsyncContextManager, asynccontextmanager
 from dataclasses import dataclass
 from functools import cached_property
-from importlib.metadata import version as importlib_version
 from typing import Any, Generic, overload
 
 import mcp_types as types
@@ -126,15 +125,6 @@ async def _ping_handler(ctx: ServerRequestContext[Any], params: types.RequestPar
     return types.EmptyResult()
 
 
-def _package_version(package: str) -> str:
-    try:
-        return importlib_version(package)
-    except Exception:  # pragma: no cover
-        pass
-
-    return "unknown"  # pragma: no cover
-
-
 class Server(Generic[LifespanResultT]):
     @overload
     def __init__(
@@ -549,7 +539,7 @@ def create_initialization_options(
         """
         return InitializationOptions(
             server_name=self.name,
-            server_version=self.version if self.version else _package_version("mcp"),
+            server_version=self.version or "",
             title=self.title,
             description=self.description,
             capabilities=self.get_capabilities(
@@ -643,7 +633,7 @@ def server_info(self) -> types.Implementation:
         """
         return types.Implementation(
             name=self.name,
-            version=self.version if self.version else _package_version("mcp"),
+            version=self.version or "",
             title=self.title,
             description=self.description,
             website_url=self.website_url,

tests/_stamp.py

@@ -1,11 +1,10 @@
 """Shared helper: strip the 2026-era serverInfo `_meta` stamp from a result.
 
 Servers stamp `io.modelcontextprotocol/serverInfo` into every 2026-era
-result's `_meta` and never into handshake-era ones, and the stamp's `version`
-defaults to the installed package version. Suites whose expected payloads
-should stay identity-free strip the stamp before exact comparison - and the
-strip is strict, so a modern result that lost its stamp fails the test
-instead of passing silently.
+result's `_meta` and never into handshake-era ones. Suites whose expected
+payloads should stay identity-free strip the stamp before exact comparison -
+and the strip is strict, so a modern result that lost its stamp fails the
+test instead of passing silently.
 
 The interaction matrix does not use this function directly: its `unstamped`
 fixture (tests/interaction/conftest.py) resolves per cell to this strict

tests/client/test_client.py

@@ -45,7 +45,6 @@
 from mcp.server.mcpserver import Context, MCPServer
 from mcp.shared.memory import MessageStream, create_client_server_memory_streams
 from mcp.shared.message import SessionMessage
-from tests._stamp import unstamped
 from tests.interaction._connect import BASE_URL, mounted_app
 
 pytestmark = pytest.mark.anyio
@@ -134,9 +133,10 @@ async def test_client_with_simple_server(simple_server: Server):
     """Test that from_server works with a basic Server instance."""
     async with Client(simple_server) as client:
         resources = await client.list_resources()
-        assert unstamped(resources) == snapshot(
+        assert resources == snapshot(
             ListResourcesResult(
-                resources=[Resource(name="Test Resource", uri="memory://test", description="A test resource")]
+                _meta={"io.modelcontextprotocol/serverInfo": {"name": "test_server", "version": ""}},
+                resources=[Resource(name="Test Resource", uri="memory://test", description="A test resource")],
             )
         )
 
@@ -150,8 +150,9 @@ async def test_client_send_ping(app: MCPServer):
 async def test_client_list_tools(app: MCPServer):
     async with Client(app) as client:
         result = await client.list_tools()
-        assert unstamped(result) == snapshot(
+        assert result == snapshot(
             ListToolsResult(
+                _meta={"io.modelcontextprotocol/serverInfo": {"name": "test", "version": ""}},
                 tools=[
                     Tool(
                         name="greet",
@@ -169,16 +170,17 @@ async def test_client_list_tools(app: MCPServer):
                             "type": "object",
                         },
                     )
-                ]
+                ],
             )
         )
 
 
 async def test_client_call_tool(app: MCPServer):
     async with Client(app) as client:
         result = await client.call_tool("greet", {"name": "World"})
-        assert unstamped(result) == snapshot(
+        assert result == snapshot(
             CallToolResult(
+                _meta={"io.modelcontextprotocol/serverInfo": {"name": "test", "version": ""}},
                 content=[TextContent(text="Hello, World!")],
                 structured_content={"result": "Hello, World!"},
             )
@@ -189,9 +191,10 @@ async def test_read_resource(app: MCPServer):
     """Test reading a resource."""
     async with Client(app) as client:
         result = await client.read_resource("test://resource")
-        assert unstamped(result) == snapshot(
+        assert result == snapshot(
             ReadResourceResult(
-                contents=[TextResourceContents(uri="test://resource", mime_type="text/plain", text="Test content")]
+                _meta={"io.modelcontextprotocol/serverInfo": {"name": "test", "version": ""}},
+                contents=[TextResourceContents(uri="test://resource", mime_type="text/plain", text="Test content")],
             )
         )
 
@@ -269,8 +272,9 @@ async def test_get_prompt(app: MCPServer):
     """Test getting a prompt."""
     async with Client(app) as client:
         result = await client.get_prompt("greeting_prompt", {"name": "Alice"})
-        assert unstamped(result) == snapshot(
+        assert result == snapshot(
             GetPromptResult(
+                _meta={"io.modelcontextprotocol/serverInfo": {"name": "test", "version": ""}},
                 description="A greeting prompt.",
                 messages=[PromptMessage(role="user", content=TextContent(text="Please greet Alice warmly."))],
             )
@@ -335,16 +339,17 @@ async def test_client_list_resources_with_params(app: MCPServer):
     """Test listing resources with params parameter."""
     async with Client(app) as client:
         result = await client.list_resources()
-        assert unstamped(result) == snapshot(
+        assert result == snapshot(
             ListResourcesResult(
+                _meta={"io.modelcontextprotocol/serverInfo": {"name": "test", "version": ""}},
                 resources=[
                     Resource(
                         name="test_resource",
                         uri="test://resource",
                         description="A test resource.",
                         mime_type="text/plain",
                     )
-                ]
+                ],
             )
         )
 
@@ -353,22 +358,27 @@ async def test_client_list_resource_templates(app: MCPServer):
     """Test listing resource templates with params parameter."""
     async with Client(app) as client:
         result = await client.list_resource_templates()
-        assert unstamped(result) == snapshot(ListResourceTemplatesResult(resource_templates=[]))
+        assert result == snapshot(
+            ListResourceTemplatesResult(
+                _meta={"io.modelcontextprotocol/serverInfo": {"name": "test", "version": ""}}, resource_templates=[]
+            )
+        )
 
 
 async def test_list_prompts(app: MCPServer):
     """Test listing prompts with params parameter."""
     async with Client(app) as client:
         result = await client.list_prompts()
-        assert unstamped(result) == snapshot(
+        assert result == snapshot(
             ListPromptsResult(
+                _meta={"io.modelcontextprotocol/serverInfo": {"name": "test", "version": ""}},
                 prompts=[
                     Prompt(
                         name="greeting_prompt",
                         description="A greeting prompt.",
                         arguments=[PromptArgument(name="name", required=True)],
                     )
-                ]
+                ],
             )
         )
 
@@ -378,7 +388,12 @@ async def test_complete_with_prompt_reference(simple_server: Server):
     async with Client(simple_server) as client:
         ref = types.PromptReference(type="ref/prompt", name="test_prompt")
         result = await client.complete(ref=ref, argument={"name": "arg", "value": "test"})
-        assert unstamped(result) == snapshot(types.CompleteResult(completion=types.Completion(values=[])))
+        assert result == snapshot(
+            types.CompleteResult(
+                _meta={"io.modelcontextprotocol/serverInfo": {"name": "test_server", "version": ""}},
+                completion=types.Completion(values=[]),
+            )
+        )
 
 
 def test_client_with_url_initializes_streamable_http_transport():
@@ -756,8 +771,12 @@ async def elicitation_callback(
         async with Client(server, elicitation_callback=elicitation_callback) as client:
             result = await client.call_tool("greet")
 
-    assert unstamped(result) == snapshot(
-        CallToolResult(content=[TextContent(text="Hello, Ada!")], structured_content={"result": "Hello, Ada!"})
+    assert result == snapshot(
+        CallToolResult(
+            _meta={"io.modelcontextprotocol/serverInfo": {"name": "test", "version": ""}},
+            content=[TextContent(text="Hello, Ada!")],
+            structured_content={"result": "Hello, Ada!"},
+        )
     )
     assert len(callback_params) == 1
     assert isinstance(callback_params[0], types.ElicitRequestFormParams)
@@ -801,9 +820,11 @@ async def sampling_callback(
         async with Client(server, sampling_callback=sampling_callback) as client:
             result = await client.call_tool("ask")
 
-    assert unstamped(result) == snapshot(
+    assert result == snapshot(
         CallToolResult(
-            content=[TextContent(text="Model said: Paris")], structured_content={"result": "Model said: Paris"}
+            _meta={"io.modelcontextprotocol/serverInfo": {"name": "test", "version": ""}},
+            content=[TextContent(text="Model said: Paris")],
+            structured_content={"result": "Model said: Paris"},
         )
     )
     assert len(callback_params) == 1
@@ -834,8 +855,9 @@ async def list_roots_callback(context: ClientRequestContext) -> types.ListRootsR
         async with Client(server, list_roots_callback=list_roots_callback) as client:
             result = await client.call_tool("count_roots")
 
-    assert unstamped(result) == snapshot(
+    assert result == snapshot(
         CallToolResult(
+            _meta={"io.modelcontextprotocol/serverInfo": {"name": "test", "version": ""}},
             content=[TextContent(text="Client exposed 1 root(s).")],
             structured_content={"result": "Client exposed 1 root(s)."},
         )
@@ -920,8 +942,11 @@ async def elicitation_callback(
     with anyio.fail_after(5):
         async with Client(server, mode="2026-07-28", elicitation_callback=elicitation_callback) as client:
             result = await client.get_prompt("summary")
-    assert unstamped(result) == snapshot(
-        GetPromptResult(messages=[PromptMessage(role="user", content=TextContent(text="ok"))])
+    assert result == snapshot(
+        GetPromptResult(
+            _meta={"io.modelcontextprotocol/serverInfo": {"name": "test", "version": ""}},
+            messages=[PromptMessage(role="user", content=TextContent(text="ok"))],
+        )
     )
 
 
@@ -948,6 +973,9 @@ async def elicitation_callback(
     with anyio.fail_after(5):
         async with Client(server, mode="2026-07-28", elicitation_callback=elicitation_callback) as client:
             result = await client.read_resource("memory://gated")
-    assert unstamped(result) == snapshot(
-        ReadResourceResult(contents=[TextResourceContents(uri="memory://gated", text="unlocked")])
+    assert result == snapshot(
+        ReadResourceResult(
+            _meta={"io.modelcontextprotocol/serverInfo": {"name": "test", "version": ""}},
+            contents=[TextResourceContents(uri="memory://gated", text="unlocked")],
+        )
     )

tests/client/test_session_concurrency.py

@@ -14,7 +14,6 @@
 from mcp import Client
 from mcp.client import ClientRequestContext
 from mcp.server.mcpserver import Context, MCPServer
-from tests._stamp import unstamped
 
 pytestmark = pytest.mark.anyio
 
@@ -67,11 +66,23 @@ async def call_and_record(tag: str) -> None:
                     await done[tag].wait()
 
     assert completion_order == ["c", "b", "a"]
-    assert {tag: unstamped(result) for tag, result in results.items()} == snapshot(
+    assert results == snapshot(
         {
-            "c": CallToolResult(content=[TextContent(text="result:c")], structured_content={"result": "result:c"}),
-            "b": CallToolResult(content=[TextContent(text="result:b")], structured_content={"result": "result:b"}),
-            "a": CallToolResult(content=[TextContent(text="result:a")], structured_content={"result": "result:a"}),
+            "c": CallToolResult(
+                _meta={"io.modelcontextprotocol/serverInfo": {"name": "parking", "version": ""}},
+                content=[TextContent(text="result:c")],
+                structured_content={"result": "result:c"},
+            ),
+            "b": CallToolResult(
+                _meta={"io.modelcontextprotocol/serverInfo": {"name": "parking", "version": ""}},
+                content=[TextContent(text="result:b")],
+                structured_content={"result": "result:b"},
+            ),
+            "a": CallToolResult(
+                _meta={"io.modelcontextprotocol/serverInfo": {"name": "parking", "version": ""}},
+                content=[TextContent(text="result:a")],
+                structured_content={"result": "result:a"},
+            ),
         }
     )
 

tests/docs_src/_helpers.py

@@ -1,6 +1,5 @@
 """Shared helpers for the docs_src tests."""
 
-from importlib.metadata import version
 from typing import TypeVar
 
 from mcp_types import SERVER_INFO_META_KEY, Result
@@ -12,13 +11,13 @@
 
 
 def strip_server_info(result: R, server: Server | MCPServer) -> R:
-    """Assert the 2026-era serverInfo stamp, then drop it so snapshots stay stable.
+    """Assert the 2026-era serverInfo stamp, then drop it so snapshots stay focused.
 
-    The doc snippets set no explicit version, so the stamp's version is the
-    installed mcp package version; keeping it in the inline snapshots would
-    make them commit-dependent.
+    The doc snippets set no explicit version, so the stamp's version is empty;
+    the fenced outputs in the docs pages leave the stamp out, and the tests
+    mirror the fences.
     """
     assert result.meta is not None
-    assert result.meta[SERVER_INFO_META_KEY] == {"name": server.name, "version": version("mcp")}
+    assert result.meta[SERVER_INFO_META_KEY] == {"name": server.name, "version": ""}
     result.meta = None
     return result

tests/docs_src/test_lowlevel.py

@@ -118,7 +118,7 @@ async def test_meta_reaches_the_client_application() -> None:
         result = await client.call_tool("search_books", {"query": "dune", "limit": 5})
         assert result.meta is not None
         # The server identity stamp shares `_meta` with the handler's keys without clobbering
-        # them. Remove it before the exact compares: its `version` tracks the installed package.
+        # them. Remove it before the exact compares: the page's fence leaves the stamp out.
         del result.meta[SERVER_INFO_META_KEY]
         assert result.meta == {"bookshop/record_ids": ["bk_17", "bk_42", "bk_99"]}
         assert result.model_dump(by_alias=True, exclude_none=True) == snapshot(

tests/interaction/conftest.py

@@ -55,13 +55,6 @@ def __init__(self, factory: Connect, spec_version: str) -> None:
         self.spec_version = spec_version
 
     def __call__(self, server: Server | MCPServer, **kwargs: Any) -> AbstractAsyncContextManager[Client]:
-        # The matrix compares exact result payloads, and the 2026-era serverInfo
-        # `_meta` stamp carries the server version, which defaults to the
-        # commit-dependent installed package version. Pin it so expected
-        # payloads stay deterministic across commits.
-        lowlevel = server._lowlevel_server if isinstance(server, MCPServer) else server
-        if lowlevel.version is None:
-            lowlevel.version = "1.0.0"
         return self._factory(server, spec_version=self.spec_version, **kwargs)