Skip to content

Your lightweight open-source personal agent.

89.2 KB
Raw Blame
from __future__ import annotations

import asyncio
import json
import sys
from contextlib import asynccontextmanager
from pathlib import Path
from types import ModuleType, SimpleNamespace
from unittest.mock import AsyncMock
from urllib.parse import unquote
from urllib.request import getproxies_environment

import httpx
import pytest

import nanobot.agent.tools.mcp as mcp_mod
from nanobot.agent.tools.context import RequestContext, request_context
from nanobot.agent.tools.mcp import (
    MCPPromptWrapper,
    MCPProvider,
    MCPResourceWrapper,
    MCPToolWrapper,
    _normalize_windows_stdio_command,
    _sanitize_mcp_tool_name,
    _sanitize_name,
    connect_mcp_servers,
)
from nanobot.agent.tools.registry import ToolRegistry, is_tool_error_result
from nanobot.config.network import NetworkConfig
from nanobot.config.schema import MCPServerConfig

_PROXY_ENV_VARS = ("HTTP_PROXY", "HTTPS_PROXY", "ALL_PROXY", "http_proxy", "https_proxy", "all_proxy")


def test_type_checking_only_mcp_annotations_are_deferred() -> None:
    assert mcp_mod._MCPWrapperBase.__annotations__["_session"] == "ClientSession"
    assert MCPToolWrapper.__init__.__annotations__["session"] == "ClientSession"
    assert MCPResourceWrapper.__init__.__annotations__["resource_def"] == "Resource"
    assert MCPPromptWrapper.__init__.__annotations__["prompt_def"] == "Prompt"
    assert connect_mcp_servers.__annotations__["mcp_servers"] == "dict[str, MCPServerConfig]"


class _FakeTextContent:
    def __init__(self, text: str) -> None:
        self.text = text


class _FakeTextResourceContents:
    def __init__(self, text: str) -> None:
        self.text = text


class _FakeBlobResourceContents:
    def __init__(self, blob: bytes) -> None:
        self.blob = blob


class _FakeImageContent:
    def __init__(self, data: str, mime_type: str = "image/png") -> None:
        self.data = data
        self.mimeType = mime_type


@pytest.fixture
def fake_mcp_runtime() -> dict[str, object | None]:
    return {"session": None}


@pytest.fixture(autouse=True)
def _clear_proxy_env(monkeypatch: pytest.MonkeyPatch) -> None:
    for name in (*_PROXY_ENV_VARS, "NO_PROXY", "no_proxy"):
        monkeypatch.delenv(name, raising=False)
    # getproxies() falls back to OS-level proxy settings (e.g. the Windows
    # registry) when no environment variables are set; keep tests hermetic.
    monkeypatch.setattr("nanobot.security.network.getproxies", getproxies_environment)


@pytest.fixture(autouse=True)
def _fake_mcp_module(
    monkeypatch: pytest.MonkeyPatch, fake_mcp_runtime: dict[str, object | None]
) -> None:
    mod = ModuleType("mcp")
    mod.types = SimpleNamespace(
        TextContent=_FakeTextContent,
        TextResourceContents=_FakeTextResourceContents,
        BlobResourceContents=_FakeBlobResourceContents,
        ImageContent=_FakeImageContent,
        PaginatedRequestParams=SimpleNamespace,
    )

    class _FakeStdioServerParameters:
        def __init__(
            self,
            command: str,
            args: list[str],
            env: dict | None = None,
            cwd: str | None = None,
        ) -> None:
            self.command = command
            self.args = args
            self.env = env
            self.cwd = cwd

    class _FakeClientSession:
        def __init__(self, _read: object, _write: object) -> None:
            self._session = fake_mcp_runtime["session"]

        async def __aenter__(self) -> object:
            return self._session

        async def __aexit__(self, exc_type, exc, tb) -> bool:
            return False

    @asynccontextmanager
    async def _fake_stdio_client(_params: object):
        yield object(), object()

    @asynccontextmanager
    async def _fake_sse_client(_url: str, httpx_client_factory=None):
        yield object(), object()

    @asynccontextmanager
    async def _fake_streamable_http_client(_url: str, http_client=None):
        yield object(), object(), object()

    mod.ClientSession = _FakeClientSession
    mod.StdioServerParameters = _FakeStdioServerParameters
    monkeypatch.setitem(sys.modules, "mcp", mod)

    client_mod = ModuleType("mcp.client")
    stdio_mod = ModuleType("mcp.client.stdio")
    stdio_mod.stdio_client = _fake_stdio_client
    sse_mod = ModuleType("mcp.client.sse")
    sse_mod.sse_client = _fake_sse_client
    streamable_http_mod = ModuleType("mcp.client.streamable_http")
    streamable_http_mod.streamable_http_client = _fake_streamable_http_client

    monkeypatch.setitem(sys.modules, "mcp.client", client_mod)
    monkeypatch.setitem(sys.modules, "mcp.client.stdio", stdio_mod)
    monkeypatch.setitem(sys.modules, "mcp.client.sse", sse_mod)
    monkeypatch.setitem(sys.modules, "mcp.client.streamable_http", streamable_http_mod)

    shared_mod = ModuleType("mcp.shared")
    exc_mod = ModuleType("mcp.shared.exceptions")

    class _FakeMcpError(Exception):
        def __init__(self, code: int = -1, message: str = "error"):
            self.error = SimpleNamespace(code=code, message=message)
            super().__init__(message)

    exc_mod.McpError = _FakeMcpError
    monkeypatch.setitem(sys.modules, "mcp.shared", shared_mod)
    monkeypatch.setitem(sys.modules, "mcp.shared.exceptions", exc_mod)


def _make_wrapper(session: object, *, timeout: float = 0.1) -> MCPToolWrapper:
    tool_def = SimpleNamespace(
        name="demo",
        description="demo tool",
        inputSchema={"type": "object", "properties": {}},
    )
    return MCPToolWrapper(session, "test", tool_def, tool_timeout=timeout)


@pytest.mark.asyncio
async def test_mcp_provider_connect_propagates_external_cancellation(monkeypatch) -> None:
    started = asyncio.Event()

    async def connect_mcp_servers(
        _servers: dict, _registry: ToolRegistry, *, network
    ) -> dict:
        started.set()
        await asyncio.sleep(60)
        return {}

    provider = MCPProvider(
        {"test": MCPServerConfig(command="fake")},
        ToolRegistry(),
    )
    monkeypatch.setattr(mcp_mod, "connect_mcp_servers", connect_mcp_servers)

    task = asyncio.create_task(provider.connect())
    await asyncio.wait_for(started.wait(), timeout=1.0)
    task.cancel()

    with pytest.raises(asyncio.CancelledError):
        await task

    assert provider.connected_server_names == set()
    assert provider.runtime_status() == {"test": "failed"}


