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.
Python artificial-intelligencedagdata-sciencedata-visualizationdataflowdeveloper-toolsmachine-learningnotebookspipelinepythonreactivesqlweb-app
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.tsnew file mode 100644index 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.tsxindex 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.pyindex 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.pyindex 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 DependencyManagerfrom marimo._loggers import marimo_logger+from marimo._mcp.dependencies import require_mcp_dependenciesfrom marimo._server.scratchpad import (EXECUTION_TIMEOUT,ScratchCellListener,@@ -46,13 +46,9 @@ def setup_code_mcp_server(app: Starlette application instance for accessing marimo stateallow_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 MCPServerfrom starlette.middleware.base import BaseHTTPMiddlewarefrom starlette.responses import JSONResponsefrom 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.pynew file mode 100644index 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.pyindex 7125e9fa28..4f8176be8c 100644--- a/marimo/_mcp/server/main.py+++ b/marimo/_mcp/server/main.py@@ -12,9 +12,8 @@ from typing import TYPE_CHECKINGfrom marimo._ai._tools.base import ToolContextfrom marimo._ai._tools.tools_registry import SUPPORTED_BACKEND_AND_MCP_TOOLS-from marimo._cli.errors import MarimoCLIMissingDependencyError-from marimo._dependencies.dependencies import DependencyManagerfrom marimo._loggers import marimo_logger+from marimo._mcp.dependencies import require_mcp_dependenciesLOGGER = marimo_logger()@@ -31,13 +30,9 @@ def setup_mcp_server(app: Starlette, allow_remote: bool = False) -> None:app: Starlette application instance for accessing marimo stateallow_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 MCPServerfrom starlette.middleware.base import BaseHTTPMiddlewarefrom starlette.responses import JSONResponsefrom 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 scopeclass RequiresEditMiddleware(BaseHTTPMiddleware):diff --git a/marimo/_server/ai/mcp/client.py b/marimo/_server/ai/mcp/client.pyindex d36c39c1d1..c14951a3cf 100644--- a/marimo/_server/ai/mcp/client.py+++ b/marimo/_server/ai/mcp/client.py@@ -3,7 +3,6 @@ from __future__ import annotationsimport asyncioimport time-from contextlib import AsyncExitStackfrom dataclasses import dataclass, fieldfrom enum import Enumfrom typing import TYPE_CHECKING@@ -23,13 +22,9 @@ from marimo._server.ai.mcp.types import MCPToolArgsfrom marimo._utils.asyncio_utils import cancel_and_wait, supervised_taskif 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 MCPConnectionClientfrom 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 = Nonestatus: MCPServerStatus = MCPServerStatus.DISCONNECTEDtools: list[Tool] = field(default_factory=list)last_health_check: float = 0error_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 = Nonedisconnect_event: asyncio.Event | None = Noneconnection_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 # secondsself.health_check_timeout: float = (5.0 # seconds - shorter timeout for health checks)+ self.health_check_failure_threshold: int = 3async def configure(self, config: MCPConfig) -> None:"""Configure the MCP client with the given configuration.@@ -120,11 +129,11 @@ class MCPClient:returnLOGGER.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_serversasync 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 Clientconnection = self.connections.get(server_name)if not connection:@@ -229,38 +238,27 @@ class MCPClient:server_def = connection.definitiontry:- # 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_clientLOGGER.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 monitoringawait 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 stateself._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 = Noneasync 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 errorcurrent_status = self.get_server_status(server_name)return current_status == MCPServerStatus.CONNECTED+ except asyncio.CancelledError:+ await cancel_and_wait(connection_task)+ raiseexcept 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 Falseexcept 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 includeReturns:- 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-handlingfrom mcp.types import CallToolResult, TextContentreturn 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 Trueasync 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 handlingtimeout = connection.definition.timeoutresult = 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 resultexcept 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 = 0try:- 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 checkhealth_check_passed = await self._perform_health_check(@@ -620,6 +681,7 @@ class MCPClient:)if health_check_passed:+ consecutive_failures = 0# Handle successful health checkLOGGER.debug(f"Health check passed for {server_name}")connection = self.connections.get(server_name)@@ -627,15 +689,24 @@ class MCPClient:# Update last health check timeconnection.last_health_check = time.time()else:- # Handle failed health check+ consecutive_failures += 1LOGGER.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 stateconnection = 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 failureexcept 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 Falsetry:- 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/pingawait 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 totools: List of raw MCP tools to add"""- from mcp.types import Tool # type: ignore[import-not-found]-server_name = connection.definition.namefor 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 registryconnection.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 completeawait 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():+ raiseLOGGER.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 = Nonedef 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_clientdiff --git a/marimo/_server/ai/mcp/transport.py b/marimo/_server/ai/mcp/transport.pyindex fca7ec9b38..f3773c7fbb 100644--- a/marimo/_server/ai/mcp/transport.py+++ b/marimo/_server/ai/mcp/transport.py@@ -3,18 +3,37 @@ from __future__ import annotationsimport osfrom abc import ABC, abstractmethod+from contextlib import asynccontextmanagerfrom enum import Enum-from typing import TYPE_CHECKING, cast+from typing import TYPE_CHECKING++from marimo._utils.typing import overrideif TYPE_CHECKING:- from contextlib import AsyncExitStack+ from collections.abc import AsyncGenerator+ from typing import TypeGuardfrom 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 configclass 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 managementReturns:- 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 StdioServerParametersfrom 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 processenv = 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.pyindex 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] | Nonediff --git a/marimo/_server/ai/tools/tool_manager.py b/marimo/_server/ai/tools/tool_manager.pyindex 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.tomlindex 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.pyindex 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 MagicMockimport pytest+from marimo._dependencies.dependencies import DependencyManagerfrom marimo._mcp.code_server.lifespan import code_mcp_server_lifespanpytest.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.pyindex 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 DependencyManagerfrom marimo._mcp.server.lifespan import mcp_server_lifespanpytest.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.pyindex 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 = clientreturn 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 mocksmock_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 connectionconnector = 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_readassert 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 clientconnection = 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 timeoutstatus=MCPServerStatus.CONNECTED,- session=AsyncMock(),+ client=AsyncMock(),)- # Mock session to hang longer than timeout+ # Mock client to hang longer than timeoutasync 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 resultcontent = [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 detectionassert 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 responsemock_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 discoveryawait client._discover_tools(connection)@@ -1400,48 +1429,96 @@ class TestMCPClientConnectionManagement:assert "mcp_test_server_tool1" in client.tool_registryassert "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 addedassert len(connection.tools) == 0assert 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 AsyncExitStackwith 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 resultsassert len(results) == 2assert results["server1"] is Trueassert 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_taskconnection.disconnect_event = disconnect_eventclient.connections["test_server"] = connection@@ -1573,7 +1724,6 @@ class TestMCPClientDisconnectionManagement:# Verify successful disconnectionassert result is Trueassert disconnect_event.is_set() # Event was signaled- # Note: mock_task should be awaited since done() returns Falseasync 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_taskconnection.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_taskconnection.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_taskconnection.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 clientserver_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"] = connectionresult = 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_checkassert 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 clientNone,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 hangsserver_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"] = connectionresult = 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 Noneassert len(connection.tools) == 0assert connection.last_health_check == 0assert connection.error_message is None@@ -1923,7 +2118,7 @@ class TestMCPUtilities:# Reset global client for this testimport marimo._server.ai.mcp.client as client_module- client_module._MCP_CLIENT = None+ client_module._mcp_client = Nonecustom_config = MCPConfig(mcpServers={diff --git a/tests/_server/ai/tools/test_tool_manager.py b/tests/_server/ai/tools/test_tool_manager.pyindex 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 pytestfrom starlette.applications import Starlettefrom marimo._ai._tools.tools_registry import SUPPORTED_BACKEND_AND_MCP_TOOLS+from marimo._dependencies.dependencies import DependencyManager+from marimo._server.ai.mcp.client import MCPClientfrom 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.txtindex 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