ms-tau-sdk 2.0.12.dev53__tar.gz → 2.0.13.dev54__tar.gz

{ms_tau_sdk-2.0.12.dev53 → ms_tau_sdk-2.0.13.dev54}/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## Unreleased
+
+- **ms-tau-sdk installs the MCP Python SDK 2.x.** The `mcp` dependency moves from `mcp>=1.27,<2`
+  to `mcp>=2.3,<3`, which brings `httpx2`, the HTTP client MCP 2.x uses. A repository that runs a
+  Harness Agent and also serves an application MCP with `mainsequence[mcp]`, which requires MCP 2.x
+  for the MCP Skills extension, could not lock both packages; it now can. Agent behaviour does not
+  change: platform and application MCP calls keep their time limits, cancellation, the one token
+  renewal on 401, and the same failure texts and details, including the refused, server-error and
+  timeout statuses that MCP 2.x no longer reports by itself. A project that pins `mcp<2` itself,
+  or uses the MCP 1.x API in its own code (`FastMCP`, `McpError`, camelCase fields), must move to
+  MCP 2.x. The time-limits guide shows `MCPServer`, MCP 2.x's name for `FastMCP`.
+
 ## 2.0.12 — 2026-10-11
 
 - **A direct Message that runs out of time gets a typed answer

{ms_tau_sdk-2.0.12.dev53 → ms_tau_sdk-2.0.13.dev54}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: ms-tau-sdk
-Version: 2.0.12.dev53
+Version: 2.0.13.dev54
 Summary: Workspace-bound Tau application primitives for Main Sequence projects
 Project-URL: Changelog, https://github.com/mainsequence-sdk/ms-tau-sdk/blob/development/CHANGELOG.md
 Project-URL: Documentation, https://github.com/mainsequence-sdk/ms-tau-sdk/tree/development/docs
@@ -18,7 +18,7 @@ Requires-Dist: cryptography>=42
 Requires-Dist: fastapi>=0.116
 Requires-Dist: httpx>=0.28
 Requires-Dist: jsonschema<5,>=4.25
-Requires-Dist: mcp<2,>=1.27
+Requires-Dist: mcp<3,>=2.3
 Requires-Dist: pydantic-settings>=2.10
 Requires-Dist: pydantic>=2.11
 Requires-Dist: pyjwt[crypto]<3,>=2.10.1

{ms_tau_sdk-2.0.12.dev53 → ms_tau_sdk-2.0.13.dev54}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "ms-tau-sdk"
-version = "2.0.12.dev53"
+version = "2.0.13.dev54"
 description = "Workspace-bound Tau application primitives for Main Sequence projects"
 readme = "README.md"
 requires-python = ">=3.13"