@pytest.mark.asyncio
async def test_saved_oauth_http_403_projects_failed_runtime_without_details(
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    class OAuthAuth(httpx.Auth):
        def auth_flow(self, request: httpx.Request):
            request.headers["Authorization"] = "Bearer saved-oauth-secret"
            yield request

    class AuthorizationRequiredError(RuntimeError):
        pass

    async def create_auth(_name: str, _url: str, _handlers=None) -> httpx.Auth:
        return OAuthAuth()

    @asynccontextmanager
    async def rejected_streamable_http(url: str, http_client=None):
        request = httpx.Request("POST", f"{url}?access_token=saved-oauth-secret")
        response = httpx.Response(403, request=request)
        raise httpx.HTTPStatusError(
            "403 Forbidden for saved-oauth-secret",
            request=request,
            response=response,
        )
        yield object(), object(), object()

    async def reachable(_url: str, *, proxy: str | None = None) -> bool:
        return True

    oauth_mod = ModuleType("nanobot.agent.tools.mcp_oauth")
    oauth_mod.MCPAuthorizationRequiredError = AuthorizationRequiredError  # type: ignore[attr-defined]
    oauth_mod.create_mcp_oauth_auth = create_auth  # type: ignore[attr-defined]
    oauth_mod.mcp_oauth_has_credentials = lambda _name, _url: True  # type: ignore[attr-defined]
    monkeypatch.setitem(sys.modules, "nanobot.agent.tools.mcp_oauth", oauth_mod)
    monkeypatch.setattr(mcp_mod, "validate_url_target", lambda _url: (True, ""))
    monkeypatch.setattr(mcp_mod, "_probe_http_url", reachable)
    monkeypatch.setattr(
        sys.modules["mcp.client.streamable_http"],
        "streamable_http_client",
        rejected_streamable_http,
    )

    provider = MCPProvider(
        {
            "xmind": MCPServerConfig(
            type="streamableHttp",
            auth="oauth",
            url="https://app.xmind.com/api/mcp",
            )
        },
        ToolRegistry(),
    )

    await provider.connect()

    snapshot = provider.runtime_status()
    assert snapshot == {"xmind": "failed"}
    assert "saved-oauth-secret" not in str(snapshot)
    assert "app.xmind.com" not in str(snapshot)


@pytest.mark.parametrize( "value_schema, params, error",
    [
        pytest.param(
            True, {"value": {"count": "42", "enabled": False}}, None,
            id="true-property-preserves-value",
        ),
        pytest.param(
            False, {"value": None}, "value is not allowed by schema",
            id="false-property-rejects-null",
        ),
        pytest.param(False, {}, None, id="false-property-can-be-absent"),
        pytest.param(
            {"type": "array", "items": True},
            {"value": ["42", False, None, {"nested": [1]}]},
            None,
            id="true-items-preserve-values",
        ),
        pytest.param(
            {"type": "array", "items": False},
            {"value": [1]},
            "value[0] is not allowed by schema",
            id="false-items-reject-element",
        ),
        pytest.param(
            {"type": "array", "items": False}, {"value": []}, None,
            id="false-items-allow-empty-array",
        ),
        pytest.param(
            {"type": "object", "properties": {"blocked": False}},
            {"value": {"blocked": "x"}},
            "value.blocked is not allowed by schema",
            id="nested-false-property-reports-path",
        ),
    ],
)
async def test_registry_executes_mcp_tools_with_boolean_subschemas(
    value_schema, params, error,
) -> None:
    session = SimpleNamespace(
        call_tool=AsyncMock(return_value=SimpleNamespace(content=[_FakeTextContent("ok")])),
    )
    tool_def = SimpleNamespace(
        name="demo",
        description="demo tool",
        inputSchema={"type": "object", "properties": {"value": value_schema}},
    )
    wrapper = MCPToolWrapper(session, "test", tool_def)
    registry = ToolRegistry()
    registry.register(wrapper)

    result = await registry.execute(wrapper.name, params)

    if error is None:
        assert result == "ok"
        session.call_tool.assert_awaited_once_with("demo", arguments=params)
    else:
        assert is_tool_error_result(result)
        assert f"Invalid parameters for tool '{wrapper.name}': {error}" in result
        session.call_tool.assert_not_awaited()


@pytest.mark.parametrize("types", [["integer", "string"], ["string", "integer"]])
@pytest.mark.parametrize("value", ["00123", "doc-A", 42])
async def test_registry_preserves_mcp_type_union_arguments(types, value) -> None:
    session = SimpleNamespace(
        call_tool=AsyncMock(return_value=SimpleNamespace(content=[_FakeTextContent("ok")])),
    )
    tool_def = SimpleNamespace(
        name="lookup",
        description="Look up an id without changing its type or value.",
        inputSchema={
            "type": "object",
            "properties": {"id": {"type": types}},
            "required": ["id"],
        },
    )
    wrapper = MCPToolWrapper(session, "test", tool_def)
    registry = ToolRegistry()
    registry.register(wrapper)

    result = await registry.execute(wrapper.name, {"id": value})

    assert result == "ok"
    session.call_tool.assert_awaited_once_with("lookup", arguments={"id": value})
    assert type(session.call_tool.call_args.kwargs["arguments"]["id"]) is type(value)


def test_wrapper_preserves_non_nullable_unions() -> None:
    tool_def = SimpleNamespace(
        name="demo",
        description="demo tool",
        inputSchema={
            "type": "object",
            "properties": {
                "value": {
                    "anyOf": [{"type": "string"}, {"type": "integer"}],
                }
            },
        },
    )

    wrapper = MCPToolWrapper(SimpleNamespace(call_tool=None), "test", tool_def)

    assert wrapper.parameters["properties"]["value"]["anyOf"] == [
        {"type": "string"},
        {"type": "integer"},
    ]


def test_wrapper_normalizes_nullable_property_type_union() -> None:
    tool_def = SimpleNamespace(
        name="demo",
        description="demo tool",
        inputSchema={
            "type": "object",
            "properties": {
                "name": {"type": ["string", "null"]},
            },
        },
    )

    wrapper = MCPToolWrapper(SimpleNamespace(call_tool=None), "test", tool_def)

    assert wrapper.parameters["properties"]["name"] == {"type": "string", "nullable": True}


def test_wrapper_normalizes_nullable_property_anyof() -> None:
    tool_def = SimpleNamespace(
        name="demo",
        description="demo tool",
        inputSchema={
            "type": "object",
            "properties": {
                "name": {
                    "anyOf": [{"type": "string"}, {"type": "null"}],
                    "description": "optional name",
                },
            },
        },
    )

    wrapper = MCPToolWrapper(SimpleNamespace(call_tool=None), "test", tool_def)

    assert wrapper.parameters["properties"]["name"] == {
        "type": "string",
        "description": "optional name",
        "nullable": True,
    }


def test_wrapper_hoists_recursive_local_refs_into_defs() -> None:
    recursive_items_ref = "#/properties/filter/properties/items"
    tool_def = SimpleNamespace(
        name="search_dataset",
        description="search tool",
        inputSchema={
            "type": "object",
            "properties": {
                "filter": {
                    "type": "object",
                    "properties": {
                        "items": {
                            "type": "array",
                            "items": {"$ref": recursive_items_ref},
                        }
                    },
                    "required": ["items"],
                }
            },
        },
    )

    wrapper = MCPToolWrapper(SimpleNamespace(call_tool=None), "test", tool_def)

    generated_ref = wrapper.parameters["properties"]["filter"]["properties"]["items"][
        "items"
    ]["$ref"]
    assert generated_ref.startswith("#/$defs/ref_")
    generated_name = generated_ref.removeprefix("#/$defs/")
    generated_schema = wrapper.parameters["$defs"][generated_name]
    assert generated_schema["type"] == "array"
    assert generated_schema["items"]["$ref"] == generated_ref


def test_wrapper_hoists_root_self_ref_into_defs() -> None:
    tool_def = SimpleNamespace(
        name="tree",
        description="tree tool",
        inputSchema={
            "type": "object",
            "properties": {
                "children": {"type": "array", "items": {"$ref": "#"}},
            },
        },
    )

    wrapper = MCPToolWrapper(SimpleNamespace(call_tool=None), "test", tool_def)

    generated_ref = wrapper.parameters["properties"]["children"]["items"]["$ref"]
    assert generated_ref.startswith("#/$defs/ref_")
    generated_name = generated_ref.removeprefix("#/$defs/")
    assert wrapper.parameters["$defs"][generated_name]["properties"]["children"]["items"] == {
        "$ref": generated_ref
    }


def test_wrapper_preserves_existing_defs_refs() -> None:
    tool_def = SimpleNamespace(
        name="demo",
        description="demo tool",
        inputSchema={
            "type": "object",
            "$defs": {"value": {"type": "string"}},
            "properties": {"value": {"$ref": "#/$defs/value"}},
        },
    )

    wrapper = MCPToolWrapper(SimpleNamespace(call_tool=None), "test", tool_def)

    assert wrapper.parameters["properties"]["value"]["$ref"] == "#/$defs/value"
    assert wrapper.parameters["$defs"]["value"]["type"] == "string"


def test_wrapper_resolves_uri_encoded_json_pointer() -> None:
    tool_def = SimpleNamespace(
        name="demo",
        description="demo tool",
        inputSchema={
            "type": "object",
            "properties": {
                "space name/value": {"type": "string"},
                "alias": {"$ref": "#/properties/space%20name~1value"},
            },
        },
    )

    wrapper = MCPToolWrapper(SimpleNamespace(call_tool=None), "test", tool_def)

    generated_ref = wrapper.parameters["properties"]["alias"]["$ref"]
    assert generated_ref.startswith("#/$defs/ref_")
    generated_name = generated_ref.removeprefix("#/$defs/")
    assert wrapper.parameters["$defs"][generated_name] == {"type": "string"}


def test_normalize_windows_stdio_command_is_noop_off_windows(
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    monkeypatch.setattr(mcp_mod.os, "name", "posix", raising=False)

    command, args, env = _normalize_windows_stdio_command(
        "npx",
        ["-y", "chrome-devtools-mcp@latest"],
        {"FOO": "bar"},
    )

    assert command == "npx"
    assert args == ["-y", "chrome-devtools-mcp@latest"]
    assert env == {"FOO": "bar"}


def test_normalize_windows_stdio_command_wraps_npx_on_windows(
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    monkeypatch.setattr(mcp_mod.os, "name", "nt", raising=False)
    monkeypatch.setattr(
        mcp_mod.shutil,
        "which",
        lambda command, path=None: r"C:\Program Files\nodejs\npx.cmd",
    )
    monkeypatch.setenv("COMSPEC", r"C:\Windows\System32\cmd.exe")

    command, args, env = _normalize_windows_stdio_command(
        "npx",
        ["-y", "chrome-devtools-mcp@latest"],
        None,
    )

    assert command == r"C:\Windows\System32\cmd.exe"
    assert args == ["/d", "/c", "npx", "-y", "chrome-devtools-mcp@latest"]
    assert env is None


def test_normalize_windows_stdio_command_wraps_resolved_cmd_launcher(
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    monkeypatch.setattr(mcp_mod.os, "name", "nt", raising=False)

    def _fake_which(command: str, path: str | None = None) -> str:
        assert command == "custom-launcher"
        assert path == r"C:\Tools"
        return r"C:\Tools\custom-launcher.cmd"

    monkeypatch.setattr(mcp_mod.shutil, "which", _fake_which)
    monkeypatch.setenv("COMSPEC", r"C:\Windows\System32\cmd.exe")

    command, args, _env = _normalize_windows_stdio_command(
        "custom-launcher",
        ["serve"],
        {"PATH": r"C:\Tools"},
    )

    assert command == r"C:\Windows\System32\cmd.exe"
    assert args == ["/d", "/c", "custom-launcher", "serve"]


def test_normalize_windows_stdio_command_keeps_real_executables_unchanged(
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    monkeypatch.setattr(mcp_mod.os, "name", "nt", raising=False)

    command, args, env = _normalize_windows_stdio_command(
        "python.exe",
        ["-m", "http.server"],
        {"FOO": "bar"},
    )

    assert command == "python.exe"
    assert args == ["-m", "http.server"]
    assert env == {"FOO": "bar"}


def test_normalize_windows_stdio_command_skips_existing_shells(
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    monkeypatch.setattr(mcp_mod.os, "name", "nt", raising=False)

    command, args, env = _normalize_windows_stdio_command(
        "cmd.exe",
        ["/c", "echo", "hello"],
        None,
    )

    assert command == "cmd.exe"
    assert args == ["/c", "echo", "hello"]
    assert env is None


@pytest.mark.asyncio
async def test_execute_returns_text_blocks() -> None:
    async def call_tool(_name: str, arguments: dict) -> object:
        assert arguments == {"value": 1}
        return SimpleNamespace(content=[_FakeTextContent("hello"), 42])

    wrapper = _make_wrapper(SimpleNamespace(call_tool=call_tool))

    result = await wrapper.execute(value=1)

    assert result == "hello\n42"


@pytest.mark.asyncio
async def test_execute_wraps_mcp_is_error_result() -> None:
    async def call_tool(_name: str, arguments: dict) -> object:
        return SimpleNamespace(
            content=[_FakeTextContent("Error: server-side MCP failure")],
            isError=True,
        )

    wrapper = _make_wrapper(SimpleNamespace(call_tool=call_tool))

    result = await wrapper.execute()

    assert result == "Error: server-side MCP failure"
    assert is_tool_error_result(result)


@pytest.mark.asyncio
async def test_execute_contains_malformed_success_result() -> None:
    async def call_tool(_name: str, arguments: dict) -> object:
        return SimpleNamespace(content=None)

    wrapper = _make_wrapper(SimpleNamespace(call_tool=call_tool))

    result = await wrapper.execute()

    assert result == "(MCP tool returned malformed content: TypeError)"
    assert is_tool_error_result(result)


@pytest.mark.asyncio
async def test_registry_adds_error_hint_to_malformed_mcp_result() -> None:
    async def call_tool(_name: str, arguments: dict) -> object:
        return SimpleNamespace(content=None)

    wrapper = _make_wrapper(SimpleNamespace(call_tool=call_tool))
    registry = ToolRegistry()
    registry.register(wrapper)

    result = await registry.execute(wrapper.name, {})

    assert is_tool_error_result(result)
    assert "MCP tool returned malformed content" in result
    assert (
        "[Consider this result in the context of the user's goal "
        "and decide whether and how to proceed.]"
    ) in result


@pytest.mark.asyncio
async def test_execute_preserves_success_text_that_starts_with_error() -> None:
    async def call_tool(_name: str, arguments: dict) -> object:
        return SimpleNamespace(
            content=[_FakeTextContent("Error: generated report successfully")],
            isError=False,
        )

    wrapper = _make_wrapper(SimpleNamespace(call_tool=call_tool))

    result = await wrapper.execute()

    assert result == "Error: generated report successfully"
    assert not is_tool_error_result(result)


_PNG_B64 = (
    "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8"
    "/x8AAwMCAO+/p9sAAAAASUVORK5CYII="
)


@pytest.mark.asyncio
async def test_execute_persists_image_block_as_artifact(tmp_path: Path) -> None:
    from nanobot.config.loader import set_config_path

    set_config_path(tmp_path / "config.json")

    async def call_tool(_name: str, arguments: dict) -> object:
        return SimpleNamespace(
            content=[
                _FakeTextContent("here you go"),
                _FakeImageContent(_PNG_B64, "image/png"),
            ]
        )

    wrapper = _make_wrapper(SimpleNamespace(call_tool=call_tool))

    result = await wrapper.execute(prompt="a cat", model="sdxl")

    payload = json.loads(result)
    assert payload["text"] == "here you go"
    assert len(payload["artifacts"]) == 1
    artifact = payload["artifacts"][0]
    assert artifact["mime"] == "image/png"
    assert artifact["prompt"] == "a cat"
    assert artifact["provider"] == "mcp:test"
    assert Path(artifact["path"]).is_file()
    assert _PNG_B64 not in result
    assert "message tool" in payload["next_step"]


@pytest.mark.asyncio
async def test_execute_notes_unstorable_image_block(tmp_path: Path) -> None:
    from nanobot.config.loader import set_config_path

    set_config_path(tmp_path / "config.json")

    async def call_tool(_name: str, arguments: dict) -> object:
        return SimpleNamespace(content=[_FakeImageContent("not-valid-base64!!", "image/png")])

    wrapper = _make_wrapper(SimpleNamespace(call_tool=call_tool))

    result = await wrapper.execute()

    assert result == "(MCP tool returned an image that could not be stored)"


@pytest.mark.asyncio
async def test_execute_returns_unknown_outcome_on_submitted_timeout() -> None:
    async def call_tool(_name: str, arguments: dict) -> object:
        await asyncio.sleep(1)
        return SimpleNamespace(content=[])

    wrapper = _make_wrapper(SimpleNamespace(call_tool=call_tool), timeout=0.01)

    result = await wrapper.execute()

    assert result == (
        "(MCP tool call outcome is unknown; timed out after 0.01s. The operation "
        "may have completed and was not replayed after this failure. Check its outcome before "
        "retrying to avoid duplicate side effects.)"
    )
    assert is_tool_error_result(result)


@pytest.mark.asyncio
async def test_execute_handles_server_cancelled_error() -> None:
    async def call_tool(_name: str, arguments: dict) -> object:
        raise asyncio.CancelledError()

    wrapper = _make_wrapper(SimpleNamespace(call_tool=call_tool))

    result = await wrapper.execute()

    assert result == "(MCP tool call was cancelled)"
    assert is_tool_error_result(result)


@pytest.mark.asyncio
async def test_execute_re_raises_external_cancellation() -> None:
    started = asyncio.Event()

    async def call_tool(_name: str, arguments: dict) -> object:
        started.set()
        await asyncio.sleep(60)
        return SimpleNamespace(content=[])

    wrapper = _make_wrapper(SimpleNamespace(call_tool=call_tool), timeout=10)
    task = asyncio.create_task(wrapper.execute())
    await asyncio.wait_for(started.wait(), timeout=1.0)

    task.cancel()

    with pytest.raises(asyncio.CancelledError):
        await task


@pytest.mark.asyncio
async def test_execute_handles_generic_exception() -> None:
    async def call_tool(_name: str, arguments: dict) -> object:
        raise RuntimeError("boom")

    wrapper = _make_wrapper(SimpleNamespace(call_tool=call_tool))

    result = await wrapper.execute()

    assert result == "(MCP tool call failed: RuntimeError)"
    assert is_tool_error_result(result)


def _make_tool_def(name: str) -> SimpleNamespace:
    return SimpleNamespace(
        name=name,
        description=f"{name} tool",
        inputSchema={"type": "object", "properties": {}},
    )


def _make_fake_session(tool_names: list[str]) -> SimpleNamespace:
    async def initialize() -> SimpleNamespace:
        return SimpleNamespace(capabilities=SimpleNamespace(tools=SimpleNamespace()))

    async def list_tools() -> SimpleNamespace:
        return SimpleNamespace(tools=[_make_tool_def(name) for name in tool_names], nextCursor=None)

    return SimpleNamespace(initialize=initialize, list_tools=list_tools)


@pytest.mark.asyncio
@pytest.mark.parametrize(
    ("enabled_tools", "expected_names"),
    [
        pytest.param(["*"], ["first", "second"], id="wildcard"),
        pytest.param(["second"], ["second"], id="raw-allowlist"),
        pytest.param(["mcp_test_second"], ["second"], id="wrapped-allowlist"),
        pytest.param([], [], id="deny-all"),
    ],
)
async def test_connect_mcp_servers_loads_all_tool_pages(
    fake_mcp_runtime: dict[str, object | None],
    enabled_tools: list[str],
    expected_names: list[str],
) -> None:
    cursors: list[str | None] = []
    pages = {
        None: SimpleNamespace(tools=[_make_tool_def("first")], nextCursor=""),
        "": SimpleNamespace(tools=[], nextCursor="opaque:+/="),
        "opaque:+/=": SimpleNamespace(tools=[_make_tool_def("second")], nextCursor=None),
    }

    async def list_tools(*, params: SimpleNamespace | None = None) -> SimpleNamespace:
        cursor = params.cursor if params is not None else None
        cursors.append(cursor)
        return pages[cursor]

    session = _make_fake_session([])
    session.list_tools = list_tools
    session.call_tool = AsyncMock(
        return_value=SimpleNamespace(content=[_FakeTextContent("second page result")])
    )
    fake_mcp_runtime["session"] = session
    registry = ToolRegistry()
    stacks = await connect_mcp_servers(
        {"test": MCPServerConfig(command="fake", enabled_tools=enabled_tools)}, registry,
    )
    try:
        assert set(stacks) == {"test"}
        assert cursors == [None, "", "opaque:+/="]
        expected = [f"mcp_test_{name}" for name in expected_names]
        assert registry.tool_names == expected
        assert [tool["function"]["name"] for tool in registry.get_definitions()] == expected
        if expected_names:
            assert await registry.execute("mcp_test_second", {}) == "second page result"
            session.call_tool.assert_awaited_once_with("second", arguments={})
        else:
            session.call_tool.assert_not_awaited()
    finally:
        for stack in stacks.values():
            await stack.aclose()


@pytest.mark.asyncio
@pytest.mark.parametrize("failure", ["request-error", "repeated-cursor"])
async def test_connect_mcp_servers_pagination_failure_registers_no_tools(
    fake_mcp_runtime: dict[str, object | None], failure: str,
) -> None:
    cursors: list[str | None] = []

    async def list_tools(*, params: SimpleNamespace | None = None) -> SimpleNamespace:
        cursor = params.cursor if params is not None else None
        cursors.append(cursor)
        if cursor is None:
            return SimpleNamespace(tools=[_make_tool_def("first")], nextCursor="next")
        if failure == "request-error":
            raise RuntimeError("second page failed")
        if len(cursors) > 2:
            raise AssertionError("A repeated cursor must not be requested again")
        return SimpleNamespace(tools=[_make_tool_def("second")], nextCursor="next")

    session = _make_fake_session([])
    session.list_tools = list_tools
    fake_mcp_runtime["session"] = session
    registry = ToolRegistry()
    stacks = await connect_mcp_servers(
        {"test": MCPServerConfig(command="fake")}, registry,
    )
    try:
        assert cursors == [None, "next"]
        assert stacks == {}
        assert registry.tool_names == []
        assert registry.get_definitions() == []
    finally:
        for stack in stacks.values():
            await stack.aclose()


@pytest.mark.asyncio
@pytest.mark.parametrize(
    "enabled_tool",
    [
        pytest.param("demo", id="raw_names"),
        pytest.param("mcp_test_demo", id="wrapped_names"),
    ],
)
async def test_connect_mcp_servers_enabled_tools_accepts_raw_and_wrapped_names(
    fake_mcp_runtime: dict[str,
    object | None],
    enabled_tool,
) -> None:
    fake_mcp_runtime["session"] = _make_fake_session(["demo", "other"])
    registry = ToolRegistry()
    stacks = await connect_mcp_servers(
        {"test": MCPServerConfig(command="fake", enabled_tools=[enabled_tool])},
        registry,
    )
    for stack in stacks.values():
        await stack.aclose()

    assert registry.tool_names == ["mcp_test_demo"]


@pytest.mark.asyncio
async def test_connect_mcp_servers_enabled_tools_defaults_to_all(
    fake_mcp_runtime: dict[str, object | None],
) -> None:
    fake_mcp_runtime["session"] = _make_fake_session(["demo", "other"])
    registry = ToolRegistry()
    stacks = await connect_mcp_servers(
        {"test": MCPServerConfig(command="fake")},
        registry,
    )
    for stack in stacks.values():
        await stack.aclose()

    assert registry.tool_names == ["mcp_test_demo", "mcp_test_other"]


@pytest.mark.asyncio
async def test_connect_mcp_servers_enabled_tools_supports_limited_wrapped_names(
    fake_mcp_runtime: dict[str, object | None],
) -> None:
    long_tool_name = "tool-" + "very-long-name-" * 8
    wrapped_name = _sanitize_mcp_tool_name(f"mcp_test_{long_tool_name}")
    assert len(wrapped_name) == 64

    fake_mcp_runtime["session"] = _make_fake_session([long_tool_name, "other"])
    registry = ToolRegistry()
    stacks = await connect_mcp_servers(
        {"test": MCPServerConfig(command="fake", enabled_tools=[wrapped_name])},
        registry,
    )
    for stack in stacks.values():
        await stack.aclose()

    assert registry.tool_names == [wrapped_name]


@pytest.mark.asyncio
async def test_connect_mcp_servers_enabled_tools_empty_list_registers_none(
    fake_mcp_runtime: dict[str, object | None],
) -> None:
    fake_mcp_runtime["session"] = _make_fake_session(["demo", "other"])
    registry = ToolRegistry()
    stacks = await connect_mcp_servers(
        {"test": MCPServerConfig(command="fake", enabled_tools=[])},
        registry,
    )
    for stack in stacks.values():
        await stack.aclose()

    assert registry.tool_names == []


@pytest.mark.asyncio
async def test_connect_mcp_servers_enabled_tools_empty_list_blocks_resources_and_prompts(
    fake_mcp_runtime: dict[str, object | None],
) -> None:
    fake_mcp_runtime["session"] = _make_fake_session_with_capabilities(
        tool_names=["demo"],
        resource_names=["secret_data"],
        prompt_names=["admin_prompt"],
    )
    registry = ToolRegistry()
    stacks = await connect_mcp_servers(
        {"test": MCPServerConfig(command="fake", enabled_tools=[])},
        registry,
    )
    for stack in stacks.values():
        await stack.aclose()

    assert registry.tool_names == []
    assert not any("secret_data" in name for name in registry.tool_names)
    assert not any("admin_prompt" in name for name in registry.tool_names)


@pytest.mark.asyncio
async def test_connect_mcp_servers_enabled_tools_specific_list_blocks_resources_and_prompts(
    fake_mcp_runtime: dict[str, object | None],
) -> None:
    fake_mcp_runtime["session"] = _make_fake_session_with_capabilities(
        tool_names=["demo", "other"],
        resource_names=["secret_data"],
        prompt_names=["admin_prompt"],
    )
    registry = ToolRegistry()
    stacks = await connect_mcp_servers(
        {"test": MCPServerConfig(command="fake", enabled_tools=["demo"])},
        registry,
    )
    for stack in stacks.values():
        await stack.aclose()

    assert "mcp_test_demo" in registry.tool_names
    assert "mcp_test_other" not in registry.tool_names
    assert not any("secret_data" in name for name in registry.tool_names)
    assert not any("admin_prompt" in name for name in registry.tool_names)


@pytest.mark.asyncio
async def test_connect_mcp_servers_enabled_tools_wildcard_allows_resources_and_prompts(
    fake_mcp_runtime: dict[str, object | None],
) -> None:
    fake_mcp_runtime["session"] = _make_fake_session_with_capabilities(
        tool_names=["demo"],
        resource_names=["public_data"],
        prompt_names=["help_prompt"],
    )
    registry = ToolRegistry()
    stacks = await connect_mcp_servers(
        {"test": MCPServerConfig(command="fake", enabled_tools=["*"])},
        registry,
    )
    for stack in stacks.values():
        await stack.aclose()

    assert "mcp_test_demo" in registry.tool_names
    assert any("public_data" in name for name in registry.tool_names)
    assert any("help_prompt" in name for name in registry.tool_names)


@pytest.mark.asyncio
async def test_connect_mcp_servers_enabled_tools_warns_on_unknown_entries(
    fake_mcp_runtime: dict[str, object | None], monkeypatch: pytest.MonkeyPatch
) -> None:
    fake_mcp_runtime["session"] = _make_fake_session(["demo"])
    registry = ToolRegistry()
    warnings: list[str] = []

    def _warning(message: str, *args: object) -> None:
        warnings.append(message.format(*args))

    monkeypatch.setattr("nanobot.agent.tools.mcp.logger.warning", _warning)

    stacks = await connect_mcp_servers(
        {"test": MCPServerConfig(command="fake", enabled_tools=["unknown"])},
        registry,
    )
    for stack in stacks.values():
        await stack.aclose()

    assert registry.tool_names == []
    assert warnings
    assert "enabledTools entries not found: unknown" in warnings[-1]
    assert "Available raw names: demo" in warnings[-1]
    assert "Available wrapped names: mcp_test_demo" in warnings[-1]


@pytest.mark.asyncio
async def test_connect_mcp_servers_logs_stdio_pollution_hint(
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    messages: list[str] = []

    @asynccontextmanager
    async def _broken_stdio_client(_params: object):
        raise RuntimeError("Parse error: Unexpected token 'INFO' before JSON-RPC headers")
        yield  # pragma: no cover

    monkeypatch.setattr(sys.modules["mcp.client.stdio"], "stdio_client", _broken_stdio_client)
    sink = mcp_mod.logger.add(
        lambda message: messages.append(message.record["message"]), level="ERROR"
    )

    registry = ToolRegistry()
    try:
        stacks = await connect_mcp_servers(
            {"gh": MCPServerConfig(command="github-mcp")}, registry
        )
    finally:
        mcp_mod.logger.remove(sink)

    assert stacks == {}
    assert messages
    assert "stdio protocol pollution" in messages[-1]
    assert "stdout" in messages[-1]
    assert "stderr" in messages[-1]


def test_transient_connection_group_logs_brief_warning_and_debug_trace() -> None:
    records: list[dict] = []
    sink = mcp_mod.logger.add(lambda message: records.append(message.record), level="DEBUG")
    error = ExceptionGroup("transport failed", [httpx.ConnectError("")])
    try:
        mcp_mod._log_mcp_connection_failure("notion", error)
    finally:
        mcp_mod.logger.remove(sink)

    warning = next(record for record in records if record["level"].name == "WARNING")
    debug = next(record for record in records if record["level"].name == "DEBUG")
    assert warning["exception"] is None
    assert "transient connection failure" in warning["message"]
    assert debug["exception"] is not None
    assert not any(record["level"].name == "ERROR" for record in records)


def test_unexpected_connection_failure_keeps_error_trace() -> None:
    records: list[dict] = []
    sink = mcp_mod.logger.add(lambda message: records.append(message.record), level="DEBUG")
    try:
        mcp_mod._log_mcp_connection_failure("notion", RuntimeError("boom"))
    finally:
        mcp_mod.logger.remove(sink)

    error = next(record for record in records if record["level"].name == "ERROR")
    assert error["exception"] is not None
    assert not any(record["level"].name == "WARNING" for record in records)


@pytest.mark.asyncio
@pytest.mark.parametrize("transport", ["sse", "streamableHttp"])
@pytest.mark.parametrize("log_content", [True, False])
async def test_proxy_constructor_failure_diagnostics_never_render_live_locals(
    monkeypatch: pytest.MonkeyPatch, transport: str, log_content: bool,
) -> None:
    proxy = "http://diagnostic-user:diagnostic-secret@\u2603.example:8080"
    network = NetworkConfig(proxy=proxy)
    with pytest.raises(httpx.InvalidURL):
        httpx.AsyncHTTPTransport(proxy=network.proxy)

    @asynccontextmanager
    async def sse_client(_url, *, httpx_client_factory):
        async with httpx_client_factory():
            yield object(), object()

    monkeypatch.setattr(sys.modules["mcp.client.sse"], "sse_client", sse_client)
    monkeypatch.setattr(mcp_mod, "validate_url_target", lambda _url: (True, ""))
    monkeypatch.setattr(mcp_mod, "_probe_http_url", AsyncMock(return_value=True))
    messages: list[str] = []
    sink = mcp_mod.logger.add(
        lambda message: messages.append(str(message)), level="DEBUG",
        format="{level} {message}", diagnose=True, backtrace=True,
    )
    registry = ToolRegistry()
    try:
        with request_context(RequestContext(channel="test", chat_id="proxy", log_content=log_content)):
            connections = await connect_mcp_servers(
                {"remote": MCPServerConfig(
                    type=transport, url="https://mcp.example.invalid/mcp", use_proxy=True,
                )}, registry, network=network,
            )
    finally:
        mcp_mod.logger.remove(sink)

    assert connections == {}
    assert registry.tool_names == []
    output = "\n".join(messages)
    assert "diagnostic-secret" not in output
    assert "diagnostic-user" not in output
    assert "failed to connect" in output
    if log_content:
        assert "InvalidURL" in output
        assert "Invalid IDNA hostname" in output
        assert "Traceback (most recent call last)" in output
        assert "in _pinned_transport_kwargs" in output
    else:
        assert "InvalidURL" not in output
        assert "Traceback" not in output


@pytest.mark.asyncio
@pytest.mark.parametrize("failure_stage", ["open", "cleanup"])
@pytest.mark.parametrize("userinfo", ["diagnostic-user:diagnostic%3Asecret", "e:p", "e"])
async def test_connection_failure_redacts_resolved_proxy_in_exception_chain_and_group(
    fake_mcp_runtime, monkeypatch: pytest.MonkeyPatch, failure_stage: str, userinfo: str,
) -> None:
    proxy = f"http://{userinfo}@proxy.example.invalid:8080"
    authority = proxy.removeprefix("http://")
    monkeypatch.setenv("MCP_DIAGNOSTIC_PROXY", proxy)
    network = NetworkConfig(proxy="${MCP_DIAGNOSTIC_PROXY}")
    session = _make_fake_session(["demo"])
    session.initialize = AsyncMock(side_effect=RuntimeError("initialize failed"))
    fake_mcp_runtime["session"] = session

    @asynccontextmanager
    async def failing_sse(_url, *, httpx_client_factory):
        if failure_stage == "cleanup":
            yield object(), object()
        try:
            raise ValueError(f"proxy handshake rejected {proxy}")
        except ValueError as cause:
            raise ExceptionGroup("MCP transport setup failed", [
                httpx.ProxyError(
                    f"authentication rejected {authority} / {unquote(authority)} / {unquote(proxy)}"
                ),
            ]) from cause
        yield  # pragma: no cover

    monkeypatch.setattr(sys.modules["mcp.client.sse"], "sse_client", failing_sse)
    monkeypatch.setattr(mcp_mod, "validate_url_target", lambda _url: (True, ""))
    monkeypatch.setattr(mcp_mod, "_probe_http_url", AsyncMock(return_value=True))
    messages: list[str] = []
    sink = mcp_mod.logger.add(
        lambda message: messages.append(str(message)), level="DEBUG",
        format="{level} {message}", diagnose=True, backtrace=True,
    )
    try:
        assert await connect_mcp_servers(
            {"remote": MCPServerConfig(type="sse", url="https://mcp.example.invalid/sse", use_proxy=True)},
            ToolRegistry(), network=network,
        ) == {}
    finally:
        mcp_mod.logger.remove(sink)

    output = "\n".join(messages)
    for credential_context in (proxy, unquote(proxy), f"{userinfo}@", f"{unquote(userinfo)}@"):
        assert credential_context not in output
    assert "Traceback (most recent call last)" in output
    assert "httpx.ProxyError: authentication rejected" in output
    assert "ValueError: proxy handshake rejected" in output
    assert "ExceptionGroup: MCP transport setup failed" in output
    assert "http://proxy.example.invalid:8080" in output
    assert "[redacted]@proxy.example.invalid:8080" in output
    assert "direct cause" in output
    assert "in failing_sse" in output
    if failure_stage == "cleanup":
        assert "initialize failed" in output


@pytest.mark.parametrize("transient", [False, True])
def test_connection_failure_retains_useful_trace_without_local_values(transient: bool) -> None:
    messages: list[str] = []
    records: list[dict] = []

    def capture(message):
        messages.append(str(message))
        records.append(message.record)

    sink = mcp_mod.logger.add(
        capture, level="DEBUG", format="{level} {message}", diagnose=True, backtrace=True,
    )

    def fail_transport():
        local_credential = "unrelated-local-credential"
        error = httpx.ConnectError if transient else RuntimeError
        raise error(f"handshake failed (credential length {len(local_credential)})")

    try:
        try:
            fail_transport()
        except Exception as exc:
            mcp_mod._log_mcp_connection_failure("remote", exc, " check server configuration")
    finally:
        mcp_mod.logger.remove(sink)

    output = "\n".join(messages)
    assert "unrelated-local-credential" not in output
    assert "handshake failed (credential length 26)" in output
    assert "in fail_transport" in output
    assert "Traceback (most recent call last)" in output
    detail = next(record for record in records if record["exception"] is not None)
    assert detail["exception"].traceback is None
    assert detail["exception"].value.__traceback__ is None
    assert detail["exception"].value.__context__ is None
    assert detail["level"].name == ("DEBUG" if transient else "ERROR")
    if transient:
        assert "ConnectError" in output
        assert "transient connection failure" in output
    else:
        assert "RuntimeError" in output
        assert "check server configuration" in output


@pytest.mark.asyncio
@pytest.mark.parametrize(
    "config",
    [
        MCPServerConfig(url="http://127.0.0.1:9/sse"),
        MCPServerConfig(type="streamableHttp", url="http://127.0.0.1:9/mcp"),
        MCPServerConfig(url="http://169.254.169.254/sse"),
        MCPServerConfig(type="streamableHttp", url="http://169.254.169.254/mcp"),
    ],
)
@pytest.mark.parametrize("use_proxy", [False, True])
async def test_connect_mcp_servers_rejects_unsafe_http_urls_before_probe(
    use_proxy: bool,
    config: MCPServerConfig,
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    attempted_connections: list[tuple[object, ...]] = []
    warnings: list[str] = []

    async def _open_connection(*args: object, **_kwargs: object):
        attempted_connections.append(args)
        raise AssertionError("unsafe MCP URL should be rejected before TCP probe")

    def _warning(message: str, *args: object) -> None:
        warnings.append(message.format(*args))

    monkeypatch.setattr(mcp_mod.asyncio, "open_connection", _open_connection)
    monkeypatch.setattr("nanobot.agent.tools.mcp.logger.warning", _warning)

    registry = ToolRegistry()
    stacks = await connect_mcp_servers(
        {"local": config.model_copy(update={"use_proxy": use_proxy})},
        registry,
        network=NetworkConfig(proxy="http://shared-proxy.example:8080"),
    )

    assert stacks == {}
    assert registry.tool_names == []
    assert attempted_connections == []
    assert any("blocked unsafe URL" in warning for warning in warnings)


@pytest.mark.asyncio
async def test_validate_mcp_request_url_rejects_loopback_without_whitelist() -> None:
    from nanobot.security.network import configure_ssrf_whitelist

    configure_ssrf_whitelist([])
    request = httpx.Request("GET", "http://127.0.0.1/private")

    with pytest.raises(httpx.RequestError, match="Blocked unsafe MCP URL"):
        await mcp_mod._validate_mcp_request_url(request)


@pytest.mark.asyncio
@pytest.mark.parametrize(
    "config",
    [
        MCPServerConfig(type="sse", url="https://mcp.example.com/sse"),
        MCPServerConfig(type="streamableHttp", url="https://mcp.example.com/mcp"),
    ],
)
async def test_connect_mcp_servers_env_proxy_adds_proxy_mounts_and_keeps_pinned_transport(
    config: MCPServerConfig,
    fake_mcp_runtime: dict[str, object | None],
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    fake_mcp_runtime["session"] = _make_fake_session(["demo"])
    client_kwargs: list[dict[str, object]] = []

    async def _reachable(_url: str, *, proxy: str | None = None) -> bool:
        return True

    def _validate(_url: str) -> tuple[bool, str]:
        return True, ""

    class FakeAsyncClient:
        def __init__(self, *args: object, **kwargs: object) -> None:
            client_kwargs.append(kwargs)

        async def __aenter__(self) -> object:
            return self

        async def __aexit__(self, exc_type: object, exc: object, tb: object) -> bool:
            return False

    @asynccontextmanager
    async def _capturing_sse_client(_url: str, httpx_client_factory=None):
        assert httpx_client_factory is not None
        async with httpx_client_factory():
            pass
        yield object(), object()

    @asynccontextmanager
    async def _capturing_streamable_http_client(_url: str, http_client=None):
        assert http_client is not None
        yield object(), object(), object()

    monkeypatch.setenv("HTTPS_PROXY", "http://proxy.example:8080")
    monkeypatch.setenv("NO_PROXY", "localhost,127.0.0.1,::1")
    monkeypatch.setattr(mcp_mod, "validate_url_target", _validate)
    monkeypatch.setattr(mcp_mod, "_probe_http_url", _reachable)
    monkeypatch.setattr(
        mcp_mod,
        "PinnedDNSAsyncTransport",
        lambda: httpx.MockTransport(lambda request: httpx.Response(200, request=request)),
    )
    monkeypatch.setattr(
        "nanobot.security.network.httpx.AsyncHTTPTransport",
        lambda **_kwargs: httpx.MockTransport(
            lambda request: httpx.Response(200, request=request)
        ),
    )
    monkeypatch.setattr(mcp_mod.httpx, "AsyncClient", FakeAsyncClient)
    monkeypatch.setattr(sys.modules["mcp.client.sse"], "sse_client", _capturing_sse_client)
    monkeypatch.setattr(
        sys.modules["mcp.client.streamable_http"],
        "streamable_http_client",
        _capturing_streamable_http_client,
    )

    registry = ToolRegistry()
    stacks = await connect_mcp_servers({"remote": config}, registry)
    for stack in stacks.values():
        await stack.aclose()

    assert client_kwargs
    assert all("transport" in kwargs for kwargs in client_kwargs)
    assert all("mounts" in kwargs for kwargs in client_kwargs)


def test_mcp_http_clients_no_proxy_env_keeps_pinned_direct_route(monkeypatch):
    monkeypatch.setenv("HTTPS_PROXY", "http://proxy.example:8080")
    monkeypatch.setenv("NO_PROXY", "mcp.example.com")
    monkeypatch.setattr(
        mcp_mod,
        "PinnedDNSAsyncTransport",
        lambda: httpx.MockTransport(lambda request: httpx.Response(200, request=request)),
    )
    monkeypatch.setattr(
        "nanobot.security.network.httpx.AsyncHTTPTransport",
        lambda **_kwargs: httpx.MockTransport(
            lambda request: httpx.Response(200, request=request)
        ),
    )

    kwargs = mcp_mod._pinned_transport_kwargs()

    assert "transport" in kwargs
    assert any(transport is None for transport in kwargs["mounts"].values())


@pytest.mark.asyncio
@pytest.mark.parametrize(
    ("config", "expected_transport"),
    [
        (MCPServerConfig(type="sse", url="https://mcp.example.com/sse"), "sse"),
        (
            MCPServerConfig(type="streamableHttp", url="https://mcp.example.com/mcp"),
            "streamableHttp",
        ),
    ],
)
@pytest.mark.parametrize("use_proxy", [False, True])
async def test_connect_mcp_servers_http_clients_reject_unsafe_redirect_targets(
    use_proxy: bool,
    config: MCPServerConfig,
    expected_transport: str,
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    checked_urls: list[str] = []
    sent_urls: list[str] = []
    used_transports: list[str] = []

    def _validate(url: str, **_kwargs: object) -> tuple[bool, str]:
        checked_urls.append(url)
        if url == "http://127.0.0.1/private":
            return False, "loopback blocked"
        return True, ""

    async def _reachable(_url: str, *, proxy: str | None = None) -> bool:
        return True

    def _handler(request: httpx.Request) -> httpx.Response:
        sent_urls.append(str(request.url))
        if str(request.url) == "https://example.com/start":
            return httpx.Response(
                302,
                headers={"Location": "http://127.0.0.1/private"},
                request=request,
            )
        raise AssertionError("unsafe redirect target should be blocked before transport")

    original_async_client = httpx.AsyncClient

    def _async_client_with_mock_transport(*args: object, **kwargs: object) -> httpx.AsyncClient:
        kwargs.setdefault("transport", httpx.MockTransport(_handler))
        return original_async_client(*args, **kwargs)

    @asynccontextmanager
    async def _fake_sse_client(_url: str, httpx_client_factory=None):
        assert httpx_client_factory is not None
        used_transports.append("sse")
        async with httpx_client_factory() as client:
            await client.get("https://example.com/start")
        yield object(), object()

    @asynccontextmanager
    async def _fake_streamable_http_client(_url: str, http_client=None):
        assert http_client is not None
        used_transports.append("streamableHttp")
        await http_client.get("https://example.com/start")
        yield object(), object(), object()

    monkeypatch.setattr(mcp_mod, "validate_url_target", _validate)
    monkeypatch.setattr(mcp_mod, "_probe_http_url", _reachable)
    monkeypatch.setattr(
        mcp_mod,
        "PinnedDNSAsyncTransport",
        lambda **_kwargs: httpx.MockTransport(_handler),
    )
    monkeypatch.setattr(
        mcp_mod.httpx,
        "AsyncHTTPTransport",
        lambda **_kwargs: httpx.MockTransport(_handler),
    )
    monkeypatch.setattr(mcp_mod.httpx, "AsyncClient", _async_client_with_mock_transport)
    monkeypatch.setattr(sys.modules["mcp.client.sse"], "sse_client", _fake_sse_client)
    monkeypatch.setattr(
        sys.modules["mcp.client.streamable_http"],
        "streamable_http_client",
        _fake_streamable_http_client,
    )

    registry = ToolRegistry()
    stacks = await connect_mcp_servers(
        {"remote": config.model_copy(update={"use_proxy": use_proxy})},
        registry,
        network=NetworkConfig(proxy="http://shared-proxy.example:8080"),
    )

    assert stacks == {}
    assert registry.tool_names == []
    assert used_transports == [expected_transport]
    assert checked_urls == [
        config.url,
        "https://example.com/start",
        "http://127.0.0.1/private",
    ]
    assert sent_urls == ["https://example.com/start"]


@pytest.mark.asyncio
@pytest.mark.parametrize("failure_mode", ["exception", "cancellation"])
async def test_connect_mcp_servers_one_failure_does_not_block_others(
    monkeypatch: pytest.MonkeyPatch,
    failure_mode: str,
) -> None:
    bad_session = _make_fake_session([])

    async def _cancel_initialize() -> None:
        raise asyncio.CancelledError("cancelled by SDK")

    if failure_mode == "cancellation":
        bad_session.initialize = _cancel_initialize
    sessions = {
        "bad": bad_session,
        "good": _make_fake_session(["demo"]),
    }

    class _SelectiveClientSession:
        def __init__(self, read: object, _write: object) -> None:
            self._session = sessions[read]

        async def __aenter__(self) -> object:
            return self._session

        async def __aexit__(self, exc_type, exc, tb) -> bool:
            return False

    @asynccontextmanager
    async def _selective_stdio_client(params: object):
        if params.command == "bad" and failure_mode == "exception":
            raise RuntimeError("boom")
        yield params.command, object()

    monkeypatch.setattr(sys.modules["mcp"], "ClientSession", _SelectiveClientSession)
    monkeypatch.setattr(sys.modules["mcp.client.stdio"], "stdio_client", _selective_stdio_client)

    registry = ToolRegistry()
    stacks = await connect_mcp_servers(
        {
            "bad": MCPServerConfig(command="bad"),
            "good": MCPServerConfig(command="good"),
        },
        registry,
    )
    for stack in stacks.values():
        await stack.aclose()

    assert registry.tool_names == ["mcp_good_demo"]
    assert set(stacks) == {"good"}


@pytest.mark.asyncio
async def test_connect_mcp_servers_propagates_external_cancellation(
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    started = asyncio.Event()
    closed = asyncio.Event()

    @asynccontextmanager
    async def _blocking_stdio_client(_params: object):
        try:
            started.set()
            await asyncio.Event().wait()
            yield object(), object()
        finally:
            closed.set()

    monkeypatch.setattr(sys.modules["mcp.client.stdio"], "stdio_client", _blocking_stdio_client)

    task = asyncio.create_task(
        connect_mcp_servers({"slow": MCPServerConfig(command="slow")}, ToolRegistry())
    )
    await asyncio.wait_for(started.wait(), timeout=1.0)
    task.cancel()

    with pytest.raises(asyncio.CancelledError):
        await task

    await asyncio.wait_for(closed.wait(), timeout=1.0)


@pytest.mark.asyncio
async def test_connect_mcp_servers_rolls_back_completed_batch_on_cancellation(
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    slow_started = asyncio.Event()
    closed: list[str] = []
    sessions = {"fast": _make_fake_session(["demo"])}

    class _SelectiveClientSession:
        def __init__(self, read: object, _write: object) -> None:
            self._session = sessions[str(read)]

        async def __aenter__(self) -> object:
            return self._session

        async def __aexit__(self, exc_type, exc, tb) -> bool:
            return False

    @asynccontextmanager
    async def _selective_stdio_client(params: object):
        command = str(params.command)
        try:
            if command == "slow":
                slow_started.set()
                await asyncio.Event().wait()
            yield command, object()
        finally:
            closed.append(command)

    monkeypatch.setattr(sys.modules["mcp"], "ClientSession", _SelectiveClientSession)
    monkeypatch.setattr(sys.modules["mcp.client.stdio"], "stdio_client", _selective_stdio_client)

    registry = ToolRegistry()
    task = asyncio.create_task(
        connect_mcp_servers(
            {
                "fast": MCPServerConfig(command="fast"),
                "slow": MCPServerConfig(command="slow"),
            },
            registry,
        )
    )
    await asyncio.wait_for(slow_started.wait(), timeout=1.0)
    assert registry.tool_names == ["mcp_fast_demo"]

    task.cancel()
    with pytest.raises(asyncio.CancelledError):
        await task

    assert registry.tool_names == []
    assert sorted(closed) == ["fast", "slow"]


@pytest.mark.asyncio
@pytest.mark.parametrize(
    ("tool_timeout", "expected_read"),
    [
        (30, 300.0),
        (600, 600.0),
    ],
)
async def test_connect_mcp_servers_streamable_http_uses_finite_timeout(
    fake_mcp_runtime: dict[str, object | None],
    monkeypatch: pytest.MonkeyPatch,
    tool_timeout: int,
    expected_read: float,
) -> None:
    fake_mcp_runtime["session"] = _make_fake_session(["demo"])
    captured: dict[str, object] = {}

    async def _reachable(_url: str, *, proxy: str | None = None) -> bool:
        return True

    def _validate(_url: str) -> tuple[bool, str]:
        return True, ""

    @asynccontextmanager
    async def _capturing_streamable_http_client(_url: str, http_client=None):
        captured["timeout"] = http_client.timeout
        yield object(), object(), object()

    monkeypatch.setattr(mcp_mod, "validate_url_target", _validate)
    monkeypatch.setattr(mcp_mod, "_probe_http_url", _reachable)
    monkeypatch.setattr(
        mcp_mod,
        "PinnedDNSAsyncTransport",
        lambda: httpx.MockTransport(lambda request: httpx.Response(200, request=request)),
    )
    monkeypatch.setattr(
        sys.modules["mcp.client.streamable_http"],
        "streamable_http_client",
        _capturing_streamable_http_client,
    )

    registry = ToolRegistry()
    stacks = await connect_mcp_servers(
        {
            "test": MCPServerConfig(
                url="https://mcp.example.com/mcp", tool_timeout=tool_timeout
            )
        },
        registry,
    )
    for stack in stacks.values():
        await stack.aclose()

    timeout = captured["timeout"]
    assert timeout.connect == 10.0
    assert timeout.read == expected_read
    assert timeout.write == 30.0
    assert timeout.pool == 30.0


@pytest.mark.parametrize("transport", ["sse", "streamableHttp"])
@pytest.mark.asyncio
async def test_connect_mcp_servers_attaches_oauth_to_remote_http_client(
    transport: str,
    fake_mcp_runtime: dict[str, object | None],
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    fake_mcp_runtime["session"] = _make_fake_session(["demo"])
    oauth_auth = object()
    oauth_handlers = object()
    captured: dict[str, object] = {}

    async def _reachable(_url: str, *, proxy: str | None = None) -> bool:
        return True

    def _validate(_url: str) -> tuple[bool, str]:
        return True, ""

    async def _create_auth(name: str, url: str, handlers: object) -> object:
        captured.update(name=name, url=url, handlers=handlers)
        return oauth_auth

    oauth_mod = ModuleType("nanobot.agent.tools.mcp_oauth")
    oauth_mod.MCPAuthorizationRequiredError = RuntimeError  # type: ignore[attr-defined]
    oauth_mod.create_mcp_oauth_auth = _create_auth  # type: ignore[attr-defined]
    monkeypatch.setitem(sys.modules, "nanobot.agent.tools.mcp_oauth", oauth_mod)

    class FakeAsyncClient:
        def __init__(self, *args: object, **kwargs: object) -> None:
            captured["client_kwargs"] = kwargs

        async def __aenter__(self) -> object:
            return self

        async def __aexit__(self, exc_type: object, exc: object, tb: object) -> bool:
            return False

    @asynccontextmanager
    async def _capturing_sse_client(
        _url: str,
        httpx_client_factory=None,
        auth=None,
    ):
        captured["transport_auth"] = auth
        yield object(), object()

    @asynccontextmanager
    async def _capturing_streamable_http_client(_url: str, http_client=None):
        assert http_client is not None
        yield object(), object(), object()

    monkeypatch.setattr(mcp_mod, "validate_url_target", _validate)
    monkeypatch.setattr(mcp_mod, "_probe_http_url", _reachable)
    monkeypatch.setattr(mcp_mod.httpx, "AsyncClient", FakeAsyncClient)
    monkeypatch.setattr(sys.modules["mcp.client.sse"], "sse_client", _capturing_sse_client)
    monkeypatch.setattr(
        sys.modules["mcp.client.streamable_http"],
        "streamable_http_client",
        _capturing_streamable_http_client,
    )

    url = "https://mcp.example.com/sse" if transport == "sse" else "https://mcp.example.com/mcp"
    registry = ToolRegistry()
    stacks = await connect_mcp_servers(
        {"remote": MCPServerConfig(type=transport, url=url, auth="oauth")},
        registry,
        oauth_handlers={"remote": oauth_handlers},  # type: ignore[arg-type]
    )
    for stack in stacks.values():
        await stack.aclose()

    assert captured["name"] == "remote"
    assert captured["url"] == url
    assert captured["handlers"] is oauth_handlers
    if transport == "sse":
        assert captured["transport_auth"] is oauth_auth
    else:
        client_kwargs = captured["client_kwargs"]
        assert isinstance(client_kwargs, dict)
        assert client_kwargs["auth"] is oauth_auth
        assert client_kwargs["event_hooks"] == {"request": [mcp_mod._validate_mcp_request_url]}


@pytest.mark.asyncio
async def test_connect_mcp_servers_skips_background_oauth_without_credentials(
    fake_mcp_runtime: dict[str, object | None],
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    class AuthorizationRequiredError(RuntimeError):
        pass

    async def _create_auth(*_args: object) -> object:
        raise AuthorizationRequiredError

    probe_called = False

    async def _probe(_url: str, *, proxy: str | None = None) -> bool:
        nonlocal probe_called
        probe_called = True
        return True

    oauth_mod = ModuleType("nanobot.agent.tools.mcp_oauth")
    oauth_mod.MCPAuthorizationRequiredError = AuthorizationRequiredError  # type: ignore[attr-defined]
    oauth_mod.create_mcp_oauth_auth = _create_auth  # type: ignore[attr-defined]
    monkeypatch.setitem(sys.modules, "nanobot.agent.tools.mcp_oauth", oauth_mod)
    monkeypatch.setattr(mcp_mod, "validate_url_target", lambda _url: (True, ""))
    monkeypatch.setattr(mcp_mod, "_probe_http_url", _probe)

    stacks = await connect_mcp_servers(
        {
            "remote": MCPServerConfig(
                type="streamableHttp",
                url="https://mcp.example.com/mcp",
                auth="oauth",
            )
        },
        ToolRegistry(),
    )

    assert stacks == {}
    assert not probe_called


@pytest.mark.asyncio
async def test_connect_mcp_servers_wraps_windows_stdio_launchers(
    fake_mcp_runtime: dict[str, object | None],
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    fake_mcp_runtime["session"] = _make_fake_session(["demo"])
    captured: dict[str, object] = {}

    @asynccontextmanager
    async def _capturing_stdio_client(params: object):
        captured["command"] = params.command
        captured["args"] = params.args
        captured["env"] = params.env
        yield object(), object()

    monkeypatch.setattr(mcp_mod.os, "name", "nt", raising=False)
    monkeypatch.setattr(
        mcp_mod.shutil,
        "which",
        lambda command, path=None: r"C:\Program Files\nodejs\npx.cmd",
    )
    monkeypatch.setenv("COMSPEC", r"C:\Windows\System32\cmd.exe")
    monkeypatch.setattr(sys.modules["mcp.client.stdio"], "stdio_client", _capturing_stdio_client)

    registry = ToolRegistry()
    stacks = await connect_mcp_servers(
        {
            "test": MCPServerConfig(
                command="npx",
                args=["-y", "chrome-devtools-mcp@latest"],
            )
        },
        registry,
    )
    for stack in stacks.values():
        await stack.aclose()

    assert captured["command"] == r"C:\Windows\System32\cmd.exe"
    assert captured["args"] == ["/d", "/c", "npx", "-y", "chrome-devtools-mcp@latest"]
    assert captured["env"] is None


@pytest.mark.asyncio
async def test_connect_mcp_servers_passes_stdio_cwd(
    fake_mcp_runtime: dict[str, object | None],
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    fake_mcp_runtime["session"] = _make_fake_session(["demo"])
    captured: dict[str, object] = {}

    @asynccontextmanager
    async def _capturing_stdio_client(params: object):
        captured["cwd"] = params.cwd
        yield object(), object()

    monkeypatch.setattr(sys.modules["mcp.client.stdio"], "stdio_client", _capturing_stdio_client)

    registry = ToolRegistry()
    stacks = await connect_mcp_servers(
        {"test": MCPServerConfig(command="fake", cwd="/tmp/nanobot-mcp-test")},
        registry,
    )
    for stack in stacks.values():
        await stack.aclose()

    assert captured["cwd"] == "/tmp/nanobot-mcp-test"


def _make_resource_def(
    name: str = "myres",
    uri: str = "file:///tmp/data.txt",
    description: str = "A test resource",
) -> SimpleNamespace:
    return SimpleNamespace(name=name, uri=uri, description=description)


def _make_resource_wrapper(session: object, *, timeout: float = 0.1) -> MCPResourceWrapper:
    return MCPResourceWrapper(session, "srv", _make_resource_def(), resource_timeout=timeout)


def test_resource_wrapper_properties() -> None:
    wrapper = MCPResourceWrapper(None, "myserver", _make_resource_def())
    assert wrapper.name == "mcp_myserver_resource_myres"
    assert "[MCP Resource]" in wrapper.description
    assert "A test resource" in wrapper.description
    assert "file:///tmp/data.txt" in wrapper.description
    assert wrapper.parameters == {"type": "object", "properties": {}, "required": []}
    assert wrapper.read_only is True


@pytest.mark.asyncio
async def test_resource_wrapper_execute_returns_text() -> None:
    async def read_resource(uri: str) -> object:
        assert uri == "file:///tmp/data.txt"
        return SimpleNamespace(
            contents=[_FakeTextResourceContents("line1"), _FakeTextResourceContents("line2")]
        )

    wrapper = _make_resource_wrapper(SimpleNamespace(read_resource=read_resource))
    result = await wrapper.execute()
    assert result == "line1\nline2"


@pytest.mark.asyncio
async def test_resource_wrapper_execute_handles_blob() -> None:
    async def read_resource(uri: str) -> object:
        return SimpleNamespace(contents=[_FakeBlobResourceContents(b"\x00\x01\x02")])

    wrapper = _make_resource_wrapper(SimpleNamespace(read_resource=read_resource))
    result = await wrapper.execute()
    assert "[Binary resource: 3 bytes]" in result


@pytest.mark.asyncio
async def test_resource_wrapper_execute_handles_timeout() -> None:
    async def read_resource(uri: str) -> object:
        await asyncio.sleep(1)
        return SimpleNamespace(contents=[])

    wrapper = _make_resource_wrapper(SimpleNamespace(read_resource=read_resource), timeout=0.01)
    result = await wrapper.execute()
    assert result == "(MCP resource read timed out after 0.01s)"


@pytest.mark.asyncio
async def test_resource_wrapper_execute_handles_error() -> None:
    async def read_resource(uri: str) -> object:
        raise RuntimeError("boom")

    wrapper = _make_resource_wrapper(SimpleNamespace(read_resource=read_resource))
    result = await wrapper.execute()
    assert result == "(MCP resource read failed: RuntimeError)"


def _make_prompt_def(
    name: str = "myprompt",
    description: str = "A test prompt",
    arguments: list | None = None,
) -> SimpleNamespace:
    return SimpleNamespace(name=name, description=description, arguments=arguments)


def _make_prompt_wrapper(session: object, *, timeout: float = 0.1) -> MCPPromptWrapper:
    return MCPPromptWrapper(session, "srv", _make_prompt_def(), prompt_timeout=timeout)


def test_prompt_wrapper_properties() -> None:
    arg1 = SimpleNamespace(name="topic", required=True)
    arg2 = SimpleNamespace(name="style", required=False)
    wrapper = MCPPromptWrapper(None, "myserver", _make_prompt_def(arguments=[arg1, arg2]))
    assert wrapper.name == "mcp_myserver_prompt_myprompt"
    assert "[MCP Prompt]" in wrapper.description
    assert "A test prompt" in wrapper.description
    assert "workflow guide" in wrapper.description
    assert wrapper.parameters["properties"]["topic"] == {"type": "string"}
    assert wrapper.parameters["properties"]["style"] == {"type": "string"}
    assert wrapper.parameters["required"] == ["topic"]
    assert wrapper.read_only is True


def test_prompt_wrapper_no_arguments() -> None:
    wrapper = MCPPromptWrapper(None, "myserver", _make_prompt_def())
    assert wrapper.parameters == {"type": "object", "properties": {}, "required": []}


def test_prompt_wrapper_preserves_argument_descriptions() -> None:
    arg = SimpleNamespace(name="topic", required=True, description="The subject to discuss")
    wrapper = MCPPromptWrapper(None, "srv", _make_prompt_def(arguments=[arg]))
    assert wrapper.parameters["properties"]["topic"] == {
        "type": "string",
        "description": "The subject to discuss",
    }


@pytest.mark.asyncio
async def test_prompt_wrapper_execute_returns_text() -> None:
    async def get_prompt(name: str, arguments: dict | None = None) -> object:
        assert name == "myprompt"
        msg1 = SimpleNamespace(
            role="user",
            content=[_FakeTextContent("You are an expert on {{topic}}.")],
        )
        msg2 = SimpleNamespace(
            role="assistant",
            content=[_FakeTextContent("Understood. Ask me anything.")],
        )
        return SimpleNamespace(messages=[msg1, msg2])

    wrapper = _make_prompt_wrapper(SimpleNamespace(get_prompt=get_prompt))
    result = await wrapper.execute(topic="AI")
    assert "You are an expert on {{topic}}." in result
    assert "Understood. Ask me anything." in result


@pytest.mark.asyncio
async def test_prompt_wrapper_execute_handles_timeout() -> None:
    async def get_prompt(name: str, arguments: dict | None = None) -> object:
        await asyncio.sleep(1)
        return SimpleNamespace(messages=[])

    wrapper = _make_prompt_wrapper(SimpleNamespace(get_prompt=get_prompt), timeout=0.01)
    result = await wrapper.execute()
    assert result == "(MCP prompt call timed out after 0.01s)"


@pytest.mark.asyncio
async def test_prompt_wrapper_execute_handles_mcp_error() -> None:
    from mcp.shared.exceptions import McpError

    async def get_prompt(name: str, arguments: dict | None = None) -> object:
        raise McpError(code=42, message="invalid argument")

    wrapper = _make_prompt_wrapper(SimpleNamespace(get_prompt=get_prompt))
    result = await wrapper.execute()
    assert "invalid argument" in result
    assert "code 42" in result


@pytest.mark.asyncio
async def test_prompt_wrapper_execute_handles_error() -> None:
    async def get_prompt(name: str, arguments: dict | None = None) -> object:
        raise RuntimeError("boom")

    wrapper = _make_prompt_wrapper(SimpleNamespace(get_prompt=get_prompt))
    result = await wrapper.execute()
    assert result == "(MCP prompt call failed: RuntimeError)"


def _make_fake_session_with_capabilities(
    tool_names: list[str],
    resource_names: list[str] | None = None,
    prompt_names: list[str] | None = None,
) -> SimpleNamespace:
    async def initialize() -> SimpleNamespace:
        return SimpleNamespace(capabilities=SimpleNamespace(tools=SimpleNamespace()))

    async def list_tools() -> SimpleNamespace:
        return SimpleNamespace(tools=[_make_tool_def(name) for name in tool_names], nextCursor=None)

    async def list_resources() -> SimpleNamespace:
        resources = []
        for rname in resource_names or []:
            resources.append(
                SimpleNamespace(
                    name=rname,
                    uri=f"file:///{rname}",
                    description=f"{rname} resource",
                )
            )
        return SimpleNamespace(resources=resources, nextCursor=None)

    async def list_prompts() -> SimpleNamespace:
        prompts = []
        for pname in prompt_names or []:
            prompts.append(
                SimpleNamespace(
                    name=pname,
                    description=f"{pname} prompt",
                    arguments=None,
                )
            )
        return SimpleNamespace(prompts=prompts, nextCursor=None)

    return SimpleNamespace(
        initialize=initialize,
        list_tools=list_tools,
        list_resources=list_resources,
        list_prompts=list_prompts,
    )


@pytest.mark.asyncio
@pytest.mark.parametrize("catalog", ["resources", "prompts"])
async def test_connect_registers_all_resource_and_prompt_pages(
    fake_mcp_runtime: dict[str, object | None], catalog: str,
) -> None:
    session = _make_fake_session_with_capabilities(["tool_a"], ["res_b"], ["prompt_c"])
    definition = (
        SimpleNamespace(name="second", uri="file:///second", description="second resource")
        if catalog == "resources"
        else SimpleNamespace(name="second", description="second prompt", arguments=None)
    )
    pages = {
        None: SimpleNamespace(**{catalog: []}, nextCursor=""),
        "": SimpleNamespace(**{catalog: []}, nextCursor="opaque:+/="),
        "opaque:+/=": SimpleNamespace(**{catalog: [definition]}, nextCursor=None),
    }
    cursors: list[str | None] = []

    async def list_pages(*, params: SimpleNamespace | None = None) -> SimpleNamespace:
        cursor = params.cursor if params is not None else None
        cursors.append(cursor)
        return pages[cursor]

    setattr(session, f"list_{catalog}", list_pages)
    fake_mcp_runtime["session"] = session
    registry = ToolRegistry()
    stacks = await connect_mcp_servers({"test": MCPServerConfig(command="fake")}, registry)
    try:
        assert set(stacks) == {"test"}
        assert cursors == [None, "", "opaque:+/="]
        kind = "resource" if catalog == "resources" else "prompt"
        other = "mcp_test_prompt_prompt_c" if catalog == "resources" else "mcp_test_resource_res_b"
        assert set(registry.tool_names) == {"mcp_test_tool_a", other, f"mcp_test_{kind}_second"}
    finally:
        for stack in stacks.values():
            await stack.aclose()


@pytest.mark.asyncio
@pytest.mark.parametrize("catalog", ["resources", "prompts"])
@pytest.mark.parametrize("failure", ["request-error", "repeated-cursor"])
async def test_connect_failed_catalog_pagination_preserves_other_capabilities(
    fake_mcp_runtime: dict[str, object | None], catalog: str, failure: str,
) -> None:
    session = _make_fake_session_with_capabilities(["tool_a"], ["res_b"], ["prompt_c"])
    first_page = await getattr(session, f"list_{catalog}")()
    first_page.nextCursor = "next"
    cursors: list[str | None] = []

    async def list_pages(*, params: SimpleNamespace | None = None) -> SimpleNamespace:
        cursor = params.cursor if params is not None else None
        cursors.append(cursor)
        if cursor is None:
            return first_page
        if failure == "request-error":
            raise RuntimeError("second page failed")
        if len(cursors) > 2:
            raise AssertionError("A repeated cursor must not be requested again")
        return SimpleNamespace(**{catalog: []}, nextCursor="next")

    setattr(session, f"list_{catalog}", list_pages)
    fake_mcp_runtime["session"] = session
    registry = ToolRegistry()
    stacks = await connect_mcp_servers({"test": MCPServerConfig(command="fake")}, registry)
    try:
        assert set(stacks) == {"test"}
        assert cursors == [None, "next"]
        other = "mcp_test_prompt_prompt_c" if catalog == "resources" else "mcp_test_resource_res_b"
        assert set(registry.tool_names) == {"mcp_test_tool_a", other}
    finally:
        for stack in stacks.values():
            await stack.aclose()


@pytest.mark.asyncio
async def test_connect_registers_resources_and_prompts(
    fake_mcp_runtime: dict[str, object | None],
) -> None:
    fake_mcp_runtime["session"] = _make_fake_session_with_capabilities(
        tool_names=["tool_a"],
        resource_names=["res_b"],
        prompt_names=["prompt_c"],
    )
    registry = ToolRegistry()
    stacks = await connect_mcp_servers(
        {"test": MCPServerConfig(command="fake")},
        registry,
    )
    for stack in stacks.values():
        await stack.aclose()

    assert "mcp_test_tool_a" in registry.tool_names
    assert "mcp_test_resource_res_b" in registry.tool_names
    assert "mcp_test_prompt_prompt_c" in registry.tool_names


@pytest.mark.asyncio
@pytest.mark.parametrize("catalog", ["resources", "prompts"])
@pytest.mark.parametrize("failure", ["http", "rpc"])
async def test_discovery_failure_logs_do_not_expose_credentials(
    fake_mcp_runtime: dict[str, object | None],
    monkeypatch: pytest.MonkeyPatch,
    catalog: str,
    failure: str,
) -> None:
    from mcp.shared.exceptions import McpError

    secrets = ("userinfo-secret", "path-secret", "signature-secret", "message-secret")
    url = (
        f"https://user:{secrets[0]}@mcp.example.com/{secrets[1]}"
        f"?signature={secrets[2]}"
    )
    if failure == "http":
        response = httpx.Response(403, request=httpx.Request("POST", url))
        try:
            response.raise_for_status()
        except httpx.HTTPStatusError as exc:
            error = exc
    else:
        error = McpError(code=-32603, message=f"Discovery failed for {url}: {secrets[3]}")

    session = _make_fake_session_with_capabilities(["tool_a"], ["res_b"], ["prompt_c"])
    setattr(session, f"list_{catalog}", AsyncMock(side_effect=error))
    fake_mcp_runtime["session"] = session
    monkeypatch.setattr(mcp_mod, "validate_url_target", lambda _url: (True, ""))
    monkeypatch.setattr(mcp_mod, "_probe_http_url", AsyncMock(return_value=True))
    messages: list[str] = []
    sink = mcp_mod.logger.add(lambda message: messages.append(str(message)), level="DEBUG")
    registry = ToolRegistry()
    stacks = {}
    try:
        stacks = await connect_mcp_servers(
            {"test": MCPServerConfig(type="streamableHttp", url=url)}, registry
        )
        assert set(stacks) == {"test"}
        other = "mcp_test_prompt_prompt_c" if catalog == "resources" else "mcp_test_resource_res_b"
        assert set(registry.tool_names) == {"mcp_test_tool_a", other}
        logs = "\n".join(messages)
        assert not any(secret in logs for secret in secrets)
        assert f"MCP server 'test': {catalog} not supported or failed: {type(error).__name__}" in logs
    finally:
        for stack in stacks.values():
            await stack.aclose()
        mcp_mod.logger.remove(sink)


@pytest.mark.asyncio
@pytest.mark.parametrize("catalog", ["resources", "prompts"])
async def test_connect_accepts_servers_without_tools_capability(
    fake_mcp_runtime: dict[str, object | None], catalog: str,
) -> None:
    from mcp.shared.exceptions import McpError

    session = _make_fake_session_with_capabilities(
        tool_names=[],
        resource_names=["document"] if catalog == "resources" else [],
        prompt_names=["review"] if catalog == "prompts" else [],
    )
    session.initialize = AsyncMock(
        return_value=SimpleNamespace(capabilities=SimpleNamespace(tools=None)),
    )
    session.list_tools = AsyncMock(side_effect=McpError(code=-32601, message="Method not found"))
    fake_mcp_runtime["session"] = session
    registry = ToolRegistry()
    stacks = await connect_mcp_servers({"test": MCPServerConfig(command="fake")}, registry)
    try:
        assert set(stacks) == {"test"}
        expected = "mcp_test_resource_document" if catalog == "resources" else "mcp_test_prompt_review"
        assert registry.tool_names == [expected]
        session.list_tools.assert_not_awaited()
    finally:
        for stack in stacks.values():
            await stack.aclose()


def test_sanitize_name_replaces_spaces() -> None:
    assert _sanitize_name("PostgreSQL System Information") == "PostgreSQL_System_Information"


def test_sanitize_name_replaces_special_characters() -> None:
    assert _sanitize_name("foo.bar@baz!") == "foo_bar_baz_"


def test_sanitize_name_collapses_consecutive_underscores() -> None:
    assert _sanitize_name("a   b") == "a_b"


def test_sanitize_name_preserves_valid_characters() -> None:
    assert _sanitize_name("my-tool_v2") == "my-tool_v2"


def test_sanitize_name_noop_for_already_clean_names() -> None:
    assert _sanitize_name("mcp_server_tool") == "mcp_server_tool"


def test_tool_wrapper_sanitizes_name() -> None:
    tool_def = SimpleNamespace(
        name="My Tool",
        description="tool with spaces",
        inputSchema={"type": "object", "properties": {}},
    )
    wrapper = MCPToolWrapper(SimpleNamespace(call_tool=None), "srv", tool_def)
    assert wrapper.name == "mcp_srv_My_Tool"


def test_resource_wrapper_sanitizes_name() -> None:
    resource_def = SimpleNamespace(
        name="PostgreSQL System Information",
        uri="file:///pg/info",
        description="PG info",
    )
    wrapper = MCPResourceWrapper(None, "srv", resource_def)
    assert wrapper.name == "mcp_srv_resource_PostgreSQL_System_Information"


def test_prompt_wrapper_sanitizes_name() -> None:
    prompt_def = SimpleNamespace(
        name="design-schema",
        description="Design schema",
        arguments=None,
    )
    wrapper = MCPPromptWrapper(None, "my server", prompt_def)
    assert wrapper.name == "mcp_my_server_prompt_design-schema"


def test_tool_wrapper_preserves_original_name_for_mcp_call() -> None:
    tool_def = SimpleNamespace(
        name="My Tool",
        description="tool with spaces",
        inputSchema={"type": "object", "properties": {}},
    )
    wrapper = MCPToolWrapper(SimpleNamespace(call_tool=None), "srv", tool_def)
    assert wrapper.name == "mcp_srv_My_Tool"
    assert wrapper._original_name == "My Tool"


@pytest.mark.asyncio
async def test_connect_mcp_servers_sanitizes_resource_names(
    fake_mcp_runtime: dict[str, object | None],
) -> None:
    fake_mcp_runtime["session"] = _make_fake_session_with_capabilities(
        tool_names=[],
        resource_names=["PostgreSQL System Information"],
        prompt_names=[],
    )
    registry = ToolRegistry()
    stacks = await connect_mcp_servers(
        {"test": MCPServerConfig(command="fake")},
        registry,
    )
    for stack in stacks.values():
        await stack.aclose()

    assert "mcp_test_resource_PostgreSQL_System_Information" in registry.tool_names


@pytest.mark.asyncio
async def test_connect_mcp_servers_enabled_tools_matches_sanitized_name(
    fake_mcp_runtime: dict[str, object | None],
) -> None:
    fake_mcp_runtime["session"] = _make_fake_session_with_capabilities(
        tool_names=["My Tool", "other"],
    )
    registry = ToolRegistry()
    stacks = await connect_mcp_servers(
        {"test": MCPServerConfig(command="fake", enabled_tools=["mcp_test_My_Tool"])},
        registry,
    )
    for stack in stacks.values():
        await stack.aclose()

    assert registry.tool_names == ["mcp_test_My_Tool"]


@pytest.mark.parametrize(
    "url, expected",
    [
        ("https://user:[email protected]/sse", "https://host.example/..."),
        ("https://host.example:8443/mcp?token=abc#frag", "https://host.example:8443/..."),
        ("https://user:secret@[::1]:8443/sse?token=abc", "https://[::1]:8443/..."),
        ("https://host.example/sse", "https://host.example/..."),
        ("https://host.example", "https://host.example"),
        ("https://host.example/", "https://host.example/"),
    ],
)
def test_redact_url_strips_credentials_and_query(url: str, expected: str) -> None:
    assert mcp_mod._redact_url(url) == expected

def test_mcp_tool_name_keeps_short_name():
    name = _sanitize_mcp_tool_name("mcp_myserver_resource_myres")
    assert name == "mcp_myserver_resource_myres"


def test_mcp_tool_name_limits_long_name():
    long_name = "mcp_" + "a" * 100
    name = _sanitize_mcp_tool_name(long_name)

    assert len(name) <= 64
    assert name.startswith("mcp_")


def test_long_server_name_tools_are_matched_by_server_name() -> None:
    server_name = "very-long-server-name-" * 4
    tool_def = SimpleNamespace(
        name="search",
        description="search tool",
        inputSchema={"type": "object", "properties": {}},
    )
    other_tool_def = SimpleNamespace(
        name="search",
        description="other search tool",
        inputSchema={"type": "object", "properties": {}},
    )
    wrapper = MCPToolWrapper(SimpleNamespace(call_tool=None), server_name, tool_def)
    other_wrapper = MCPToolWrapper(SimpleNamespace(call_tool=None), "other", other_tool_def)
    registry = ToolRegistry()
    registry.register(wrapper)
    registry.register(other_wrapper)

    assert len(wrapper.name) == 64
    assert not wrapper.name.startswith(mcp_mod._tool_prefix(server_name))

    provider = MCPProvider(
        {server_name: MCPServerConfig(command="fake")},
        registry,
    )
    provider._attach_reconnect_handlers({server_name})
    assert wrapper._reconnect is not None
    assert other_wrapper._reconnect is None

    removed = mcp_mod._unregister_server_tools(registry, server_name)

    assert removed == 1
    assert wrapper.name not in registry.tool_names
    assert other_wrapper.name in registry.tool_names


@pytest.mark.parametrize("params, error", [
    ({"team": "nanobot", "query": "bug"}, None),
    ({"team": "nanobot", "customView": "saved-view"}, None),
    ({"query": "bug"}, "missing required team"),
    ({"team": "nanobot", "customView": ""}, "customView must be at least 1 chars"),
])
async def test_optional_mcp_filters_reach_server_unchanged(params, error):
    async def call_tool(name, arguments):
        assert name == "list_issues"
        assert not ({"query", "customView"} <= arguments.keys())
        return SimpleNamespace(content=[_FakeTextContent("ok")])

    session = SimpleNamespace(call_tool=AsyncMock(side_effect=call_tool))
    wrapper = MCPToolWrapper(session, "linear", SimpleNamespace(
        name="list_issues",
        description="Search issues or use a saved view",
        inputSchema={
            "type": "object",
            "properties": {
                "team": {"type": "string"},
                "query": {"type": "string"},
                "customView": {"type": "string", "minLength": 1},
            },
            "required": ["team"],
        },
    ))
    registry = ToolRegistry()
    registry.register(wrapper)

    result = await registry.execute(wrapper.name, params)

    if error:
        assert is_tool_error_result(result)
        assert error in result
        session.call_tool.assert_not_awaited()
    else:
        assert result == "ok"
        session.call_tool.assert_awaited_once_with("list_issues", arguments=params)


@pytest.mark.asyncio
@pytest.mark.parametrize("transport", ["sse", "streamableHttp"])
@pytest.mark.parametrize("use_proxy", [False, True], ids=["environment-route", "shared-route"])
async def test_mcp_http_requests_use_selected_transport_without_route_fallback(
    fake_mcp_runtime,
    monkeypatch: pytest.MonkeyPatch,
    transport: str,
    use_proxy: bool,
) -> None:
    fake_mcp_runtime["session"] = _make_fake_session(["demo"])
    routes: list[str] = []
    constructed_proxies: list[str] = []
    shared_proxy = "http://shared.example:8080"

    def recording_transport(route: str) -> httpx.MockTransport:
        def respond(request: httpx.Request) -> httpx.Response:
            routes.append(route)
            return httpx.Response(200, json={"ok": True}, request=request)
        return httpx.MockTransport(respond)

    def proxy_transport(*, proxy: str) -> httpx.MockTransport:
        constructed_proxies.append(proxy)
        return recording_transport("shared")

    async def probe(_url, *, proxy):
        assert proxy == (shared_proxy if use_proxy else None)
        return True

    @asynccontextmanager
    async def sse_client(url, *, httpx_client_factory):
        async with httpx_client_factory() as client:
            response = await client.get(url)
            assert response.json() == {"ok": True}
        yield object(), object()

    @asynccontextmanager
    async def streamable_client(url, *, http_client):
        response = await http_client.get(url)
        assert response.json() == {"ok": True}
        yield object(), object(), object()

    monkeypatch.setenv("HTTPS_PROXY", "http://environment.example:8888")
    monkeypatch.setattr(mcp_mod, "validate_url_target", lambda _url: (True, ""))
    monkeypatch.setattr(mcp_mod, "_probe_http_url", probe)
    monkeypatch.setattr(mcp_mod, "PinnedDNSAsyncTransport", lambda: recording_transport("direct"))
    monkeypatch.setattr(
        mcp_mod, "httpx_env_proxy_mounts", lambda: {"all://": recording_transport("environment")},
    )
    monkeypatch.setattr(mcp_mod.httpx, "AsyncHTTPTransport", proxy_transport)
    monkeypatch.setattr(sys.modules["mcp.client.sse"], "sse_client", sse_client)
    monkeypatch.setattr(sys.modules["mcp.client.streamable_http"], "streamable_http_client", streamable_client)

    registry = ToolRegistry()
    connections = await connect_mcp_servers(
        {"remote": MCPServerConfig(
            type=transport, url="https://93.184.216.34/mcp", use_proxy=use_proxy,
        )},
        registry,
        network=NetworkConfig(proxy=shared_proxy),
    )
    try:
        assert set(connections) == {"remote"}
        assert registry.has("mcp_remote_demo")
        assert routes == (["shared"] if use_proxy else ["environment"])
        assert constructed_proxies == ([shared_proxy] if use_proxy else [])
    finally:
        for connection in connections.values():
            await connection.aclose()


@pytest.mark.asyncio
async def test_stdio_cannot_opt_into_shared_proxy(monkeypatch) -> None:
    stdio_client = AsyncMock()
    monkeypatch.setattr(sys.modules["mcp.client.stdio"], "stdio_client", stdio_client)
    registry = ToolRegistry()
    connections = await connect_mcp_servers(
        {"local": MCPServerConfig(command="must-not-launch", use_proxy=True)},
        registry,
        network=NetworkConfig(proxy="http://shared.example:8080"),
    )
    assert connections == {}
    assert registry.tool_names == []
    stdio_client.assert_not_called()