Skip to content

A reactive notebook for Python — run reproducible experiments, query with SQL, execute as a script, deploy as an app, and version with git. Stored as pure Python. All in a modern, AI-native editor.

feat(mcp): migrate to MCP 2 (#10581)

Shahmir Varqha849f16b6d288
diff --git a/frontend/src/components/app-config/optional-features.test.ts b/frontend/src/components/app-config/optional-features.test.ts
new file mode 100644
index 0000000000..eb4a55c369
--- /dev/null
+++ b/frontend/src/components/app-config/optional-features.test.ts
@@ -0,0 +1,78 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+
+import { describe, expect, it } from "vitest";
+import { isPackageRequirementInstalled } from "./optional-features";
+
+describe("isPackageRequirementInstalled", () => {
+ const installedPackages = [
+ { name: "mcp", version: "2.0.0" },
+ { name: "polars", version: "1.8.2" },
+ ];
+
+ it("requires the package to be installed", () => {
+ expect(
+ isPackageRequirementInstalled({ name: "missing" }, installedPackages),
+ ).toBe(false);
+ });
+
+ it("accepts an installed package without a minimum version", () => {
+ expect(
+ isPackageRequirementInstalled({ name: "polars" }, installedPackages),
+ ).toBe(true);
+ });
+
+ it("rejects an installed package below the minimum version", () => {
+ expect(
+ isPackageRequirementInstalled(
+ { name: "mcp", minVersion: "2.1.0" },
+ installedPackages,
+ ),
+ ).toBe(false);
+ });
+
+ it.each(["2.0.0rc1", "2.0.0.dev1", "2.0.0-beta1"])(
+ "rejects the prerelease version %s",
+ (version) => {
+ expect(
+ isPackageRequirementInstalled({ name: "mcp", minVersion: "2.0.0" }, [
+ { name: "mcp", version },
+ ]),
+ ).toBe(false);
+ },
+ );
+
+ it.each(["2.1.0rc1", "3.0.0rc1"])(
+ "accepts the later prerelease version %s",
+ (version) => {
+ expect(
+ isPackageRequirementInstalled({ name: "mcp", minVersion: "2.0.0" }, [
+ { name: "mcp", version },
+ ]),
+ ).toBe(true);
+ },
+ );
+
+ it("accepts an installed package at or above the minimum version", () => {
+ expect(
+ isPackageRequirementInstalled(
+ { name: "mcp", minVersion: "2.0.0" },
+ installedPackages,
+ ),
+ ).toBe(true);
+ expect(
+ isPackageRequirementInstalled(
+ { name: "mcp", minVersion: "1.9.0" },
+ installedPackages,
+ ),
+ ).toBe(true);
+ });
+
+ it("normalizes extras in the requirement name", () => {
+ expect(
+ isPackageRequirementInstalled(
+ { name: "polars[pyarrow]" },
+ installedPackages,
+ ),
+ ).toBe(true);
+ });
+});
diff --git a/frontend/src/components/app-config/optional-features.tsx b/frontend/src/components/app-config/optional-features.tsx
index 49d526e9d8..ad2d3f23bb 100644
--- a/frontend/src/components/app-config/optional-features.tsx
+++ b/frontend/src/components/app-config/optional-features.tsx
@@ -20,6 +20,7 @@ import { isWasm } from "@/core/wasm/utils";
import { useAsyncData } from "@/hooks/useAsyncData";
import { ErrorBanner } from "@/plugins/impl/common/error-banner";
import { cn } from "@/utils/cn";
+import { semverSort } from "@/utils/versions";
import { SettingSubtitle } from "./common";
interface Package {
@@ -27,6 +28,35 @@ interface Package {
minVersion?: string;
}
+interface InstalledPackage {
+ name: string;
+ version: string;
+}
+
+const PEP_440_PRERELEASE =
+ /^((?:\d+!)?\d+(?:\.\d+)*)(?:[-_.]?(?:a|b|c|rc|alpha|beta|pre|preview|dev)\d*)/i;
+
+export function isPackageRequirementInstalled(
+ requirement: Package,
+ installedPackages: InstalledPackage[],
+): boolean {
+ const packageName = requirement.name.split("[")[0];
+ const installedPackage = installedPackages.find(
+ (pkg) => pkg.name === packageName,
+ );
+ if (!installedPackage) {
+ return false;
+ }
+ if (!requirement.minVersion) {
+ return true;
+ }
+ const prerelease = installedPackage.version.match(PEP_440_PRERELEASE);
+ if (prerelease) {
+ return semverSort(prerelease[1], requirement.minVersion) > 0;
+ }
+ return semverSort(installedPackage.version, requirement.minVersion) >= 0;
+}
+
interface OptionalFeature {
id: string;
/**
@@ -77,8 +107,8 @@ const OPTIONAL_DEPENDENCIES: OptionalFeature[] = [
},
{
id: "mcp",
- packagesRequired: [{ name: "mcp", minVersion: "1" }],
- additionalPackageInstalls: [{ name: "pydantic", minVersion: "2" }],
+ packagesRequired: [{ name: "mcp", minVersion: "2.0.0" }],
+ additionalPackageInstalls: [],
description: "Connect to MCP servers",
},
{
@@ -123,9 +153,6 @@ export const OptionalFeatures: React.FC = () => {
}
const installedPackages = data?.packages || [];
- const installedPackageNames = new Set(
- installedPackages.map((pkg) => pkg.name),
- );
return (
<div className="flex-1 flex flex-col overflow-hidden gap-2">
@@ -149,7 +176,7 @@ export const OptionalFeatures: React.FC = () => {
<TableBody>
{OPTIONAL_DEPENDENCIES.map((dep) => {
const isInstalled = dep.packagesRequired.every((pkg) =>
- installedPackageNames.has(pkg.name.split("[")[0]),
+ isPackageRequirementInstalled(pkg, installedPackages),
);
const packageSpec = dep.packagesRequired
.map((pkg) => pkg.name)
diff --git a/marimo/_dependencies/dependencies.py b/marimo/_dependencies/dependencies.py
index 7620b57bc7..07f002a577 100644
--- a/marimo/_dependencies/dependencies.py
+++ b/marimo/_dependencies/dependencies.py
@@ -269,7 +269,7 @@ class DependencyManager:
redshift_connector = Dependency("redshift_connector")
starrocks = Dependency("starrocks")
- mcp = Dependency("mcp")
+ mcp = Dependency("mcp", min_version="2.0.0", max_version="3.0.0")
pydantic_ai = Dependency(
"pydantic_ai", pkg_name_to_install="pydantic-ai-slim"
)
diff --git a/marimo/_mcp/code_server/main.py b/marimo/_mcp/code_server/main.py
index 4fa2f67dab..71693348db 100644
--- a/marimo/_mcp/code_server/main.py
+++ b/marimo/_mcp/code_server/main.py
@@ -17,8 +17,8 @@ from marimo._ai._tools.types import (
ListSessionsResult,
MarimoNotebookInfo,
)
-from marimo._dependencies.dependencies import DependencyManager
from marimo._loggers import marimo_logger
+from marimo._mcp.dependencies import require_mcp_dependencies
from marimo._server.scratchpad import (
EXECUTION_TIMEOUT,
ScratchCellListener,
@@ -46,13 +46,9 @@ def setup_code_mcp_server(
app: Starlette application instance for accessing marimo state
allow_remote: If True, disable DNS rebinding protection to allow remote access behind proxies.
"""
- if not DependencyManager.mcp.has():
- from click import ClickException
+ require_mcp_dependencies()
- msg = "MCP dependencies not available. Install with `pip install marimo[mcp]` or `uv add marimo[mcp]`"
- raise ClickException(msg)
-
- from mcp.server.fastmcp import FastMCP
+ from mcp.server import MCPServer
from starlette.middleware.base import BaseHTTPMiddleware
from starlette.responses import JSONResponse
from starlette.routing import Mount
@@ -69,12 +65,9 @@ def setup_code_mcp_server(
enable_dns_rebinding_protection=False,
)
- mcp = FastMCP(
+ mcp = MCPServer(
"marimo-code-mcp",
- stateless_http=True,
log_level="WARNING",
- streamable_http_path="/server",
- transport_security=transport_security,
)
@mcp.tool()
@@ -155,7 +148,11 @@ def setup_code_mcp_server(
return extract_result(session, listener)
# Build the streamable HTTP app
- mcp_app = mcp.streamable_http_app()
+ mcp_app = mcp.streamable_http_app(
+ stateless_http=True,
+ streamable_http_path="/server",
+ transport_security=transport_security,
+ )
class RequiresEditMiddleware(BaseHTTPMiddleware):
async def __call__(
diff --git a/marimo/_mcp/dependencies.py b/marimo/_mcp/dependencies.py
new file mode 100644
index 0000000000..5313aebd24
--- /dev/null
+++ b/marimo/_mcp/dependencies.py
@@ -0,0 +1,22 @@
+# Copyright 2026 Marimo. All rights reserved.
+from __future__ import annotations
+
+from marimo._cli.errors import MarimoCLIMissingDependencyError
+from marimo._dependencies.dependencies import DependencyManager
+
+
+def require_mcp_dependencies() -> None:
+ dependency = DependencyManager.mcp
+ if dependency.has_required_version(quiet=True):
+ return
+
+ if dependency.has(quiet=True):
+ installed_version = dependency.get_version() or "unknown"
+ message = (
+ f"MCP SDK {installed_version} is not supported. "
+ "marimo requires MCP >=2.0.0,<3.0.0."
+ )
+ else:
+ message = "MCP dependencies not available."
+
+ raise MarimoCLIMissingDependencyError(message, "marimo[mcp]")
diff --git a/marimo/_mcp/server/main.py b/marimo/_mcp/server/main.py
index 7125e9fa28..4f8176be8c 100644
--- a/marimo/_mcp/server/main.py
+++ b/marimo/_mcp/server/main.py
@@ -12,9 +12,8 @@ from typing import TYPE_CHECKING
from marimo._ai._tools.base import ToolContext
from marimo._ai._tools.tools_registry import SUPPORTED_BACKEND_AND_MCP_TOOLS
-from marimo._cli.errors import MarimoCLIMissingDependencyError
-from marimo._dependencies.dependencies import DependencyManager
from marimo._loggers import marimo_logger
+from marimo._mcp.dependencies import require_mcp_dependencies
LOGGER = marimo_logger()
@@ -31,13 +30,9 @@ def setup_mcp_server(app: Starlette, allow_remote: bool = False) -> None:
app: Starlette application instance for accessing marimo state
allow_remote: If True, disable DNS rebinding protection to allow remote access behind proxies.
"""
- if not DependencyManager.mcp.has():
- raise MarimoCLIMissingDependencyError(
- "MCP dependencies not available.",
- "marimo[mcp]",
- )
+ require_mcp_dependencies()
- from mcp.server.fastmcp import FastMCP
+ from mcp.server import MCPServer
from starlette.middleware.base import BaseHTTPMiddleware
from starlette.responses import JSONResponse
from starlette.routing import Mount
@@ -54,13 +49,9 @@ def setup_mcp_server(app: Starlette, allow_remote: bool = False) -> None:
enable_dns_rebinding_protection=False,
)
- mcp = FastMCP(
+ mcp = MCPServer(
"marimo-mcp-server",
- stateless_http=True,
log_level="WARNING",
- # Change base path from /mcp to /server
- streamable_http_path="/server",
- transport_security=transport_security,
)
# Create context for tools and prompts
@@ -77,7 +68,11 @@ def setup_mcp_server(app: Starlette, allow_remote: bool = False) -> None:
mcp.prompt()(prompt_with_context.as_mcp_prompt_fn())
# Initialize streamable HTTP app
- mcp_app = mcp.streamable_http_app()
+ mcp_app = mcp.streamable_http_app(
+ stateless_http=True,
+ streamable_http_path="/server",
+ transport_security=transport_security,
+ )
# Middleware to require edit scope
class RequiresEditMiddleware(BaseHTTPMiddleware):
diff --git a/marimo/_server/ai/mcp/client.py b/marimo/_server/ai/mcp/client.py
index d36c39c1d1..c14951a3cf 100644
--- a/marimo/_server/ai/mcp/client.py
+++ b/marimo/_server/ai/mcp/client.py
@@ -3,7 +3,6 @@ from __future__ import annotations
import asyncio
import time
-from contextlib import AsyncExitStack
from dataclasses import dataclass, field
from enum import Enum
from typing import TYPE_CHECKING
@@ -23,13 +22,9 @@ from marimo._server.ai.mcp.types import MCPToolArgs
from marimo._utils.asyncio_utils import cancel_and_wait, supervised_task
if TYPE_CHECKING:
- from anyio.streams.memory import (
- MemoryObjectReceiveStream,
- MemoryObjectSendStream,
- )
+ from typing import Protocol
- from mcp import ClientSession # type: ignore[import-not-found]
- from mcp.shared.message import SessionMessage
+ from mcp import Client as MCPConnectionClient
from mcp.types import ( # type: ignore[import-not-found]
CallToolRequestParams,
CallToolResult,
@@ -37,9 +32,28 @@ if TYPE_CHECKING:
Tool,
)
+ class _StructuredContentResult(Protocol):
+ @property
+ def structured_content(self) -> object | None: ...
+
+ class _MetadataCarrier(Protocol):
+ @property
+ def meta(self) -> dict[str, object] | None: ...
+
+
LOGGER = _loggers.marimo_logger()
+def _get_structured_content(
+ result: _StructuredContentResult,
+) -> object | None:
+ return result.structured_content
+
+
+def _get_metadata(value: _MetadataCarrier) -> dict[str, object]:
+ return dict(value.meta or {})
+
+
class MCPServerStatus(Enum):
"""Status of an MCP server connection."""
@@ -54,18 +68,12 @@ class MCPServerConnection:
"""Represents a connection to an MCP server."""
definition: MCPServerDefinition
- session: ClientSession | None = None
+ client: MCPConnectionClient | None = None
status: MCPServerStatus = MCPServerStatus.DISCONNECTED
tools: list[Tool] = field(default_factory=list)
last_health_check: float = 0
error_message: str | None = None
- read_stream: (
- MemoryObjectReceiveStream[SessionMessage | Exception] | None
- ) = None
- write_stream: MemoryObjectSendStream[SessionMessage] | None = None
- exit_stack: AsyncExitStack | None = None
-
- # Minimal additions for task-per-connection fix
+ # The task owns the client's async context from connection through cleanup.
connection_task: asyncio.Task[None] | None = None
disconnect_event: asyncio.Event | None = None
connection_event: asyncio.Event | None = None
@@ -86,12 +94,13 @@ class MCPClient:
self.server_counters: dict[
str, int
] = {} # For handling naming conflicts
- self.transport_registry = MCPTransportRegistry()
+ self.transport_registry: MCPTransportRegistry = MCPTransportRegistry()
self.health_check_tasks: dict[str, asyncio.Task[None]] = {}
self.health_check_interval: float = 30.0 # seconds
self.health_check_timeout: float = (
5.0 # seconds - shorter timeout for health checks
)
+ self.health_check_failure_threshold: int = 3
async def configure(self, config: MCPConfig) -> None:
"""Configure the MCP client with the given configuration.
@@ -120,11 +129,11 @@ class MCPClient:
return
LOGGER.info(
- f"MCP configuration changed: "
- f"{len(diff.servers_to_add)} to add, "
- f"{len(diff.servers_to_remove)} to remove, "
- f"{len(diff.servers_to_update)} to update, "
- f"{len(diff.servers_unchanged)} unchanged"
+ "MCP configuration changed: %d to add, %d to remove, %d to update, %d unchanged",
+ len(diff.servers_to_add),
+ len(diff.servers_to_remove),
+ len(diff.servers_to_update),
+ len(diff.servers_unchanged),
)
# Disconnect from removed servers
@@ -219,8 +228,8 @@ class MCPClient:
return parsed_servers
async def _connection_lifecycle(self, server_name: str) -> None:
- """Minimal wrapper to run existing connection and disconnection logic in task-owned AsyncExitStack."""
- from mcp import ClientSession
+ """Run a task-owned MCP client connection until disconnected."""
+ from mcp import Client
connection = self.connections.get(server_name)
if not connection:
@@ -229,38 +238,27 @@ class MCPClient:
server_def = connection.definition
try:
- # Task-owned AsyncExitStack - same task creates and closes it
- # If a different task tries to close it, it will raise an exception
- async with AsyncExitStack() as exit_stack:
- connection.exit_stack = exit_stack
+ transport_connector = self.transport_registry.get_connector(
+ server_def.transport
+ )
+ mcp_client = Client(
+ transport_connector.create(server_def),
+ mode="auto",
+ read_timeout_seconds=server_def.timeout,
+ )
- # All existing connection logic unchanged
+ # MCP transports use task-affine AnyIO cancel scopes. The lifecycle
+ # task must both enter and exit the client context.
+ async with mcp_client:
+ connection.client = mcp_client
LOGGER.info(
f"Connecting to MCP server: {server_name} (transport: {server_def.transport})"
)
- transport_connector = self.transport_registry.get_connector(
- server_def.transport
- )
- read, write, *_ = await transport_connector.connect(
- server_def, exit_stack
- )
-
- connection.read_stream = read
- connection.write_stream = write
-
- connection.session = await exit_stack.enter_async_context(
- ClientSession(read, write)
- )
-
- if connection.session is None:
- raise RuntimeError("Session was not properly created")
- await connection.session.initialize()
-
+ await self._discover_tools(connection)
self._update_server_status(
server_name, MCPServerStatus.CONNECTED
)
- await self._discover_tools(connection)
if server_name not in self.health_check_tasks:
self.health_check_tasks[server_name] = supervised_task(
@@ -283,8 +281,6 @@ class MCPClient:
# Cancel health monitoring
await self._cancel_health_monitoring(server_name)
- # AsyncExitStack cleans up automatically here in same task
-
except Exception as e:
error_msg = f"Failed to connect to MCP server {server_name} (transport: {server_def.transport}): {e!s}"
LOGGER.error(error_msg)
@@ -298,13 +294,11 @@ class MCPClient:
finally:
# Clean up connection state
self._remove_server_tools(server_name)
- self._update_server_status(
- server_name, MCPServerStatus.DISCONNECTED
- )
- connection.session = None
- connection.read_stream = None
- connection.write_stream = None
- connection.exit_stack = None
+ if connection.status != MCPServerStatus.ERROR:
+ self._update_server_status(
+ server_name, MCPServerStatus.DISCONNECTED
+ )
+ connection.client = None
async def connect_to_server(self, server_name: str) -> bool:
"""Connect to an MCP server using the appropriate transport."""
@@ -314,11 +308,13 @@ class MCPClient:
server_def = self.servers[server_name]
- # Check if already connected
- if server_name in self.connections:
+ existing_connection = self.connections.get(server_name)
+ if existing_connection:
current_status = self.get_server_status(server_name)
if current_status == MCPServerStatus.CONNECTED:
return True
+ if existing_connection.connection_task:
+ await self.disconnect_from_server(server_name)
try:
# Create connection with minimal task-per-connection additions
@@ -350,14 +346,23 @@ class MCPClient:
# Event was set, but check if it was success or error
current_status = self.get_server_status(server_name)
return current_status == MCPServerStatus.CONNECTED
+ except asyncio.CancelledError:
+ await cancel_and_wait(connection_task)
+ raise
except asyncio.TimeoutError:
- # Connection timed out, but keep task running in background
- LOGGER.warning(
- f"Connection to {server_name} is taking longer than {server_def.timeout}s, continuing in background"
+ # A lifecycle can time out before it reaches disconnect_event.
+ # Letting it continue would make refresh and shutdown wait on a
+ # task that they cannot signal, so a timeout is terminal.
+ error_msg = (
+ f"Connection to {server_name} timed out after "
+ f"{server_def.timeout}s"
)
- # Return True if still connecting, False if error occurred
- current_status = self.get_server_status(server_name)
- return current_status == MCPServerStatus.CONNECTING
+ LOGGER.warning(error_msg)
+ self._update_server_status(
+ server_name, MCPServerStatus.ERROR, error_msg
+ )
+ await cancel_and_wait(connection_task)
+ return False
except Exception as e:
error_msg = f"Failed to connect to MCP server {server_name} (transport: {server_def.transport}): {e!s}"
@@ -370,30 +375,39 @@ class MCPClient:
async def _discover_tools(self, connection: MCPServerConnection) -> None:
"""Discover tools from an MCP server."""
- try:
- LOGGER.info(
- f"Discovering tools for server: {connection.definition.name}"
- )
+ LOGGER.info(
+ f"Discovering tools for server: {connection.definition.name}"
+ )
+
+ if not connection.client:
+ raise RuntimeError("No active client for tool discovery")
- if not connection.session:
- raise RuntimeError("No active session for tool discovery")
+ tools: list[Tool] = []
+ cursor: str | None = None
+ seen_cursors: set[str] = set()
- # Use the MCP SDK to discover tools
+ # Tool discovery is bounded by the connection timeout, which cancels
+ # the lifecycle task if pagination does not complete.
+ while True:
tools_response: ListToolsResult = (
- await connection.session.list_tools()
+ await connection.client.list_tools(cursor=cursor)
)
+ tools.extend(tools_response.tools)
+ cursor = tools_response.next_cursor
+ if cursor is None:
+ break
+ if cursor in seen_cursors:
+ raise RuntimeError(
+ f"Tool discovery returned repeated cursor {cursor!r}"
+ )
+ seen_cursors.add(cursor)
- # Add discovered tools
- self._add_server_tools(connection, tools_response.tools)
-
- LOGGER.info(
- f"Discovered {len(connection.tools)} tools from {connection.definition.name}"
- )
+ self._remove_server_tools(connection.definition.name)
+ self._add_server_tools(connection, tools)
- except Exception as e:
- LOGGER.error(
- f"Tool discovery failed for {connection.definition.name}: {e!s}"
- )
+ LOGGER.info(
+ f"Discovered {len(connection.tools)} tools from {connection.definition.name}"
+ )
def _create_namespaced_tool_name(
self, server_name: str, tool_name: str
@@ -449,20 +463,20 @@ class MCPClient:
error_message: The error message to include
Returns:
- CallToolResult with isError=True and the error message
+ CallToolResult with `is_error=True` and the error message.
"""
# Based on the MCP SDK error handling:
# https://modelcontextprotocol.io/docs/concepts/tools#error-handling
from mcp.types import CallToolResult, TextContent
return CallToolResult(
- isError=True,
+ is_error=True,
content=[TextContent(type="text", text=error_message)],
)
def is_error_result(self, result: CallToolResult) -> bool:
"""Check if a CallToolResult represents an error."""
- return hasattr(result, "isError") and result.isError is True
+ return result.is_error is True
async def invoke_tool(
self,
@@ -484,8 +498,8 @@ class MCPClient:
)
# Get server_name from meta field
- server_name = tool.meta.get("server_name") if tool.meta else None
- if not server_name:
+ server_name = _get_metadata(tool).get("server_name")
+ if not isinstance(server_name, str):
return self._create_error_result(
f"Internal error: Tool '{namespaced_tool_name}' missing server information"
)
@@ -496,9 +510,9 @@ class MCPClient:
)
connection = self.connections.get(server_name)
- if not connection or not connection.session:
+ if not connection or not connection.client:
return self._create_error_result(
- f"Internal error: No active session for server '{server_name}'"
+ f"Internal error: No active client for server '{server_name}'"
)
try:
@@ -509,7 +523,7 @@ class MCPClient:
# Use asyncio.wait_for for timeout handling
timeout = connection.definition.timeout
result = await asyncio.wait_for(
- connection.session.call_tool(params.name, params.arguments),
+ connection.client.call_tool(params.name, params.arguments),
timeout=timeout,
)
@@ -520,7 +534,7 @@ class MCPClient:
)
return self._create_error_result("Tool returned empty result")
- # Return the MCP SDK result directly (may already have isError=True)
+ # Return the MCP SDK result directly (may already be an error).
return result
except asyncio.TimeoutError:
@@ -574,13 +588,56 @@ class MCPClient:
)
# Log if this was an error result (for debugging purposes)
- if hasattr(result, "isError") and result.isError:
+ if result.is_error:
LOGGER.debug(
f"Extracted text content from error result: {len(text_contents)} items"
)
return text_contents
+ def convert_tool_result(self, result: CallToolResult) -> object | None:
+ """Convert an MCP result into a JSON-serializable tool output.
+
+ Structured content is the most useful representation for an AI model.
+ Text-only results retain the existing string shape. Mixed or non-text
+ content keeps every MCP content block instead of silently dropping it.
+ """
+ structured_content = _get_structured_content(result)
+ if structured_content is not None:
+ return structured_content
+
+ if not result.content:
+ return None
+
+ from mcp.types import TextContent
+
+ text_content = [
+ item for item in result.content if isinstance(item, TextContent)
+ ]
+ if len(text_content) == len(result.content):
+ return " ".join(item.text for item in text_content)
+
+ return {
+ "content": [
+ item.model_dump(by_alias=True, mode="json", exclude_none=True)
+ for item in result.content
+ ]
+ }
+
+ def format_tool_error(self, result: CallToolResult) -> str:
+ """Convert an MCP error result into a stable message."""
+ import json
+
+ converted = self.convert_tool_result(result)
+ if converted is None:
+ return "Unknown MCP tool error"
+ if isinstance(converted, str):
+ return converted
+ try:
+ return json.dumps(converted, ensure_ascii=False, sort_keys=True)
+ except (TypeError, ValueError):
+ return str(converted)
+
def get_all_tools(self) -> list[Tool]:
"""Get all registered MCP tools."""
return list(self.tool_registry.values())
@@ -604,15 +661,19 @@ class MCPClient:
async def _monitor_server_health(self, server_name: str) -> None:
"""Continuously monitor server health."""
+ consecutive_failures = 0
try:
- while True:
+ while (
+ self.get_server_status(server_name)
+ == MCPServerStatus.CONNECTED
+ ):
try:
await asyncio.sleep(self.health_check_interval)
-
- # Use the public API to check server status
- current_status = self.get_server_status(server_name)
- if current_status != MCPServerStatus.CONNECTED:
- continue
+ if (
+ self.get_server_status(server_name)
+ != MCPServerStatus.CONNECTED
+ ):
+ break
# Perform health check
health_check_passed = await self._perform_health_check(
@@ -620,6 +681,7 @@ class MCPClient:
)
if health_check_passed:
+ consecutive_failures = 0
# Handle successful health check
LOGGER.debug(f"Health check passed for {server_name}")
connection = self.connections.get(server_name)
@@ -627,15 +689,24 @@ class MCPClient:
# Update last health check time
connection.last_health_check = time.time()
else:
- # Handle failed health check
+ consecutive_failures += 1
LOGGER.warning(
- f"Health check failed for {server_name}, marking as ERROR and removing from monitoring"
+ "Health check failed for %s (%d/%d)",
+ server_name,
+ consecutive_failures,
+ self.health_check_failure_threshold,
)
+ if (
+ consecutive_failures
+ < self.health_check_failure_threshold
+ ):
+ continue
+
# Determine the appropriate error message based on connection state
connection = self.connections.get(server_name)
- if connection and not connection.session:
- error_msg = "No active session"
+ if connection and not connection.client:
+ error_msg = "No active client"
else:
error_msg = "Health check failed"
@@ -644,6 +715,8 @@ class MCPClient:
server_name, MCPServerStatus.ERROR, error_msg
)
self._remove_server_tools(server_name)
+ if connection and connection.disconnect_event:
+ connection.disconnect_event.set()
break # Exit monitoring loop on failure
except asyncio.CancelledError:
@@ -656,8 +729,9 @@ class MCPClient:
finally:
# Clean up the monitoring task from the registry
# Note: Don't cancel here since the task is already exiting
- if server_name in self.health_check_tasks:
- del self.health_check_tasks[server_name]
+ current_task = asyncio.current_task()
+ if self.health_check_tasks.get(server_name) is current_task:
+ self.health_check_tasks.pop(server_name, None)
LOGGER.debug(
f"Removed health monitoring task for {server_name}"
)
@@ -669,13 +743,11 @@ class MCPClient:
return False
try:
- if not connection.session:
+ if not connection.client:
return False
- # Use official MCP ping method for health check
- # https://modelcontextprotocol.io/specification/2025-03-26/basic/utilities/ping
await asyncio.wait_for(
- connection.session.send_ping(),
+ connection.client.list_tools(cache_mode="refresh"),
timeout=self.health_check_timeout,
)
@@ -719,8 +791,6 @@ class MCPClient:
connection: Server connection to add tools to
tools: List of raw MCP tools to add
"""
- from mcp.types import Tool # type: ignore[import-not-found]
-
server_name = connection.definition.name
for tool in tools:
@@ -728,18 +798,13 @@ class MCPClient:
server_name, tool.name
)
- # Create MCP tool with metadata
- # Note: MCP SDK Tool constructor uses _meta parameter (with underscore)
- # but exposes the data as .meta attribute (without underscore) after creation
- mcp_tool = Tool(
- name=tool.name,
- description=tool.description,
- inputSchema=tool.inputSchema,
- _meta={
- "server_name": server_name,
- "namespaced_name": namespaced_name,
- },
+ # Keep the complete tool definition while attaching routing metadata.
+ metadata = _get_metadata(tool)
+ metadata.update(
+ server_name=server_name,
+ namespaced_name=namespaced_name,
)
+ mcp_tool = tool.model_copy(update={"meta": metadata})
# Add to connection and registry
connection.tools.append(mcp_tool)
@@ -793,24 +858,21 @@ class MCPClient:
server_name: Server name to cancel monitoring for. If None, cancels all.
"""
if server_name is not None:
- # Cancel single server monitoring
- if server_name in self.health_check_tasks:
- await cancel_and_wait(self.health_check_tasks[server_name])
- del self.health_check_tasks[server_name]
+ task = self.health_check_tasks.pop(server_name, None)
+ if task:
+ await cancel_and_wait(task)
LOGGER.debug(f"Cancelled health monitoring for {server_name}")
else:
- # Cancel all server monitoring
- if self.health_check_tasks:
- # Cancel all tasks
- for task in self.health_check_tasks.values():
+ tasks = list(self.health_check_tasks.values())
+ self.health_check_tasks.clear()
+ if tasks:
+ for task in tasks:
task.cancel()
- # Wait for all tasks to complete
await asyncio.gather(
- *self.health_check_tasks.values(),
+ *tasks,
return_exceptions=True,
)
- self.health_check_tasks.clear()
LOGGER.debug("Cancelled all health monitoring tasks")
async def disconnect_from_server(self, server_name: str) -> bool:
@@ -832,11 +894,12 @@ class MCPClient:
connection.disconnect_event.set()
# Wait for the connection task to complete its cleanup
- if (
- connection.connection_task
- and not connection.connection_task.done()
- ):
- await connection.connection_task
+ if connection.connection_task:
+ try:
+ await asyncio.shield(connection.connection_task)
+ except asyncio.CancelledError:
+ if not connection.connection_task.cancelled():
+ raise
LOGGER.info(f"Disconnected from MCP server: {server_name}")
return True
@@ -864,7 +927,7 @@ class MCPClient:
# Global MCP client instance using lazy initialization
-_MCP_CLIENT: MCPClient | None = None
+_mcp_client: MCPClient | None = None
def get_mcp_client() -> MCPClient:
@@ -873,8 +936,8 @@ def get_mcp_client() -> MCPClient:
Note: The client must be configured using await client.configure(config)
before connecting to servers.
"""
- global _MCP_CLIENT
- if _MCP_CLIENT is None:
- _MCP_CLIENT = MCPClient()
+ global _mcp_client
+ if _mcp_client is None:
+ _mcp_client = MCPClient()
LOGGER.info("MCP client initialized")
- return _MCP_CLIENT
+ return _mcp_client
diff --git a/marimo/_server/ai/mcp/transport.py b/marimo/_server/ai/mcp/transport.py
index fca7ec9b38..f3773c7fbb 100644
--- a/marimo/_server/ai/mcp/transport.py
+++ b/marimo/_server/ai/mcp/transport.py
@@ -3,18 +3,37 @@ from __future__ import annotations
import os
from abc import ABC, abstractmethod
+from contextlib import asynccontextmanager
from enum import Enum
-from typing import TYPE_CHECKING, cast
+from typing import TYPE_CHECKING
+
+from marimo._utils.typing import override
if TYPE_CHECKING:
- from contextlib import AsyncExitStack
+ from collections.abc import AsyncGenerator
+ from typing import TypeGuard
from marimo._config.config import (
+ MCPServerConfig,
MCPServerStdioConfig,
MCPServerStreamableHttpConfig,
)
from marimo._server.ai.mcp.config import MCPServerDefinition
- from marimo._server.ai.mcp.types import TransportConnectorResponse
+ from mcp.client import Transport
+ from mcp.shared._stream_protocols import ReadStream, WriteStream
+ from mcp.shared.message import SessionMessage
+
+
+def _is_stdio_config(
+ config: MCPServerConfig,
+) -> TypeGuard[MCPServerStdioConfig]:
+ return "command" in config
+
+
+def _is_streamable_http_config(
+ config: MCPServerConfig,
+) -> TypeGuard[MCPServerStreamableHttpConfig]:
+ return "url" in config
class MCPTransportType(str, Enum):
@@ -29,33 +48,28 @@ class MCPTransportConnector(ABC):
"""Abstract base class for MCP transport connectors."""
@abstractmethod
- async def connect(
- self, server_def: MCPServerDefinition, exit_stack: AsyncExitStack
- ) -> TransportConnectorResponse:
- """Connect to the MCP server and return read/write streams.
+ def create(self, server_def: MCPServerDefinition) -> Transport:
+ """Create a transport for an MCP server.
Args:
server_def: Server definition with transport-specific parameters
- exit_stack: Async exit stack for resource management
Returns:
- Tuple of (read_stream, write_stream) for the ClientSession
+ A transport managed by the MCP client.
"""
class StdioTransportConnector(MCPTransportConnector):
"""STDIO transport connector for process-based MCP servers."""
- async def connect(
- self, server_def: MCPServerDefinition, exit_stack: AsyncExitStack
- ) -> TransportConnectorResponse:
- # Import MCP SDK components for stdio transport
+ @override
+ def create(self, server_def: MCPServerDefinition) -> Transport:
from mcp import StdioServerParameters
from mcp.client.stdio import stdio_client
- # Type narrowing for mypy
- assert "command" in server_def.config
- config = cast("MCPServerStdioConfig", server_def.config)
+ config = server_def.config
+ if not _is_stdio_config(config):
+ raise ValueError("STDIO transport requires a command")
# Set up environment variables for the server process
env = os.environ.copy()
@@ -68,59 +82,41 @@ class StdioTransportConnector(MCPTransportConnector):
env=env,
)
- # Establish connection with proper resource management
- read, write, *_ = await exit_stack.enter_async_context(
- stdio_client(server_params)
- )
-
- return read, write
+ return stdio_client(server_params)
class StreamableHTTPTransportConnector(MCPTransportConnector):
"""Streamable HTTP transport connector for modern HTTP-based MCP servers."""
- async def connect(
- self, server_def: MCPServerDefinition, exit_stack: AsyncExitStack
- ) -> TransportConnectorResponse:
- # Import MCP SDK components for streamable HTTP transport
- # Try for latest MCP SDK v2.0
- try:
- import httpx
-
- from mcp.client.streamable_http import streamable_http_client
-
- # Type narrowing for mypy
- assert "url" in server_def.config
- config = cast("MCPServerStreamableHttpConfig", server_def.config)
-
- headers = config.get("headers", {})
- http_client = httpx.AsyncClient(
- headers=headers, timeout=server_def.timeout
- )
-
- # Establish streamable HTTP connection
- read, write, *_ = await exit_stack.enter_async_context(
- streamable_http_client(
- config["url"],
- http_client=http_client,
- )
- )
- # Fallback to ealierst implementation of MCP SDK v1.8 to v1.28
- except ImportError:
- from mcp.client.streamable_http import streamablehttp_client
-
- assert "url" in server_def.config
- config = cast("MCPServerStreamableHttpConfig", server_def.config)
-
- read, write, *_ = await exit_stack.enter_async_context(
- streamablehttp_client(
- config["url"],
- headers=config.get("headers", {}),
- timeout=server_def.timeout,
- )
- )
-
- return read, write
+ @override
+ def create(self, server_def: MCPServerDefinition) -> Transport:
+ import httpx2
+
+ from mcp.client.streamable_http import streamable_http_client
+
+ config = server_def.config
+ if not _is_streamable_http_config(config):
+ raise ValueError("Streamable HTTP transport requires a URL")
+
+ @asynccontextmanager
+ async def transport() -> AsyncGenerator[
+ tuple[
+ ReadStream[SessionMessage | Exception],
+ WriteStream[SessionMessage],
+ ]
+ ]:
+ timeout = httpx2.Timeout(server_def.timeout, read=300.0)
+ async with httpx2.AsyncClient(
+ headers=config.get("headers", {}),
+ follow_redirects=True,
+ timeout=timeout,
+ ) as http_client:
+ async with streamable_http_client(
+ config["url"], http_client=http_client
+ ) as streams:
+ yield streams
+
+ return transport()
class MCPTransportRegistry:
diff --git a/marimo/_server/ai/mcp/types.py b/marimo/_server/ai/mcp/types.py
index 380edc8b88..76dd831029 100644
--- a/marimo/_server/ai/mcp/types.py
+++ b/marimo/_server/ai/mcp/types.py
@@ -1,22 +1,15 @@
# Copyright 2026 Marimo. All rights reserved.
from __future__ import annotations
-from typing import TYPE_CHECKING, Any
-
-if TYPE_CHECKING:
- from anyio.streams.memory import (
- MemoryObjectReceiveStream,
- MemoryObjectSendStream,
- )
-
- from mcp.shared.message import SessionMessage
-
-
-# Type alias that matches the MCP SDK's CallToolRequestParams.arguments type
-MCPToolArgs = dict[str, Any] | None
-
-# Type alias for MCP transport connection streams
-TransportConnectorResponse = tuple[
- "MemoryObjectReceiveStream[SessionMessage | Exception]",
- "MemoryObjectSendStream[SessionMessage]",
-]
+from typing import TypeAlias
+
+MCPToolValue: TypeAlias = (
+ str
+ | int
+ | float
+ | bool
+ | None
+ | list["MCPToolValue"]
+ | dict[str, "MCPToolValue"]
+)
+MCPToolArgs: TypeAlias = dict[str, MCPToolValue] | None
diff --git a/marimo/_server/ai/tools/tool_manager.py b/marimo/_server/ai/tools/tool_manager.py
index 486120815e..de02fe7a0f 100644
--- a/marimo/_server/ai/tools/tool_manager.py
+++ b/marimo/_server/ai/tools/tool_manager.py
@@ -176,7 +176,7 @@ class ToolManager:
return ToolDefinition(
name=namespaced_name or mcp_tool.name,
description=mcp_tool.description or "No description available",
- parameters=mcp_tool.inputSchema,
+ parameters=mcp_tool.input_schema,
source="mcp",
# MCP tools available in ask mode and agent mode
# TODO: Determine which tools to support in agent mode
@@ -251,15 +251,7 @@ class ToolManager:
mcp_client = get_mcp_client()
if mcp_client.is_error_result(call_result):
- # Extract error message from the result content
- error_messages = mcp_client.extract_text_content(
- call_result
- )
- error_text = (
- " ".join(error_messages)
- if error_messages
- else "Unknown MCP tool error"
- )
+ error_text = mcp_client.format_tool_error(call_result)
LOGGER.error(
f"MCP tool '{tool_name}' returned error: {error_text}"
)
@@ -267,15 +259,11 @@ class ToolManager:
tool_name=tool_name, result=None, error=error_text
)
- # For successful results, extract text content from CallToolResult
- success_messages = mcp_client.extract_text_content(call_result)
- result_text = (
- " ".join(success_messages)
- if success_messages
- else "MCP tool completed successfully with no text output"
- )
+ result = mcp_client.convert_tool_result(call_result)
+ if result is None:
+ result = "MCP tool completed successfully with no output"
return ToolCallResult(
- tool_name=tool_name, result=result_text, error=None
+ tool_name=tool_name, result=result, error=None
)
else:
diff --git a/pyproject.toml b/pyproject.toml
index 723ab67c06..b7420902dc 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -117,8 +117,8 @@ lsp = [
]
mcp = [
- "mcp>=1.0.0,<2", # MCP 2.0 is a major rework, unsupported for now.
- "pydantic>2",
+ "httpx2>=2.5.0,<3",
+ "mcp>=2.0.0,<3",
]
otel = [
@@ -225,7 +225,7 @@ test-optional = [
"flax>=0.10.0; python_version == '3.12'",
"torch>=2.4.0; python_version == '3.12'",
"scikit-bio>=0.6.3; python_version == '3.12'",
- "mcp>=1.0.0,<2",
+ "mcp>=2.0.0,<3",
# zeromq
"pyzmq>=27.1.0",
# weave tracing integration
@@ -264,7 +264,7 @@ typecheck = [
"types-Markdown>=3.6.0.20240316",
"types-PyYAML>=6.0.12.20240808",
"types-docutils>=0.21.0.20241128",
- "mcp>=1.0.0,<2",
+ "mcp>=2.0.0,<3",
# zeromq
"pyzmq>=27.1.0",
"pyarrow-stubs",
diff --git a/tests/_mcp/code_server/test_code_server.py b/tests/_mcp/code_server/test_code_server.py
index 025c469e04..38b6ad8ac6 100644
--- a/tests/_mcp/code_server/test_code_server.py
+++ b/tests/_mcp/code_server/test_code_server.py
@@ -5,6 +5,7 @@ from unittest.mock import MagicMock
import pytest
+from marimo._dependencies.dependencies import DependencyManager
from marimo._mcp.code_server.lifespan import code_mcp_server_lifespan
pytest.importorskip("mcp", reason="MCP requires Python 3.10+")
@@ -52,6 +53,46 @@ def test_code_mcp_server_starts_up():
assert any("/mcp" in str(route.path) for route in app.routes)
+def test_code_mcp_server_requires_supported_mcp_version(monkeypatch):
+ from marimo._cli.errors import MarimoCLIMissingDependencyError
+
+ has_required_version = MagicMock(return_value=False)
+ has_mcp = MagicMock(return_value=True)
+ get_version = MagicMock(return_value="1.9.0")
+ monkeypatch.setattr(
+ DependencyManager.mcp,
+ "has_required_version",
+ has_required_version,
+ )
+ monkeypatch.setattr(DependencyManager.mcp, "has", has_mcp)
+ monkeypatch.setattr(DependencyManager.mcp, "get_version", get_version)
+
+ with pytest.raises(
+ MarimoCLIMissingDependencyError,
+ match="MCP SDK 1.9.0 is not supported",
+ ):
+ setup_code_mcp_server(Starlette())
+
+ has_required_version.assert_called_once_with(quiet=True)
+ has_mcp.assert_called_once_with(quiet=True)
+ get_version.assert_called_once_with()
+
+
+async def test_code_mcp_server_supports_modern_protocol():
+ """The v2 code server should expose its tools over the modern protocol."""
+ from mcp import Client
+
+ app = create_test_app()
+ async with Client(app.state.code_mcp) as client:
+ tools = await client.list_tools()
+
+ assert client.protocol_version == "2026-07-28"
+ assert {tool.name for tool in tools.tools} == {
+ "execute_code",
+ "list_sessions",
+ }
+
+
async def test_code_mcp_server_requires_edit_scope():
"""Test that Code MCP server validates 'edit' scope is present."""
diff --git a/tests/_mcp/server/test_mcp_server.py b/tests/_mcp/server/test_mcp_server.py
index f3346f6fed..4cd5079c16 100644
--- a/tests/_mcp/server/test_mcp_server.py
+++ b/tests/_mcp/server/test_mcp_server.py
@@ -1,6 +1,10 @@
# Copyright 2026 Marimo. All rights reserved.
+from unittest.mock import MagicMock
+
import pytest
+from marimo._cli.errors import MarimoCLIMissingDependencyError
+from marimo._dependencies.dependencies import DependencyManager
from marimo._mcp.server.lifespan import mcp_server_lifespan
pytest.importorskip("mcp", reason="MCP requires Python 3.10+")
@@ -44,6 +48,90 @@ def test_mcp_server_starts_up():
assert any("/mcp" in str(route.path) for route in app.routes)
+def test_mcp_server_requires_supported_mcp_version(monkeypatch):
+ has_required_version = MagicMock(return_value=False)
+ has_mcp = MagicMock(return_value=True)
+ get_version = MagicMock(return_value="1.9.0")
+ monkeypatch.setattr(
+ DependencyManager.mcp,
+ "has_required_version",
+ has_required_version,
+ )
+ monkeypatch.setattr(DependencyManager.mcp, "has", has_mcp)
+ monkeypatch.setattr(DependencyManager.mcp, "get_version", get_version)
+
+ with pytest.raises(
+ MarimoCLIMissingDependencyError,
+ match="MCP SDK 1.9.0 is not supported",
+ ):
+ setup_mcp_server(Starlette())
+
+ has_required_version.assert_called_once_with(quiet=True)
+ has_mcp.assert_called_once_with(quiet=True)
+ get_version.assert_called_once_with()
+
+
+def test_mcp_server_requires_mcp_dependency(monkeypatch):
+ has_required_version = MagicMock(return_value=False)
+ has_mcp = MagicMock(return_value=False)
+ monkeypatch.setattr(
+ DependencyManager.mcp,
+ "has_required_version",
+ has_required_version,
+ )
+ monkeypatch.setattr(DependencyManager.mcp, "has", has_mcp)
+
+ with pytest.raises(
+ MarimoCLIMissingDependencyError,
+ match="MCP dependencies not available",
+ ):
+ setup_mcp_server(Starlette())
+
+ has_required_version.assert_called_once_with(quiet=True)
+ has_mcp.assert_called_once_with(quiet=True)
+
+
+async def test_mcp_server_supports_modern_protocol():
+ """The v2 server should negotiate the modern protocol directly."""
+ from mcp import Client
+
+ app = create_test_app()
+ async with Client(app.state.mcp) as client:
+ tools = await client.list_tools()
+ prompts = await client.list_prompts()
+
+ assert client.protocol_version == "2026-07-28"
+ assert tools.tools
+ assert {prompt.name for prompt in prompts.prompts} == {
+ "active_notebooks",
+ "errors_summary",
+ }
+
+
+async def test_mcp_server_supports_streamable_http():
+ import httpx2
+ from mcp import Client
+ from mcp.client.streamable_http import streamable_http_client
+
+ app = create_test_app()
+ http_transport = httpx2.ASGITransport(app=app)
+ async with mcp_server_lifespan(app):
+ async with httpx2.AsyncClient(
+ transport=http_transport,
+ base_url="http://localhost:8000",
+ follow_redirects=True,
+ ) as http_client:
+ transport = streamable_http_client(
+ "http://localhost:8000/mcp/server",
+ http_client=http_client,
+ )
+ async with Client(transport, mode="2026-07-28") as client:
+ tools = await client.list_tools()
+
+ assert client.protocol_version == "2026-07-28"
+ assert tools.tools
+
+
async def test_mcp_server_requires_edit_scope():
"""Test that MCP server validates 'edit' scope is present."""
app = create_test_app()
diff --git a/tests/_server/ai/test_mcp.py b/tests/_server/ai/test_mcp.py
index ddcb23720b..d3cda9831e 100644
--- a/tests/_server/ai/test_mcp.py
+++ b/tests/_server/ai/test_mcp.py
@@ -104,7 +104,7 @@ def create_test_server_connection(
args: list | None = None,
env: dict | None = None,
status: MCPServerStatus = MCPServerStatus.DISCONNECTED,
- session=None,
+ client=None,
timeout: float | None = None,
) -> MCPServerConnection:
"""Create a test server connection with sensible defaults."""
@@ -113,7 +113,7 @@ def create_test_server_connection(
)
connection = MCPServerConnection(definition=server_def)
connection.status = status
- connection.session = session
+ connection.client = client
return connection
@@ -136,7 +136,7 @@ def create_test_tool(
return Tool(
name=name,
description=description,
- inputSchema=input_schema,
+ input_schema=input_schema,
_meta={
"server_name": server_name,
"namespaced_name": namespaced_name,
@@ -145,6 +145,16 @@ def create_test_tool(
return None
+def create_connection_task(
+ error: Exception | None = None,
+) -> asyncio.Task[None]:
+ async def lifecycle() -> None:
+ if error is not None:
+ raise error
+
+ return asyncio.create_task(lifecycle())
+
+
# tests
@@ -489,16 +499,9 @@ class TestMCPTransportConnectors:
not DependencyManager.mcp.has(), reason="MCP SDK not available"
)
@patch("mcp.client.stdio.stdio_client")
- async def test_stdio_connector_connect(self, mock_stdio_client):
- """Test STDIO transport connector connection."""
- # Setup mocks
- mock_read = AsyncMock()
- mock_write = AsyncMock()
+ def test_stdio_connector_create(self, mock_stdio_client):
+ """Test STDIO transport creation."""
mock_context = AsyncMock()
- mock_context.__aenter__ = AsyncMock(
- return_value=(mock_read, mock_write)
- )
- mock_context.__aexit__ = AsyncMock(return_value=None)
mock_stdio_client.return_value = mock_context
# Create connector and test connection
@@ -510,19 +513,24 @@ class TestMCPTransportConnectors:
name="test", transport=MCPTransportType.STDIO, config=config
)
- from contextlib import AsyncExitStack
+ transport = connector.create(server_def)
- async with AsyncExitStack() as exit_stack:
- read, write = await connector.connect(server_def, exit_stack)
- assert read == mock_read
- assert write == mock_write
+ assert transport is mock_context
+ parameters = mock_stdio_client.call_args.args[0]
+ assert parameters.command == "python"
+ assert parameters.args == ["server.py"]
+ assert parameters.env is not None
+ assert parameters.env["TEST_VAR"] == "value"
@pytest.mark.skipif(
not DependencyManager.mcp.has(), reason="MCP SDK not available"
)
+ @patch("httpx2.AsyncClient")
@patch("mcp.client.streamable_http.streamable_http_client")
- async def test_http_connector_connect(self, mock_http_client):
- """Test HTTP transport connector connection."""
+ async def test_http_connector_create(
+ self, mock_streamable_http_client, mock_httpx_client
+ ):
+ """Test HTTP transport creation."""
# Setup mocks
mock_read = AsyncMock()
mock_write = AsyncMock()
@@ -531,7 +539,14 @@ class TestMCPTransportConnectors:
return_value=(mock_read, mock_write)
)
mock_context.__aexit__ = AsyncMock(return_value=None)
- mock_http_client.return_value = mock_context
+ mock_streamable_http_client.return_value = mock_context
+
+ mock_httpx_context = AsyncMock()
+ mock_httpx_client.return_value = mock_httpx_context
+ mock_httpx_context.__aenter__ = AsyncMock(
+ return_value=mock_httpx_context
+ )
+ mock_httpx_context.__aexit__ = AsyncMock(return_value=None)
# Create connector and test connection
connector = StreamableHTTPTransportConnector()
@@ -547,60 +562,27 @@ class TestMCPTransportConnectors:
timeout=30.0,
)
- from contextlib import AsyncExitStack
-
- async with AsyncExitStack() as exit_stack:
- read, write = await connector.connect(server_def, exit_stack)
+ transport = connector.create(server_def)
+ async with transport as (read, write):
assert read == mock_read
assert write == mock_write
- @pytest.mark.skipif(
- not DependencyManager.mcp.has(), reason="MCP SDK not available"
- )
- @patch("mcp.client.streamable_http.streamablehttp_client")
- @patch.dict("sys.modules", {})
- async def test_http_connector_connect_legacy_fallback(
- self, mock_streamablehttp_client
- ):
- """Test HTTP transport connector fallback to streamablehttp_client on ImportError."""
- mock_read = AsyncMock()
- mock_write = AsyncMock()
- mock_context = AsyncMock()
- mock_context.__aenter__ = AsyncMock(
- return_value=(mock_read, mock_write)
- )
- mock_context.__aexit__ = AsyncMock(return_value=None)
- mock_streamablehttp_client.return_value = mock_context
-
- connector = StreamableHTTPTransportConnector()
- config = MCPServerStreamableHttpConfig(
- url="https://api.example.com/mcp",
- headers={"Authorization": "Bearer token"},
- timeout=30.0,
- )
- server_def = MCPServerDefinition(
- name="test",
- transport=MCPTransportType.STREAMABLE_HTTP,
- config=config,
- timeout=30.0,
+ mock_httpx_client.assert_called_once()
+ http_client_kwargs = mock_httpx_client.call_args.kwargs
+ assert http_client_kwargs["headers"] == {
+ "Authorization": "Bearer token"
+ }
+ assert http_client_kwargs["follow_redirects"] is True
+ timeout = http_client_kwargs["timeout"]
+ assert timeout.connect == 30.0
+ assert timeout.read == 300.0
+ assert timeout.write == 30.0
+ assert timeout.pool == 30.0
+ mock_streamable_http_client.assert_called_once_with(
+ "https://api.example.com/mcp",
+ http_client=mock_httpx_context,
)
- from contextlib import AsyncExitStack
-
- with patch(
- "mcp.client.streamable_http.streamable_http_client",
- side_effect=ImportError,
- ):
- async with AsyncExitStack() as exit_stack:
- read, write = await connector.connect(server_def, exit_stack)
- assert read == mock_read
- assert write == mock_write
- mock_streamablehttp_client.assert_called_once_with(
- "https://api.example.com/mcp",
- headers={"Authorization": "Bearer token"},
- timeout=30.0,
- )
-
class TestMCPClientConfiguration:
"""Test cases for MCPClient configuration parsing and initialization."""
@@ -957,7 +939,7 @@ class TestMCPClientToolManagement:
tool1 = Tool(
name="create_issue",
description="Test tool",
- inputSchema={},
+ input_schema={"type": "object"},
_meta={"server_name": "github", "namespaced_name": name1},
)
client.tool_registry[name1] = tool1
@@ -989,12 +971,12 @@ class TestMCPClientToolManagement:
Tool(
name="tool1",
description="Test tool 1",
- inputSchema={"type": "object"},
+ input_schema={"type": "object"},
),
Tool(
name="tool2",
description="Test tool 2",
- inputSchema={"type": "object"},
+ input_schema={"type": "object"},
),
]
@@ -1028,7 +1010,7 @@ class TestMCPClientToolManagement:
Tool(
name="tool1",
description="Test",
- inputSchema={},
+ input_schema={"type": "object"},
_meta={
"server_name": "server1",
"namespaced_name": "mcp_server1_tool1",
@@ -1040,7 +1022,7 @@ class TestMCPClientToolManagement:
Tool(
name="tool2",
description="Test",
- inputSchema={},
+ input_schema={"type": "object"},
_meta={
"server_name": "server1",
"namespaced_name": "mcp_server1_tool2",
@@ -1054,7 +1036,7 @@ class TestMCPClientToolManagement:
Tool(
name="tool3",
description="Test",
- inputSchema={},
+ input_schema={"type": "object"},
_meta={
"server_name": "server2",
"namespaced_name": "mcp_server2_tool3",
@@ -1118,7 +1100,7 @@ class TestMCPClientToolManagement:
tool = Tool(
name=namespaced_name.split("_")[-1],
description="Test",
- inputSchema={},
+ input_schema={"type": "object"},
_meta={
"server_name": server,
"namespaced_name": namespaced_name,
@@ -1166,21 +1148,21 @@ class TestMCPClientToolExecution:
[
pytest.param(
None, # No tool setup
- {"status": MCPServerStatus.CONNECTED, "session": AsyncMock()},
+ {"status": MCPServerStatus.CONNECTED, "client": AsyncMock()},
"Tool 'nonexistent_tool' not found",
id="tool_not_found",
),
pytest.param(
{"server_name": "test_server"},
- {"status": MCPServerStatus.DISCONNECTED, "session": None},
+ {"status": MCPServerStatus.DISCONNECTED, "client": None},
"Server 'test_server' is not connected",
id="server_not_connected",
),
pytest.param(
{"server_name": "test_server"},
- {"status": MCPServerStatus.CONNECTED, "session": None},
- "No active session for server 'test_server'",
- id="no_active_session",
+ {"status": MCPServerStatus.CONNECTED, "client": None},
+ "No active client for server 'test_server'",
+ id="no_active_client",
),
],
)
@@ -1196,7 +1178,7 @@ class TestMCPClientToolExecution:
mock_tool = Tool(
name="test_tool",
description="Test tool",
- inputSchema={},
+ input_schema={"type": "object"},
_meta={
"server_name": tool_setup["server_name"],
"namespaced_name": "mcp_test_server_test_tool",
@@ -1210,7 +1192,7 @@ class TestMCPClientToolExecution:
)
connection = MCPServerConnection(definition=server_def)
connection.status = connection_setup["status"]
- connection.session = connection_setup["session"]
+ connection.client = connection_setup["client"]
client.connections["test_server"] = connection
# Create params for the tool
@@ -1247,9 +1229,9 @@ class TestMCPClientToolExecution:
mock_tool = create_test_tool()
client.tool_registry["mcp_test_server_test_tool"] = mock_tool
- # Setup connection with mock session
+ # Setup connection with mock client
connection = create_test_server_connection(
- status=MCPServerStatus.CONNECTED, session=AsyncMock()
+ status=MCPServerStatus.CONNECTED, client=AsyncMock()
)
# Mock successful tool result
@@ -1258,7 +1240,7 @@ class TestMCPClientToolExecution:
TextContent(type="text", text="Tool executed successfully")
]
)
- connection.session.call_tool = AsyncMock(return_value=expected_result)
+ connection.client.call_tool = AsyncMock(return_value=expected_result)
client.connections["test_server"] = connection
# Create params and invoke tool
@@ -1272,8 +1254,8 @@ class TestMCPClientToolExecution:
text_contents = client.extract_text_content(result)
assert "Tool executed successfully" in text_contents[0]
- # Verify session was called correctly
- connection.session.call_tool.assert_called_once_with(
+ # Verify client was called correctly
+ connection.client.call_tool.assert_called_once_with(
"test_tool", {"arg1": "value1"}
)
@@ -1289,14 +1271,14 @@ class TestMCPClientToolExecution:
connection = create_test_server_connection(
timeout=0.1, # Very short timeout
status=MCPServerStatus.CONNECTED,
- session=AsyncMock(),
+ client=AsyncMock(),
)
- # Mock session to hang longer than timeout
+ # Mock client to hang longer than timeout
async def slow_call_tool(_name, _args):
await asyncio.sleep(1) # Longer than timeout
- connection.session.call_tool = AsyncMock(side_effect=slow_call_tool)
+ connection.client.call_tool = AsyncMock(side_effect=slow_call_tool)
client.connections["test_server"] = connection
# Create params and invoke tool
@@ -1346,7 +1328,7 @@ class TestMCPClientToolExecution:
# Create result
content = [TextContent(**item) for item in result_content]
- result = CallToolResult(isError=expected_is_error, content=content)
+ result = CallToolResult(is_error=expected_is_error, content=content)
# Test error detection
assert client.is_error_result(result) == expected_is_error
@@ -1360,6 +1342,53 @@ class TestMCPClientToolExecution:
):
assert text_contents[i] == expected_text
+ def test_convert_structured_tool_result(self):
+ from mcp.types import CallToolResult, TextContent
+
+ client = MCPClient()
+ result = CallToolResult(
+ content=[TextContent(type="text", text="fallback")],
+ structured_content={"rows": [{"value": 1}]},
+ )
+
+ assert client.convert_tool_result(result) == {"rows": [{"value": 1}]}
+
+ def test_convert_non_text_tool_result(self):
+ from mcp.types import CallToolResult, ImageContent
+
+ client = MCPClient()
+ result = CallToolResult(
+ content=[
+ ImageContent(
+ type="image", data="aW1hZ2U=", mime_type="image/png"
+ )
+ ]
+ )
+
+ assert client.convert_tool_result(result) == {
+ "content": [
+ {
+ "type": "image",
+ "data": "aW1hZ2U=",
+ "mimeType": "image/png",
+ }
+ ]
+ }
+
+ def test_format_structured_tool_error(self):
+ from mcp.types import CallToolResult
+
+ client = MCPClient()
+ result = CallToolResult(
+ is_error=True,
+ content=[],
+ structured_content={"reason": "denied", "code": 403},
+ )
+
+ assert client.format_tool_error(result) == (
+ '{"code": 403, "reason": "denied"}'
+ )
+
@pytest.mark.skipif(
not DependencyManager.mcp.has(), reason="MCP SDK not available"
@@ -1372,25 +1401,25 @@ class TestMCPClientConnectionManagement:
client = MCPClient()
from mcp.types import ListToolsResult, Tool
- # Create mock connection with session
- mock_session = AsyncMock()
- connection = create_test_server_connection(session=mock_session)
+ # Create mock connection with a client
+ mock_client = AsyncMock()
+ connection = create_test_server_connection(client=mock_client)
# Mock tools response
mock_tools = [
Tool(
name="tool1",
description="First tool",
- inputSchema={"type": "object"},
+ input_schema={"type": "object"},
),
Tool(
name="tool2",
description="Second tool",
- inputSchema={"type": "object"},
+ input_schema={"type": "object"},
),
]
mock_response = ListToolsResult(tools=mock_tools)
- mock_session.list_tools = AsyncMock(return_value=mock_response)
+ mock_client.list_tools = AsyncMock(return_value=mock_response)
# Test tool discovery
await client._discover_tools(connection)
@@ -1400,48 +1429,96 @@ class TestMCPClientConnectionManagement:
assert "mcp_test_server_tool1" in client.tool_registry
assert "mcp_test_server_tool2" in client.tool_registry
- # Verify session was called
- mock_session.list_tools.assert_called_once()
+ # Verify client was called
+ mock_client.list_tools.assert_called_once_with(cursor=None)
- async def test_discover_tools_no_session(self):
- """Test tool discovery with no active session."""
- client = MCPClient()
+ async def test_discover_tools_follows_pagination(self):
+ from mcp.types import ListToolsResult, Tool
- # Create connection without session
- connection = create_test_server_connection(session=None)
+ client = MCPClient()
+ mock_client = AsyncMock()
+ connection = create_test_server_connection(client=mock_client)
+ mock_client.list_tools.side_effect = [
+ ListToolsResult(
+ tools=[
+ Tool(
+ name="tool1",
+ description="First tool",
+ input_schema={"type": "object"},
+ )
+ ],
+ next_cursor="page-2",
+ ),
+ ListToolsResult(
+ tools=[
+ Tool(
+ name="tool2",
+ description="Second tool",
+ input_schema={"type": "object"},
+ )
+ ]
+ ),
+ ]
- # Test tool discovery (should handle gracefully)
await client._discover_tools(connection)
+ assert set(client.tool_registry) == {
+ "mcp_test_server_tool1",
+ "mcp_test_server_tool2",
+ }
+ assert mock_client.list_tools.await_args_list == [
+ (((), {"cursor": None})),
+ (((), {"cursor": "page-2"})),
+ ]
+
+ async def test_discover_tools_is_atomic_on_failure(self):
+ client = MCPClient()
+ existing_tool = create_test_tool(name="existing")
+ connection = create_test_server_connection(client=AsyncMock())
+ connection.tools = [existing_tool]
+ client.connections["test_server"] = connection
+ client.tool_registry["mcp_test_server_existing"] = existing_tool
+ connection.client.list_tools.side_effect = RuntimeError("failed")
+
+ with pytest.raises(RuntimeError, match="failed"):
+ await client._discover_tools(connection)
+
+ assert connection.tools == [existing_tool]
+ assert set(client.tool_registry) == {"mcp_test_server_existing"}
+
+ async def test_discover_tools_no_client(self):
+ """Test tool discovery with no active client."""
+ client = MCPClient()
+
+ connection = create_test_server_connection(client=None)
+
+ with pytest.raises(RuntimeError, match="No active client"):
+ await client._discover_tools(connection)
+
# Verify no tools were added
assert len(connection.tools) == 0
assert len(client.tool_registry) == 0
- @patch("mcp.ClientSession")
- @patch("mcp.client.stdio.stdio_client")
+ @patch("mcp.Client")
async def test_connect_to_server_success(
self,
- mock_stdio_client,
- mock_session_class,
- mock_stdio_setup,
- mock_session_setup,
+ mock_client_class,
):
"""Test successful server connection with complete flow."""
- # Setup stdio and session mocks using fixtures
- mock_read, mock_write, mock_stdio_context = mock_stdio_setup()
- mock_stdio_client.return_value = mock_stdio_context
-
- _mock_session, mock_session_context = mock_session_setup()
- mock_session_class.return_value = mock_session_context
+ mock_connection_client = AsyncMock()
+ mock_connection_client.__aenter__ = AsyncMock(
+ return_value=mock_connection_client
+ )
+ mock_connection_client.__aexit__ = AsyncMock(return_value=None)
+ mock_connection_client.list_tools.return_value.tools = []
+ mock_connection_client.list_tools.return_value.next_cursor = None
+ mock_client_class.return_value = mock_connection_client
+ transport = AsyncMock()
- # Mock AsyncExitStack
with patch(
- "marimo._server.ai.mcp.StdioTransportConnector.connect"
- ) as mock_connector_connect:
- # Mock connector.connect to return the expected streams
- mock_connector_connect.return_value = (mock_read, mock_write)
-
- # Create client with test config
+ "marimo._server.ai.mcp.StdioTransportConnector.create",
+ return_value=transport,
+ ):
config = MCPConfig(
mcpServers={
"test_server": MCPServerStdioConfig(
@@ -1461,6 +1538,102 @@ class TestMCPClientConnectionManagement:
client.connections["test_server"].status
== MCPServerStatus.CONNECTED
)
+ mock_client_class.assert_called_once_with(
+ transport,
+ mode="auto",
+ read_timeout_seconds=30.0,
+ )
+ await client.disconnect_from_server("test_server")
+
+ @patch("mcp.Client")
+ async def test_connect_to_server_fails_when_discovery_fails(
+ self, mock_client_class
+ ):
+ mock_connection_client = AsyncMock()
+ mock_connection_client.__aenter__.return_value = mock_connection_client
+ mock_connection_client.list_tools.side_effect = RuntimeError(
+ "discovery failed"
+ )
+ mock_client_class.return_value = mock_connection_client
+ client = MCPClient()
+ client.servers["test_server"] = create_test_server_definition()
+
+ with patch(
+ "marimo._server.ai.mcp.StdioTransportConnector.create",
+ return_value=AsyncMock(),
+ ):
+ result = await client.connect_to_server("test_server")
+
+ assert result is False
+ connection = client.connections["test_server"]
+ assert connection.status == MCPServerStatus.ERROR
+ assert connection.tools == []
+ assert connection.error_message is not None
+ assert "discovery failed" in connection.error_message
+
+ @patch("mcp.Client")
+ async def test_connect_to_server_cancels_timed_out_lifecycle(
+ self, mock_client_class
+ ):
+ async def wait_forever():
+ await asyncio.Event().wait()
+
+ mock_connection_client = AsyncMock()
+ mock_connection_client.__aenter__.side_effect = wait_forever
+ mock_client_class.return_value = mock_connection_client
+ client = MCPClient()
+ client.servers["test_server"] = create_test_server_definition(
+ timeout=0.01
+ )
+
+ with patch(
+ "marimo._server.ai.mcp.StdioTransportConnector.create",
+ return_value=AsyncMock(),
+ ):
+ result = await client.connect_to_server("test_server")
+
+ assert result is False
+ connection = client.connections["test_server"]
+ assert connection.status == MCPServerStatus.ERROR
+ assert connection.connection_task is not None
+ assert connection.connection_task.cancelled()
+ assert await client.disconnect_from_server("test_server") is True
+
+ @patch("mcp.Client")
+ async def test_cancelling_connection_closes_lifecycle(
+ self, mock_client_class
+ ):
+ discovery_started = asyncio.Event()
+
+ async def wait_forever(*, cursor):
+ assert cursor is None
+ discovery_started.set()
+ await asyncio.Event().wait()
+
+ mock_connection_client = AsyncMock()
+ mock_connection_client.__aenter__.return_value = mock_connection_client
+ mock_connection_client.list_tools.side_effect = wait_forever
+ mock_client_class.return_value = mock_connection_client
+ client = MCPClient()
+ client.servers["test_server"] = create_test_server_definition()
+
+ with patch(
+ "marimo._server.ai.mcp.StdioTransportConnector.create",
+ return_value=AsyncMock(),
+ ):
+ connect_task = asyncio.create_task(
+ client.connect_to_server("test_server")
+ )
+ await asyncio.wait_for(discovery_started.wait(), timeout=1)
+ connect_task.cancel()
+ with pytest.raises(asyncio.CancelledError):
+ await connect_task
+
+ connection = client.connections["test_server"]
+ assert connection.status == MCPServerStatus.DISCONNECTED
+ assert connection.connection_task is not None
+ assert connection.connection_task.cancelled()
+ mock_connection_client.__aexit__.assert_awaited_once()
@pytest.mark.parametrize(
("server_exists", "already_connected", "expected_result"),
@@ -1494,48 +1667,28 @@ class TestMCPClientConnectionManagement:
result = await client.connect_to_server("test_server")
assert result == expected_result
- @pytest.mark.xfail(reason="Flaky test")
- @patch("mcp.ClientSession")
- async def test_connect_to_all_servers_mixed_results(
- self, mock_session_class
- ):
+ async def test_connect_to_all_servers_mixed_results(self):
"""Test connecting to multiple servers with mixed success/failure."""
- # Setup session mock for successful connections
- mock_session = AsyncMock()
- mock_session.initialize = AsyncMock()
- mock_session.list_tools = AsyncMock()
- mock_session.list_tools.return_value.tools = []
-
- mock_session_context = AsyncMock()
- mock_session_context.__aenter__ = AsyncMock(return_value=mock_session)
- mock_session_context.__aexit__ = AsyncMock(return_value=None)
- mock_session_class.return_value = mock_session_context
-
- with patch(
- "marimo._server.ai.mcp.StdioTransportConnector.connect"
- ) as mock_connector_connect:
- # Simulate success for server1, failure for server2
- mock_connector_connect.side_effect = [
- (AsyncMock(), AsyncMock()), # server1 success
- Exception("Connection failed"), # server2 failure
- ]
-
- config = MCPConfig(
- mcpServers={
- "server1": MCPServerStdioConfig(
- command="python", args=["test1.py"]
- ),
- "server2": MCPServerStdioConfig(
- command="python", args=["test2.py"]
- ),
- }
- )
- client = MCPClient()
- await client.configure(config)
+ config = MCPConfig(
+ mcpServers={
+ "server1": MCPServerStdioConfig(
+ command="python", args=["test1.py"]
+ ),
+ "server2": MCPServerStdioConfig(
+ command="python", args=["test2.py"]
+ ),
+ }
+ )
+ client = MCPClient()
+ client.servers = client._parse_config(config)
+ with patch.object(
+ client,
+ "connect_to_server",
+ new=AsyncMock(side_effect=[True, False]),
+ ):
results = await client.connect_to_all_servers()
- # Verify mixed results
assert len(results) == 2
assert results["server1"] is True
assert results["server2"] is False
@@ -1555,15 +1708,13 @@ class TestMCPClientDisconnectionManagement:
connection = create_test_server_connection(
name="test_server",
status=MCPServerStatus.CONNECTED,
- session=AsyncMock(),
+ client=AsyncMock(),
)
- # Create mock task that simulates running connection task
- mock_task = AsyncMock()
- mock_task.done.return_value = False # Task is still running
+ connection_task = create_connection_task()
disconnect_event = asyncio.Event()
- connection.connection_task = mock_task
+ connection.connection_task = connection_task
connection.disconnect_event = disconnect_event
client.connections["test_server"] = connection
@@ -1573,7 +1724,6 @@ class TestMCPClientDisconnectionManagement:
# Verify successful disconnection
assert result is True
assert disconnect_event.is_set() # Event was signaled
- # Note: mock_task should be awaited since done() returns False
async def test_disconnect_from_server_already_disconnected(self):
"""Test disconnection from server that's already disconnected."""
@@ -1626,7 +1776,7 @@ class TestMCPClientDisconnectionManagement:
connection = create_test_server_connection(
name="test_server",
status=MCPServerStatus.CONNECTED,
- session=AsyncMock(),
+ client=AsyncMock(),
)
# Add tools to verify they get cleaned up
@@ -1645,9 +1795,8 @@ class TestMCPClientDisconnectionManagement:
health_task = AsyncMock()
client.health_check_tasks["test_server"] = health_task
- # Setup connection task
- connection.connection_task = AsyncMock()
- connection.connection_task.done.return_value = True # Already done
+ connection_task = create_connection_task()
+ connection.connection_task = connection_task
connection.disconnect_event = asyncio.Event()
client.connections["test_server"] = connection
@@ -1695,16 +1844,14 @@ class TestMCPClientDisconnectionManagement:
name=setup["name"], status=MCPServerStatus.CONNECTED
)
- # Setup task behavior based on should_succeed
- if setup["should_succeed"]:
- mock_task = AsyncMock()
- mock_task.done.return_value = False
- else:
- mock_task = AsyncMock()
- mock_task.done.return_value = False
- mock_task.side_effect = Exception("Simulated failure")
+ error = (
+ None
+ if setup["should_succeed"]
+ else Exception("Simulated failure")
+ )
+ connection_task = create_connection_task(error)
- connection.connection_task = mock_task
+ connection.connection_task = connection_task
connection.disconnect_event = asyncio.Event()
client.connections[setup["name"]] = connection
@@ -1728,8 +1875,8 @@ class TestMCPClientDisconnectionManagement:
connection = create_test_server_connection(
name=name, status=MCPServerStatus.CONNECTED
)
- connection.connection_task = AsyncMock()
- connection.connection_task.done.return_value = True
+ connection_task = create_connection_task()
+ connection.connection_task = connection_task
connection.disconnect_event = asyncio.Event()
client.connections[name] = connection
@@ -1794,41 +1941,43 @@ class TestMCPClientHealthMonitoring:
"""Test successful health check."""
client = MCPClient()
- # Create connection with mock session
+ # Create connection with mock client
server_def = MCPServerDefinitionFactory.from_config(
"test", MCPServerStdioConfig(command="test", args=[])
)
connection = MCPServerConnection(definition=server_def)
- connection.session = AsyncMock()
- connection.session.send_ping = AsyncMock()
+ connection.client = AsyncMock()
+ connection.client.list_tools = AsyncMock()
client.connections["test"] = connection
result = await client._perform_health_check("test")
assert result is True
- connection.session.send_ping.assert_called_once()
+ connection.client.list_tools.assert_called_once_with(
+ cache_mode="refresh"
+ )
# Note: last_health_check is updated by the caller (_monitor_server_health), not _perform_health_check
assert connection.last_health_check == 0 # Should remain unchanged
@pytest.mark.parametrize(
- ("session_setup", "ping_behavior", "expected_result"),
+ ("client_setup", "discovery_behavior", "expected_result"),
[
pytest.param(
- None, # No session
+ None, # No client
None,
False,
- id="no_session",
+ id="no_client",
),
pytest.param(
AsyncMock(), # Valid session
- Exception("Ping failed"), # Exception during ping
+ Exception("Discovery failed"),
False,
- id="ping_exception",
+ id="discovery_exception",
),
],
)
async def test_perform_health_check_failure_cases(
- self, session_setup, ping_behavior, expected_result
+ self, client_setup, discovery_behavior, expected_result
):
"""Test health check failure scenarios."""
client = MCPClient()
@@ -1838,10 +1987,12 @@ class TestMCPClientHealthMonitoring:
"test", MCPServerStdioConfig(command="test", args=[])
)
connection = MCPServerConnection(definition=server_def)
- connection.session = session_setup
+ connection.client = client_setup
- if session_setup and ping_behavior:
- connection.session.send_ping = AsyncMock(side_effect=ping_behavior)
+ if client_setup and discovery_behavior:
+ connection.client.list_tools = AsyncMock(
+ side_effect=discovery_behavior
+ )
client.connections["test"] = connection
@@ -1856,18 +2007,19 @@ class TestMCPClientHealthMonitoring:
client = MCPClient()
client.health_check_timeout = 0.1 # Very short timeout
- # Create connection with session that hangs
+ # Create connection with a client that hangs
server_def = MCPServerDefinitionFactory.from_config(
"test", MCPServerStdioConfig(command="test", args=[])
)
connection = MCPServerConnection(definition=server_def)
- connection.session = AsyncMock()
+ connection.client = AsyncMock()
# Create a coroutine that sleeps longer than timeout
- async def slow_ping():
+ async def slow_discovery(*, cache_mode):
+ assert cache_mode == "refresh"
await asyncio.sleep(1)
- connection.session.send_ping = AsyncMock(side_effect=slow_ping)
+ connection.client.list_tools = AsyncMock(side_effect=slow_discovery)
client.connections["test"] = connection
result = await client._perform_health_check("test")
@@ -1876,6 +2028,49 @@ class TestMCPClientHealthMonitoring:
# Note: _perform_health_check doesn't update connection status directly
# Status updates happen in the calling code (_monitor_server_health)
+ async def test_health_monitor_closes_after_failure_threshold(self):
+ client = MCPClient()
+ client.health_check_interval = 0
+ client.health_check_failure_threshold = 3
+ connection = create_test_server_connection(
+ name="test", status=MCPServerStatus.CONNECTED, client=AsyncMock()
+ )
+ connection.disconnect_event = asyncio.Event()
+ client.connections["test"] = connection
+ client._perform_health_check = AsyncMock(return_value=False)
+
+ task = asyncio.create_task(client._monitor_server_health("test"))
+ client.health_check_tasks["test"] = task
+ await asyncio.wait_for(task, timeout=1)
+
+ assert client._perform_health_check.await_count == 3
+ assert connection.status == MCPServerStatus.ERROR
+ assert connection.disconnect_event.is_set()
+ assert "test" not in client.health_check_tasks
+
+ async def test_health_monitor_exits_when_server_is_not_connected(self):
+ client = MCPClient()
+ connection = create_test_server_connection(
+ name="test", status=MCPServerStatus.DISCONNECTED
+ )
+ client.connections["test"] = connection
+ client._perform_health_check = AsyncMock()
+
+ await client._monitor_server_health("test")
+
+ client._perform_health_check.assert_not_awaited()
+
+ async def test_cancel_health_monitoring_removes_task_once(self):
+ client = MCPClient()
+ client.health_check_interval = 60
+ task = asyncio.create_task(client._monitor_server_health("test"))
+ client.health_check_tasks["test"] = task
+
+ await client._cancel_health_monitoring("test")
+
+ assert task.done()
+ assert "test" not in client.health_check_tasks
+
class TestMCPServerConnection:
"""Test cases for MCPServerConnection class."""
@@ -1896,7 +2091,7 @@ class TestMCPServerConnection:
assert connection.definition.config.get("args") == ["test.py"]
assert connection.definition.config.get("env") == {"TEST": "value"}
assert connection.status == MCPServerStatus.DISCONNECTED
- assert connection.session is None
+ assert connection.client is None
assert len(connection.tools) == 0
assert connection.last_health_check == 0
assert connection.error_message is None
@@ -1923,7 +2118,7 @@ class TestMCPUtilities:
# Reset global client for this test
import marimo._server.ai.mcp.client as client_module
- client_module._MCP_CLIENT = None
+ client_module._mcp_client = None
custom_config = MCPConfig(
mcpServers={
diff --git a/tests/_server/ai/tools/test_tool_manager.py b/tests/_server/ai/tools/test_tool_manager.py
index 150e4e7b87..fa4e5e7bef 100644
--- a/tests/_server/ai/tools/test_tool_manager.py
+++ b/tests/_server/ai/tools/test_tool_manager.py
@@ -1,11 +1,18 @@
from __future__ import annotations
+from unittest.mock import AsyncMock, patch
+
import pytest
from starlette.applications import Starlette
from marimo._ai._tools.tools_registry import SUPPORTED_BACKEND_AND_MCP_TOOLS
+from marimo._dependencies.dependencies import DependencyManager
+from marimo._server.ai.mcp.client import MCPClient
from marimo._server.ai.tools.tool_manager import ToolManager
-from marimo._server.ai.tools.types import ToolCallResult
+from marimo._server.ai.tools.types import (
+ ToolCallResult,
+ ToolDefinition,
+)
from tests._server.mocks import get_starlette_server_state_init
@@ -66,6 +73,45 @@ async def test_invoke_tool_invalid_arguments(manager: ToolManager):
assert "Invalid arguments" in result.error or result.error is None
+ not DependencyManager.mcp.has(), reason="MCP SDK not available"
+)
+async def test_invoke_mcp_tool_preserves_structured_error(
+ manager: ToolManager,
+):
+ from mcp.types import CallToolResult
+
+ tool = ToolDefinition(
+ name="mcp_server_tool",
+ description="Tool",
+ parameters={"type": "object"},
+ source="mcp",
+ mode=["ask"],
+ )
+ call_result = CallToolResult(
+ is_error=True,
+ content=[],
+ structured_content={"reason": "denied", "code": 403},
+ )
+
+ with (
+ patch.object(manager, "_get_tool", return_value=tool),
+ patch.object(
+ manager,
+ "_invoke_mcp_tool",
+ new=AsyncMock(return_value=call_result),
+ ),
+ patch(
+ "marimo._server.ai.tools.tool_manager.get_mcp_client",
+ return_value=MCPClient(),
+ ),
+ ):
+ result = await manager.invoke_tool(tool.name, {})
+
+ assert result.result is None
+ assert result.error == '{"code": 403, "reason": "denied"}'
+
+
def test_validate_backend_tool_arguments(manager: ToolManager):
"""Test argument validation for backend tools."""
diff --git a/tests/snapshots/optional-dependencies-mcp.txt b/tests/snapshots/optional-dependencies-mcp.txt
index 587c67536f..74b412ca6b 100644
--- a/tests/snapshots/optional-dependencies-mcp.txt
+++ b/tests/snapshots/optional-dependencies-mcp.txt
@@ -1,2 +1,2 @@
-mcp>=1.0.0,<2
-pydantic>2
\ No newline at end of file
+httpx2>=2.5.0,<3
+mcp>=2.0.0,<3
\ No newline at end of file