@@ -22,7 +22,7 @@ dependencies = [
   "fastapi>=0.116",
   "httpx>=0.28",
   "jsonschema>=4.25,<5",
-  "mcp>=1.27,<2",
+  "mcp>=2.3,<3",
   "pydantic>=2.11",
   "pydantic-settings>=2.10",
   "pyjwt[crypto]>=2.10.1,<3",

{ms_tau_sdk-2.0.12.dev53 → ms_tau_sdk-2.0.13.dev54}/src/ms_tau_sdk/backend/mcp.py

@@ -5,20 +5,22 @@ from __future__ import annotations
 import asyncio
 import contextvars
 import math
-from collections.abc import AsyncGenerator, AsyncIterator, Callable
+from collections.abc import AsyncGenerator, AsyncIterator
 from contextlib import asynccontextmanager
 from dataclasses import dataclass
-from datetime import timedelta
+from types import TracebackType
 from typing import Any, Literal, Self, cast
 
 import anyio
-import httpx
-from anyio.abc import ObjectSendStream
-from anyio.streams.memory import MemoryObjectReceiveStream, MemoryObjectSendStream
+import httpx2
 from mcp import ClientSession, types
 from mcp.client.streamable_http import RequestContext, StreamableHTTPTransport
+from mcp.shared._context_streams import (
+    ContextReceiveStream,
+    ContextSendStream,
+    create_context_streams,
+)
 from mcp.shared.message import SessionMessage
-from pydantic import AnyUrl
 from structlog.contextvars import bound_contextvars, get_contextvars
 
 from ms_tau_sdk.settings import TauSDKSettings
@@ -36,7 +38,18 @@ def _actionable_cleanup_error(error: BaseException) -> Exception | None:
     return error if isinstance(error, Exception) else None
 
 
-class _RuntimeCredentialHTTPXAuth(httpx.Auth):
+def raise_for_renewed_401(response: httpx2.Response) -> None:
+    """End the call when a request still gets 401 after its credential was renewed.
+
+    MCP 2.x turns an HTTP error into a JSON-RPC error without its status. Raising here keeps the
+    status, as MCP 1.x's transport did, so callers can still say the call was refused.
+    """
+
+    if response.status_code == 401:
+        response.raise_for_status()
+
+
+class _RuntimeCredentialHTTPXAuth(httpx2.Auth):
     requires_request_body = True
 
     def __init__(self, runtime_auth: BackendAuth) -> None:
@@ -44,13 +57,13 @@ class _RuntimeCredentialHTTPXAuth(httpx.Auth):
 
     async def async_auth_flow(
         self,
-        request: httpx.Request,
-    ) -> AsyncGenerator[httpx.Request, httpx.Response]:
+        request: httpx2.Request,
+    ) -> AsyncGenerator[httpx2.Request, httpx2.Response]:
         request.headers.update(await self.runtime_auth.headers())
         response = yield request
         if response.status_code == 401:
             request.headers.update(await self.runtime_auth.headers(force=True))
-            yield request
+            raise_for_renewed_401((yield request))
 
 
 @dataclass
@@ -75,7 +88,7 @@ _tool_call: contextvars.ContextVar[_ToolCall | None] = contextvars.ContextVar(
 )
 
 
-class _ToolCallWriteStream(ObjectSendStream[SessionMessage]):
+class _ToolCallWriteStream:
     """Associate the session's request ID with its call before the transport sends it.
 
     MCP's HTTP writer runs in another task, so the calling task's context does not reach its
@@ -84,14 +97,14 @@ class _ToolCallWriteStream(ObjectSendStream[SessionMessage]):
 
     def __init__(
         self,
-        stream: MemoryObjectSendStream[SessionMessage],
+        stream: ContextSendStream[SessionMessage],
         calls: dict[types.RequestId, _ToolCall],
     ) -> None:
         self._stream = stream
         self._calls = calls
 
-    async def send(self, item: SessionMessage) -> None:
-        message = item.message.root
+    async def send(self, item: SessionMessage, /) -> None:
+        message = item.message
         call = _tool_call.get()
         if (
             call is not None
@@ -105,6 +118,18 @@ class _ToolCallWriteStream(ObjectSendStream[SessionMessage]):
     async def aclose(self) -> None:
         await self._stream.aclose()
 
+    async def __aenter__(self) -> Self:
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> bool | None:
+        await self.aclose()
+        return None
+
 
 class _ToolCallTransport(StreamableHTTPTransport):
     """Give each call's POST a cancellation scope inside MCP's transport task.
@@ -118,7 +143,7 @@ class _ToolCallTransport(StreamableHTTPTransport):
         self._calls = calls
 
     async def _handle_post_request(self, ctx: RequestContext) -> None:
-        message = ctx.session_message.message.root
+        message = ctx.session_message.message
         call = (
             self._calls.get(message.id)
             if isinstance(message, types.JSONRPCRequest) and message.method == "tools/call"
@@ -143,14 +168,13 @@ class _ToolCallTransport(StreamableHTTPTransport):
 async def streamable_http_client(
     url: str,
     *,
-    http_client: httpx.AsyncClient,
+    http_client: httpx2.AsyncClient,
     calls: dict[types.RequestId, _ToolCall],
     terminate_on_close: bool = False,
 ) -> AsyncIterator[
     tuple[
-        MemoryObjectReceiveStream[SessionMessage | Exception],
-        MemoryObjectSendStream[SessionMessage],
-        Callable[[], str | None],
+        ContextReceiveStream[SessionMessage | Exception],
+        ContextSendStream[SessionMessage],
     ]
 ]:
     """Use MCP's HTTP readers/writer with call-scoped POST cancellation.
@@ -158,33 +182,35 @@ async def streamable_http_client(
     The upstream factory constructs its transport internally without an injection point.
     Preserve its stream/task-group lifecycle while selecting our transport specialization.
     """
-    read_writer, read_stream = anyio.create_memory_object_stream[SessionMessage | Exception](0)
-    write_stream, write_reader = anyio.create_memory_object_stream[SessionMessage](0)
+    read_writer, read_stream = create_context_streams[SessionMessage | Exception](0)
+    write_stream, write_reader = create_context_streams[SessionMessage](0)
     transport = _ToolCallTransport(url, calls)
-    async with anyio.create_task_group() as task_group:
+    async with (
+        read_writer,
+        read_stream,
+        write_stream,
+        write_reader,
+        anyio.create_task_group() as task_group,
+    ):
+
+        def start_get_stream() -> None:
+            task_group.start_soon(transport.handle_get_stream, http_client, read_writer)
+
+        task_group.start_soon(
+            transport.post_writer,
+            http_client,
+            write_reader,
+            read_writer,
+            write_stream,
+            start_get_stream,
+            task_group,
+        )
         try:
-
-            def start_get_stream() -> None:
-                task_group.start_soon(transport.handle_get_stream, http_client, read_writer)
-
-            task_group.start_soon(
-                transport.post_writer,
-                http_client,
-                write_reader,
-                read_writer,
-                write_stream,
-                start_get_stream,
-                task_group,
-            )
-            try:
-                yield read_stream, write_stream, transport.get_session_id
-            finally:
-                if terminate_on_close:
-                    await transport.terminate_session(http_client)
-                task_group.cancel_scope.cancel()
+            yield read_stream, write_stream
         finally:
-            await read_writer.aclose()
-            await write_stream.aclose()
+            if transport.session_id and terminate_on_close:
+                await transport.terminate_session(http_client)
+            task_group.cancel_scope.cancel()
 
 
 def _validate_response_timeout(seconds: float) -> None:
@@ -241,8 +267,8 @@ class MCPConnectionClient:
         name: str,
         display_name: str,
         url: str,
-        auth: httpx.Auth | None,
-        timeout: httpx.Timeout,
+        auth: httpx2.Auth | None,
+        timeout: httpx2.Timeout,
         read_timeout_seconds: float,
         read_concurrency: int,
     ) -> None:
@@ -300,25 +326,24 @@ class MCPConnectionClient:
     async def _run(self, initial_log_context: dict[str, object]) -> None:
         failure: Exception | None = None
         try:
-            async with httpx.AsyncClient(
+            async with httpx2.AsyncClient(
                 timeout=self._http_timeout,
                 auth=self._http_auth,
-                event_hooks={"request": [self._prepare_tool_request]},
+                event_hooks={
+                    "request": [self._prepare_tool_request],
+                    "response": [self._raise_for_error_status],
+                },
             ) as http_client:
                 async with streamable_http_client(
                     self.url,
                     http_client=http_client,
                     calls=self._http_calls,
                     terminate_on_close=False,
-                ) as (read_stream, write_stream, _get_session_id):
+                ) as (read_stream, write_stream):
                     async with ClientSession(
                         read_stream,
-                        # MCP annotates this as a memory stream, but uses only send/aclose.
-                        cast(
-                            MemoryObjectSendStream[SessionMessage],
-                            _ToolCallWriteStream(write_stream, self._http_calls),
-                        ),
-                        read_timeout_seconds=timedelta(seconds=self._read_timeout_seconds),
+                        _ToolCallWriteStream(write_stream, self._http_calls),
+                        read_timeout_seconds=self._read_timeout_seconds,
                     ) as session:
                         with bound_contextvars(**initial_log_context):
                             initialized = await session.initialize()
@@ -327,8 +352,8 @@ class MCPConnectionClient:
                                 tool.name
                                 for tool in self.tools
                                 if tool.annotations is not None
-                                and tool.annotations.readOnlyHint is True
-                                and tool.annotations.idempotentHint is True
+                                and tool.annotations.read_only_hint is True
+                                and tool.annotations.idempotent_hint is True
                             )
                         if self._ready is not None and not self._ready.done():
                             self._ready.set_result(None)
