fix(mcp): restore compatibility with mcp 2.x (kyegomez#2128)

requirements.txt now allows mcp 2.x (kyegomez#2108), which renamed several
attributes. Three sites still read the 1.x spellings, and because they
all used getattr with a default, two of them failed silently rather
than raising.

- CallToolResult.isError -> is_error. The old name now always fell
  through to the default, so every failed MCP tool call was reported to
  the agent as a success.
- CallToolResult.structuredContent -> structured_content, same
  silent-fallthrough shape.
- OAuthClientProvider dropped its timeout kwarg in 2.x, so building an
  OAuth provider raised TypeError. The wait stays bounded because
  callback_handler already closes over oauth.callback_timeout.

_mcp_tool_to_openai already handled inputSchema -> input_schema this
way; these sites were missed.

The test fixture server imported mcp.server.fastmcp, removed in 2.x,
so it could not start at all -- 28 tests errored in setup. FastMCP is
now MCPServer, behind a shim that still works on 1.x.

test_api_key_server_rejects_wrong_key asserted "401" in the error.
Rejection still works, but 2.x collapses every non-404 non-2xx response
into ErrorData(INTERNAL_ERROR, "Server returned an error response")
before it reaches us, so the status is unrecoverable. The assertion is
now version-gated rather than dropped: 1.x still requires the status.

tests/tools/test_mcp_manager.py: 85 passed (was 2 failed, 28 errors).
The 6 remaining failures in tests/tools/ are in test_base_tool.py and
test_parse_tools.py, and fail identically on unmodified master.

Author: kyegomez

swarms/tools/mcp_manager.py

@@ -1084,7 +1084,12 @@ async def _acall_tool(
             "tool": name,
             "server": self.label(connection),
             "arguments": arguments,
-            "is_error": bool(getattr(result, "isError", False)),
+            # mcp 2.x renamed `isError` to `is_error`; reading only the
+            # old name reports every failed call as a success.
+            "is_error": bool(
+                getattr(result, "isError", None)
+                or getattr(result, "is_error", None)
+            ),
             "result": self._extract_result(result),
         }
 
@@ -1144,7 +1149,10 @@ def _extract_result(result: Any) -> Any:
         if texts or others:
             return {"text": "\n".join(texts), "content": others}
 
-        structured = getattr(result, "structuredContent", None)
+        # mcp 2.x renamed `structuredContent` to `structured_content`.
+        structured = getattr(
+            result, "structuredContent", None
+        ) or getattr(result, "structured_content", None)
         if structured:
             return structured
 
@@ -1408,14 +1416,18 @@ async def callback_handler() -> Tuple[str, Optional[str]]:
                 callback_server.wait, float(oauth.callback_timeout)
             )
 
-        provider = OAuthClientProvider(
-            server_url=_server_origin(connection.url or ""),
-            client_metadata=client_metadata,
-            storage=storage,
-            redirect_handler=redirect_handler,
-            callback_handler=callback_handler,
-            timeout=float(oauth.callback_timeout),
-        )
+        provider_kwargs: Dict[str, Any] = {
+            "server_url": _server_origin(connection.url or ""),
+            "client_metadata": client_metadata,
+            "storage": storage,
+            "redirect_handler": redirect_handler,
+            "callback_handler": callback_handler,
+        }
+        # 2.x dropped the kwarg; callback_handler already bounds the wait.
+        if not MCP_IS_V2:
+            provider_kwargs["timeout"] = float(oauth.callback_timeout)
+
+        provider = OAuthClientProvider(**provider_kwargs)
 
         self._oauth_providers[key] = provider
         return provider

tests/tools/mcp_test_server.py

@@ -16,15 +16,32 @@
 
 import sys
 
-from mcp.server.fastmcp import FastMCP
 from starlette.responses import JSONResponse
 
+try:
+    # mcp 1.x
+    from mcp.server.fastmcp import FastMCP
+
+    def _build_server(port: int):
+        return FastMCP(
+            "swarms-test-server", host="127.0.0.1", port=port
+        )
+
+except ImportError:
+    # 2.x renamed FastMCP to MCPServer and moved the transport settings
+    # off the constructor; uvicorn binds the port here either way.
+    from mcp.server.mcpserver import MCPServer
+
+    def _build_server(port: int):
+        return MCPServer("swarms-test-server")
+
+
 API_KEY = "test-key-123"
 BEARER_TOKEN = "test-token-abc"
 
 
 def build_app(profile: str, port: int):
-    mcp = FastMCP("swarms-test-server", host="127.0.0.1", port=port)
+    mcp = _build_server(port)
 
     @mcp.tool()
     def add(a: int, b: int) -> int:

tests/tools/test_mcp_manager.py

@@ -30,6 +30,7 @@
 from swarms.schemas.agent_mcp_errors import AgentMCPConnectionError
 from swarms.schemas.mcp_schemas import MCPConnection, MCPOAuthConfig
 from swarms.tools.mcp_manager import (
+    MCP_IS_V2,
     MCPFileTokenStorage,
     MCPInMemoryTokenStorage,
     MCPManager,
@@ -527,7 +528,16 @@ def test_api_key_server_rejects_wrong_key(self, apikey_server):
         )
         with pytest.raises(AgentMCPConnectionError) as excinfo:
             manager.get_tools()
-        assert "401" in str(excinfo.value)
+        message = str(excinfo.value)
+        assert apikey_server.url in message
+        if MCP_IS_V2:
+            # 2.x collapses every non-404 non-2xx response into
+            # ErrorData(INTERNAL_ERROR, "Server returned an error
+            # response") (mcp/client/streamable_http.py), so the status
+            # is gone before it reaches us. Only the rejection survives.
+            assert "error response" in message
+        else:
+            assert "401" in message
 
     def test_bearer_server_accepts_authorization_token(
         self, bearer_server