@@ -349,10 +374,10 @@ class MCPConnectionClient:
             )
             self._http_calls.clear()
 
-    async def _prepare_tool_request(self, request: httpx.Request) -> None:
+    async def _prepare_tool_request(self, request: httpx2.Request) -> None:
         if request.method != "POST":
             return
-        message = types.JSONRPCMessage.model_validate_json(request.content).root
+        message = types.jsonrpc_message_adapter.validate_json(request.content)
         if (
             isinstance(message, types.JSONRPCRequest)
             and message.method == "tools/call"
@@ -362,6 +387,13 @@ class MCPConnectionClient:
             # connect/write/pool limits, without mutating the shared HTTP client defaults.
             request.extensions["timeout"] = {**request.extensions["timeout"], "read": None}
 
+    async def _raise_for_error_status(self, response: httpx2.Response) -> None:
+        # MCP 2.x answers an HTTP error on a message POST with a JSON-RPC error that drops the
+        # status. Raise it, as MCP 1.x did, so a failure still says refused, server error or
+        # timeout. 401 is left to the credential's renewal, and 404 to MCP, as 1.x did.
+        if response.request.method == "POST" and response.status_code not in {401, 404}:
+            response.raise_for_status()
+
     async def _read_server_catalog(
         self,
         session: ClientSession,
@@ -396,21 +428,21 @@ class MCPConnectionClient:
                             call = _ToolCall(cancel_scope)
                             token = _tool_call.set(call)
                             command.result.add_done_callback(call.cancel_if_abandoned)
+                            # MCP types `_meta` as a TypedDict; the call's own keys pass through.
+                            meta = cast(types.RequestParamsMeta | None, command.meta)
                             try:
                                 if command.timeout_seconds is None:
                                     tool_result = await session.call_tool(
                                         command.name,
                                         command.arguments,
-                                        meta=command.meta,
+                                        meta=meta,
                                     )
                                 else:
                                     tool_result = await session.call_tool(
                                         command.name,
                                         command.arguments,
-                                        read_timeout_seconds=timedelta(
-                                            seconds=command.timeout_seconds
-                                        ),
-                                        meta=command.meta,
+                                        read_timeout_seconds=command.timeout_seconds,
+                                        meta=meta,
                                     )
                                 if not command.result.done():
                                     command.result.set_result(tool_result)
@@ -419,7 +451,7 @@ class MCPConnectionClient:
                                 _tool_call.reset(token)
                                 call.finish()
                     else:
-                        resource_result = await session.read_resource(AnyUrl(command.uri))
+                        resource_result = await session.read_resource(command.uri)
                         if not command.result.done():
                             command.result.set_result(resource_result)
             except Exception as error:
@@ -557,7 +589,7 @@ class MainSequenceMCPClient(MCPConnectionClient):
             display_name="Main Sequence",
             url=f"{settings.backend_url.rstrip('/')}/mcp",
             auth=_RuntimeCredentialHTTPXAuth(auth),
-            timeout=httpx.Timeout(
+            timeout=httpx2.Timeout(
                 connect=settings.backend_connect_timeout_seconds,
                 read=settings.backend_read_timeout_seconds,
                 write=settings.backend_write_timeout_seconds,

{ms_tau_sdk-2.0.12.dev53 → ms_tau_sdk-2.0.13.dev54}/src/ms_tau_sdk/tools/mainsequence_mcp.py

@@ -43,7 +43,7 @@ def _tau_tool_input_schema(
     *,
     local_user_semantics: bool = False,
 ) -> Mapping[str, JSONValue]:
-    schema = deepcopy(tool.inputSchema)
+    schema = deepcopy(tool.input_schema)
     if tool.name == A2A_SEND_TOOL:
         properties = schema.setdefault("properties", {})
         if isinstance(properties, dict):

{ms_tau_sdk-2.0.12.dev53 → ms_tau_sdk-2.0.13.dev54}/src/ms_tau_sdk/tools/mcp_applications.py

@@ -22,8 +22,9 @@ from collections.abc import AsyncGenerator, Mapping, Sequence
 from typing import Protocol
 
 import httpx
+import httpx2
 import structlog
-from mcp import McpError, types
+from mcp import MCPError, types
 from tau_agent.messages import TextContent
 from tau_agent.tools import (
     AgentTool,
@@ -33,7 +34,7 @@ from tau_agent.tools import (
 )
 from tau_agent.types import JSONValue
 
-from ms_tau_sdk.backend.mcp import MCPConnectionClient
+from ms_tau_sdk.backend.mcp import MCPConnectionClient, raise_for_renewed_401
 from ms_tau_sdk.backend.models import MCPApplication
 from ms_tau_sdk.errors import (
     ApplicationReadinessTimeoutError,
@@ -63,7 +64,7 @@ class ApplicationConnector(Protocol):
     ) -> MCPConnectionClient: ...
 
 
-class _ApplicationTokenAuth(httpx.Auth):
+class _ApplicationTokenAuth(httpx2.Auth):
     """Send the turn's application token; obtain a new one once when the application says 401."""
 
     def __init__(self, access: _TurnApplicationAccess) -> None:
@@ -72,14 +73,14 @@ class _ApplicationTokenAuth(httpx.Auth):
 
     async def async_auth_flow(
         self,
-        request: httpx.Request,
-    ) -> AsyncGenerator[httpx.Request, httpx.Response]:
+        request: httpx2.Request,
+    ) -> AsyncGenerator[httpx2.Request, httpx2.Response]:
         request.headers["Authorization"] = f"Bearer {self._token}"
         response = yield request
         if response.status_code == 401:
             self._token = await self._renew()
             request.headers["Authorization"] = f"Bearer {self._token}"
-            yield request
+            raise_for_renewed_401((yield request))
 
 
 def application_connector(settings: TauSDKSettings) -> ApplicationConnector:
@@ -100,7 +101,7 @@ def application_connector(settings: TauSDKSettings) -> ApplicationConnector:
             auth=_ApplicationTokenAuth(access),
             # The connection applies the tool's response deadline to its call; these HTTP limits
             # also bound initialization and catalog requests.
-            timeout=httpx.Timeout(
+            timeout=httpx2.Timeout(
                 connect=settings.backend_connect_timeout_seconds,
                 read=settings.backend_read_timeout_seconds,
                 write=settings.backend_write_timeout_seconds,
@@ -114,10 +115,11 @@ def application_connector(settings: TauSDKSettings) -> ApplicationConnector:
 
 
 def _timed_out(error: BaseException) -> bool:
-    if isinstance(error, McpError):
-        return error.error.code == httpx.codes.REQUEST_TIMEOUT
+    if isinstance(error, MCPError):
+        return error.code == types.REQUEST_TIMEOUT
     return isinstance(error, TimeoutError) or (
-        isinstance(error, httpx.TimeoutException) and not isinstance(error, httpx.ConnectTimeout)
+        isinstance(error, httpx.TimeoutException | httpx2.TimeoutException)
+        and not isinstance(error, httpx.ConnectTimeout | httpx2.ConnectTimeout)
     )
 
 
@@ -175,7 +177,7 @@ def _failure(
             f"{subject} did not answer within {timeout_seconds:g} seconds.",
             {"failure": "timeout", "timeout_seconds": timeout_seconds},
         )
-    if isinstance(error, httpx.HTTPStatusError):
+    if isinstance(error, httpx.HTTPStatusError | httpx2.HTTPStatusError):
         status = error.response.status_code
         if status in {408, 504}:
             text = f"The {name} application or its gateway reported a timeout ({status})."
@@ -188,7 +190,10 @@ def _failure(
             return text, {"failure": "refused", "status": status}
         text = f"The {name} application answered with an error ({status})."
         return text, {"failure": "error_status", "status": status}
-    if isinstance(error, httpx.ConnectError | httpx.ConnectTimeout):
+    if isinstance(
+        error,
+        httpx.ConnectError | httpx.ConnectTimeout | httpx2.ConnectError | httpx2.ConnectTimeout,
+    ):
         return f"The {name} application could not be reached.", {"failure": "unreachable"}
     return f"The {name} application could not complete this call.", {"failure": "failed"}
 
@@ -196,9 +201,9 @@ def _failure(
 def _retryable(error: BaseException) -> bool:
     """Whether opening the session failed in a way that a second attempt may not repeat."""
 
-    if isinstance(error, httpx.HTTPStatusError):
+    if isinstance(error, httpx.HTTPStatusError | httpx2.HTTPStatusError):
         return error.response.status_code == 408 or error.response.status_code >= 500
-    return isinstance(error, httpx.TransportError) or _timed_out(error)
+    return isinstance(error, httpx.TransportError | httpx2.TransportError) or _timed_out(error)
 
 
 def _error(name: str, text: str, **details: JSONValue) -> AgentToolResult:
@@ -209,11 +214,11 @@ def _error(name: str, text: str, **details: JSONValue) -> AgentToolResult:
 
 
 def _tool_entry(tool: types.Tool) -> dict[str, JSONValue]:
-    entry: dict[str, JSONValue] = {"name": tool.name, "inputSchema": dict(tool.inputSchema)}
+    entry: dict[str, JSONValue] = {"name": tool.name, "inputSchema": dict(tool.input_schema)}
     if tool.description:
         entry["description"] = tool.description
-    if tool.annotations is not None and tool.annotations.readOnlyHint is not None:
-        entry["readOnly"] = tool.annotations.readOnlyHint
+    if tool.annotations is not None and tool.annotations.read_only_hint is not None:
+        entry["readOnly"] = tool.annotations.read_only_hint
     return entry
 
 

{ms_tau_sdk-2.0.12.dev53 → ms_tau_sdk-2.0.13.dev54}/src/ms_tau_sdk/tools/mcp_connection.py

@@ -124,24 +124,26 @@ def mcp_tool_result(
             content.append(
                 ImageContent(
                     data=block.data,
-                    mime_type=block.mimeType,
+                    mime_type=block.mime_type,
                 )
             )
         else:
-            content.append(TextContent(text=_json_text(block.model_dump(mode="json"))))
-    if not content and result.structuredContent is not None:
-        content.append(TextContent(text=_json_text(result.structuredContent)))
-    if not content and result.isError:
+            content.append(
+                TextContent(text=_json_text(block.model_dump(by_alias=True, mode="json")))
+            )
+    if not content and result.structured_content is not None:
+        content.append(TextContent(text=_json_text(result.structured_content)))
+    if not content and result.is_error:
         content.append(TextContent(text=f"{display_name} MCP tool {canonical_name} failed."))
 
     details: dict[str, JSONValue] = {
         "mcp_tool": canonical_name,
-        "is_error": result.isError,
+        "is_error": result.is_error,
     }
-    if result.structuredContent is not None:
+    if result.structured_content is not None:
         details["structured_content"] = cast(
             JSONValue,
-            result.structuredContent,
+            result.structured_content,
         )
     return AgentToolResult(content=content, details=details)
 
@@ -159,8 +161,8 @@ def _create_tool(
     execution_mode: Literal["sequential", "parallel"] = (
         "parallel"
         if annotations is not None
-        and bool(getattr(annotations, "readOnlyHint", False))
-        and bool(getattr(annotations, "idempotentHint", False))
+        and bool(getattr(annotations, "read_only_hint", False))
+        and bool(getattr(annotations, "idempotent_hint", False))
         else "sequential"
     )
     # A tool that declares its time limit is waited for that long; any other tool gets the
@@ -199,7 +201,7 @@ def _create_tool(
     parameters = (
         policy.input_schema(tool)
         if policy.input_schema is not None
-        else cast(Mapping[str, JSONValue], deepcopy(tool.inputSchema))
+        else cast(Mapping[str, JSONValue], deepcopy(tool.input_schema))
     )
     return AgentTool(
         name=tau_name,
@@ -241,7 +243,7 @@ def _create_resource_tool(client: MCPConnection, policy: MCPToolPolicy) -> Agent
             else:
                 content.append(
                     TextContent(
-                        text=_json_text(item.model_dump(mode="json")),
+                        text=_json_text(item.model_dump(by_alias=True, mode="json")),
                     )
                 )
         return AgentToolResult(