Skip to content

Local UI to run and train LLMs and diffusion models. Supports GGUF, MLX, Qwen3.8, DeepSeek-V4.1, MiniMax-H3, Gemma 4, FLUX and more.

115 KB
Raw Blame
# SPDX-License-Identifier: AGPL-3.0-only
# Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0

import json
from collections import OrderedDict

import pytest
from fastapi import HTTPException
from pydantic import ValidationError

from storage import mcp_servers_db


def _reset_db(tmp_path, monkeypatch):
    monkeypatch.setenv("UNSLOTH_STUDIO_HOME", str(tmp_path))
    monkeypatch.setattr(mcp_servers_db, "_schema_ready", set())


def test_create_and_get_server(tmp_path, monkeypatch):
    _reset_db(tmp_path, monkeypatch)
    mcp_servers_db.create_server(
        id = "srv1",
        display_name = "GitHub",
        url = "https://example.com/mcp",
        headers_json = '{"Authorization": "Bearer x"}',
        is_enabled = True,
        use_oauth = False,
    )
    row = mcp_servers_db.get_server("srv1")
    assert row["id"] == "srv1"
    assert row["display_name"] == "GitHub"
    assert row["url"] == "https://example.com/mcp"
    assert row["headers_json"] == '{"Authorization": "Bearer x"}'
    assert row["is_enabled"] == 1
    assert row["use_oauth"] == 0


def test_list_servers_ordered_by_created_at(tmp_path, monkeypatch):
    _reset_db(tmp_path, monkeypatch)
    mcp_servers_db.create_server(id = "a", display_name = "A", url = "https://a/m")
    mcp_servers_db.create_server(id = "b", display_name = "B", url = "https://b/m")
    rows = mcp_servers_db.list_servers()
    assert [r["id"] for r in rows] == ["a", "b"]


def test_update_server_coerces_bools(tmp_path, monkeypatch):
    _reset_db(tmp_path, monkeypatch)
    mcp_servers_db.create_server(id = "srv1", display_name = "A", url = "https://a/m")
    assert mcp_servers_db.update_server("srv1", {"is_enabled": False, "use_oauth": True})
    row = mcp_servers_db.get_server("srv1")
    assert row["is_enabled"] == 0
    assert row["use_oauth"] == 1


def test_update_server_empty_changes_returns_false(tmp_path, monkeypatch):
    _reset_db(tmp_path, monkeypatch)
    mcp_servers_db.create_server(id = "srv1", display_name = "A", url = "https://a/m")
    assert mcp_servers_db.update_server("srv1", {}) is False


def test_delete_server_roundtrip(tmp_path, monkeypatch):
    _reset_db(tmp_path, monkeypatch)
    mcp_servers_db.create_server(id = "srv1", display_name = "A", url = "https://a/m")
    assert mcp_servers_db.delete_server("srv1") is True
    assert mcp_servers_db.delete_server("srv1") is False
    assert mcp_servers_db.get_server("srv1") is None


def test_validate_url_accepts_http_and_https():
    from routes.mcp_servers import _validate_url

    assert _validate_url("http://example.com/mcp") == "http://example.com/mcp"
    assert _validate_url("https://example.com/mcp") == "https://example.com/mcp"
    assert _validate_url("  https://example.com/mcp  ") == "https://example.com/mcp"
    assert _validate_url("\n  https://example.com/mcp  \u2003") == "https://example.com/mcp"


def test_validate_url_stdio_keeps_posix_outer_normalization(monkeypatch):
    import routes.mcp_servers as routes_mcp

    import sys

    monkeypatch.setattr(sys, "platform", "linux")
    monkeypatch.setattr(routes_mcp, "stdio_mcp_enabled", lambda: True)
    assert routes_mcp._validate_url("\n  python --flag  \u2003") == "python --flag"


@pytest.mark.parametrize("bad", ["", "   ", "ftp://x", "http://", "noscheme.com"])
def test_validate_url_rejects_bad(bad):
    from routes.mcp_servers import _validate_url
    with pytest.raises(HTTPException) as exc:
        _validate_url(bad)
    assert exc.value.status_code == 400


def test_stdio_command_codec_roundtrip_preserves_order_empty_and_url_argument(monkeypatch):
    from models.mcp_servers import McpStdioCommand, McpStdioDecodeRequest
    import routes.mcp_servers as routes_mcp

    monkeypatch.setattr(routes_mcp, "stdio_mcp_enabled", lambda: True)
    payload = McpStdioCommand(
        command = "python",
        arguments = ["-m", "mod", "--name", "a b", "", "https://example.com/value"],
    )
    encoded = routes_mcp.encode_stdio_command(payload, current_subject = "u")
    decoded = routes_mcp.decode_stdio_command(
        McpStdioDecodeRequest(url = encoded.url), current_subject = "u"
    )

    assert decoded.command == payload.command
    assert decoded.arguments == payload.arguments
    assert McpStdioCommand(command = "python").arguments == []


def test_stdio_command_codec_strips_only_executable_outer_padding(monkeypatch):
    from models.mcp_servers import McpStdioCommand, McpStdioDecodeRequest
    import routes.mcp_servers as routes_mcp

    monkeypatch.setattr(routes_mcp, "stdio_mcp_enabled", lambda: True)
    arguments = ["  keep outer spaces  ", "\nkeep control whitespace\n", ""]
    encoded = routes_mcp.encode_stdio_command(
        McpStdioCommand(command = "  python  ", arguments = arguments), current_subject = "u"
    )
    decoded = routes_mcp.decode_stdio_command(
        McpStdioDecodeRequest(url = encoded.url), current_subject = "u"
    )

    assert decoded.command == "python"
    assert decoded.arguments == arguments


@pytest.mark.parametrize(
    "final_argument",
    [
        pytest.param("\n", id = "newline"),
        pytest.param("\r", id = "carriage-return"),
        pytest.param("\v", id = "vertical-tab"),
        pytest.param("\f", id = "form-feed"),
        pytest.param("\u00a0", id = "nbsp"),
        pytest.param("\u2003", id = "em-space"),
    ],
)
def test_stdio_command_codec_windows_preserves_final_whitespace_argument_end_to_end(
    tmp_path, monkeypatch, final_argument
):
    from core.inference import mcp_client
    from models.mcp_servers import McpServerUpdate
    from models.mcp_servers import McpStdioCommand, McpStdioDecodeRequest
    import asyncio
    import routes.mcp_servers as routes_mcp

    import sys

    import fastmcp
    from fastmcp.client import transports

    from models.mcp_servers import (
        McpServerCreate,
        McpServerTestRequest,
        McpServerUpdate,
        McpStdioCommand,
        McpStdioDecodeRequest,
    )

    _reset_db(tmp_path, monkeypatch)
    monkeypatch.setattr(sys, "platform", "win32")
    monkeypatch.setattr(routes_mcp, "stdio_mcp_enabled", lambda: True)
    monkeypatch.setattr(mcp_client, "stdio_mcp_enabled", lambda: True)
    monkeypatch.setattr(routes_mcp, "close_mcp_sessions", lambda *args: None)

    probed_urls: list[str] = []

    async def capture_probe(**kwargs):
        probed_urls.append(kwargs["url"])
        return []

    monkeypatch.setattr(routes_mcp, "list_tools_async", capture_probe)

    encoded = routes_mcp.encode_stdio_command(
        McpStdioCommand(command = "python", arguments = [final_argument]),
        current_subject = "u",
    )
    decoded = routes_mcp.decode_stdio_command(
        McpStdioDecodeRequest(url = encoded.url), current_subject = "u"
    )

    assert encoded.url.endswith(final_argument)
    assert decoded.arguments == [final_argument]

    probe = asyncio.run(
        routes_mcp.test_mcp_server(McpServerTestRequest(url = encoded.url), current_subject = "u")
    )
    assert probe.ok is True
    assert probed_urls == [encoded.url]

    created = asyncio.run(
        routes_mcp.create_mcp_server(
            McpServerCreate(display_name = "created", url = encoded.url),
            current_subject = "u",
        )
    )
    assert created.url == encoded.url
    assert mcp_servers_db.get_server(created.id)["url"] == encoded.url
    created_decoded = routes_mcp.decode_stdio_command(
        McpStdioDecodeRequest(url = created.url), current_subject = "u"
    )
    assert created_decoded.arguments == [final_argument]

    seed = asyncio.run(
        routes_mcp.create_mcp_server(
            McpServerCreate(display_name = "updated", url = "python seed"),
            current_subject = "u",
        )
    )
    updated = asyncio.run(
        routes_mcp.update_mcp_server(
            seed.id,
            McpServerUpdate(url = encoded.url),
            current_subject = "u",
        )
    )
    assert updated.url == encoded.url
    assert mcp_servers_db.get_server(seed.id)["url"] == encoded.url
    updated_decoded = routes_mcp.decode_stdio_command(
        McpStdioDecodeRequest(url = updated.url), current_subject = "u"
    )
    assert updated_decoded.arguments == [final_argument]

    captured_transport = {}

    class CapturingStdioTransport:
        def __init__(self, **kwargs):
            captured_transport.update(kwargs)

    monkeypatch.setattr(fastmcp, "Client", lambda transport: transport)
    monkeypatch.setattr(transports, "StdioTransport", CapturingStdioTransport)
    monkeypatch.setattr(mcp_client, "_stdio_argv", lambda parts, env: parts)
    mcp_client._client(updated.url, None)
    assert captured_transport["command"] == "python"
    assert captured_transport["args"] == [final_argument]
    assert captured_transport["keep_alive"] is False


def test_stdio_command_codec_is_stateless_and_never_probes(monkeypatch):
    from models.mcp_servers import McpStdioCommand, McpStdioDecodeRequest
    import routes.mcp_servers as routes_mcp

    monkeypatch.setattr(routes_mcp, "stdio_mcp_enabled", lambda: True)

    def _never(*args, **kwargs):
        raise AssertionError("codec must not access storage or transport")

    monkeypatch.setattr(routes_mcp, "list_tools_async", _never)
    monkeypatch.setattr(mcp_servers_db, "list_servers", _never)
    monkeypatch.setattr(mcp_servers_db, "create_server", _never)
    encoded = routes_mcp.encode_stdio_command(
        McpStdioCommand(command = "python", arguments = ["-m", "mod"]),
        current_subject = "u",
    )
    decoded = routes_mcp.decode_stdio_command(
        McpStdioDecodeRequest(url = encoded.url), current_subject = "u"
    )
    assert (decoded.command, decoded.arguments) == ("python", ["-m", "mod"])


def test_stdio_command_codec_remains_available_when_execution_is_disabled(monkeypatch):
    from models.mcp_servers import McpStdioCommand, McpStdioDecodeRequest
    import routes.mcp_servers as routes_mcp

    monkeypatch.setattr(routes_mcp, "stdio_mcp_enabled", lambda: False)
    encoded = routes_mcp.encode_stdio_command(
        McpStdioCommand(command = "python", arguments = ["a b", ""]),
        current_subject = "u",
    )
    decoded = routes_mcp.decode_stdio_command(
        McpStdioDecodeRequest(url = encoded.url), current_subject = "u"
    )

    assert (decoded.command, decoded.arguments) == ("python", ["a b", ""])


@pytest.mark.parametrize(
    ("operation", "detail"),
    [
        ("blank", "command must not be empty"),
        ("url", "local executable"),
        ("http_arguments", "local executable"),
        ("remote_decode", "do not have arguments"),
        ("malformed_decode", "Invalid command"),
    ],
)
def test_stdio_command_codec_rejects_invalid_input_before_probe(monkeypatch, operation, detail):
    from models.mcp_servers import McpStdioCommand, McpStdioDecodeRequest
    import routes.mcp_servers as routes_mcp

    monkeypatch.setattr(routes_mcp, "stdio_mcp_enabled", lambda: True)

    async def _never(**kwargs):
        raise AssertionError("invalid codec input must not be probed")

    monkeypatch.setattr(routes_mcp, "list_tools_async", _never)
    with pytest.raises(HTTPException) as exc:
        if operation == "blank":
            routes_mcp.encode_stdio_command(McpStdioCommand(command = "   "), current_subject = "u")
        elif operation in {"url", "http_arguments"}:
            arguments = ["--flag"] if operation == "http_arguments" else []
            routes_mcp.encode_stdio_command(
                McpStdioCommand(command = "  https://example.com/mcp  ", arguments = arguments),
                current_subject = "u",
            )
        elif operation == "remote_decode":
            routes_mcp.decode_stdio_command(
                McpStdioDecodeRequest(url = "https://example.com/mcp"), current_subject = "u"
            )
        else:
            routes_mcp.decode_stdio_command(
                McpStdioDecodeRequest(url = 'python "unterminated'), current_subject = "u"
            )
    assert exc.value.status_code == 400
    assert detail in str(exc.value.detail)


@pytest.mark.parametrize("bad", [1, True, None, {"value": "x"}])
def test_stdio_command_codec_rejects_non_string_arguments(bad):
    from models.mcp_servers import McpStdioCommand, McpStdioDecodeRequest

    from models.mcp_servers import McpStdioCommand
    with pytest.raises(ValidationError):
        McpStdioCommand.model_validate({"command": "python", "arguments": [bad]})


@pytest.mark.parametrize(
    "payload",
    [
        pytest.param({"command": "py\u0000thon", "arguments": []}, id = "command"),
        pytest.param({"command": "python", "arguments": ["a\u0000b"]}, id = "argument"),
    ],
)
def test_stdio_command_codec_rejects_json_nul(payload, monkeypatch):
    from models.mcp_servers import McpStdioCommand, McpStdioDecodeRequest
    import routes.mcp_servers as routes_mcp

    from models.mcp_servers import McpStdioCommand

    monkeypatch.setattr(routes_mcp, "stdio_mcp_enabled", lambda: True)
    command = McpStdioCommand.model_validate_json(json.dumps(payload))

    with pytest.raises(HTTPException) as exc:
        routes_mcp.encode_stdio_command(command, current_subject = "u")

    assert exc.value.status_code == 400
    assert "NUL" in str(exc.value.detail)


def test_stdio_raw_nul_is_rejected_before_route_side_effects(tmp_path, monkeypatch):
    from models.mcp_servers import McpServerUpdate
    from models.mcp_servers import McpStdioCommand, McpStdioDecodeRequest
    import asyncio
    import routes.mcp_servers as routes_mcp

    from models.mcp_servers import (
        McpServerCreate,
        McpServerImportRequest,
        McpServerTestRequest,
        McpServerUpdate,
        McpStdioDecodeRequest,
    )

    _reset_db(tmp_path, monkeypatch)
    monkeypatch.setattr(routes_mcp, "stdio_mcp_enabled", lambda: True)
    raw = "python a\x00b"
    side_effects: list[str] = []

    async def unexpected_probe(**kwargs):
        side_effects.append("probe")
        return []

    monkeypatch.setattr(routes_mcp, "list_tools_async", unexpected_probe)
    monkeypatch.setattr(
        routes_mcp, "invalidate_tool_cache", lambda *args: side_effects.append("invalidate")
    )
    monkeypatch.setattr(
        routes_mcp, "close_mcp_sessions", lambda *args: side_effects.append("close")
    )

    with pytest.raises(HTTPException):
        routes_mcp.decode_stdio_command(McpStdioDecodeRequest(url = raw), current_subject = "u")
    with pytest.raises(HTTPException):
        asyncio.run(
            routes_mcp.create_mcp_server(
                McpServerCreate(display_name = "bad", url = raw), current_subject = "u"
            )
        )
    assert mcp_servers_db.list_servers() == []

    mcp_servers_db.create_server(id = "seed", display_name = "seed", url = "python ok")
    with pytest.raises(HTTPException):
        asyncio.run(
            routes_mcp.update_mcp_server("seed", McpServerUpdate(url = raw), current_subject = "u")
        )
    assert mcp_servers_db.get_server("seed")["url"] == "python ok"

    with pytest.raises(HTTPException):
        asyncio.run(routes_mcp.test_mcp_server(McpServerTestRequest(url = raw), current_subject = "u"))

    imported = asyncio.run(
        routes_mcp.import_mcp_servers(
            McpServerImportRequest(
                config = {"mcpServers": {"bad": {"command": "python", "args": ["a\x00b"]}}}
            ),
            current_subject = "u",
        )
    )
    assert imported.created == []
    assert len(imported.errors) == 1
    assert "NUL" in imported.errors[0]
    assert [row["id"] for row in mcp_servers_db.list_servers()] == ["seed"]
    assert side_effects == []


def test_normalize_headers():
    from routes.mcp_servers import _normalize_headers

    assert _normalize_headers({"  Auth  ": "Bearer x", "": "ignored"}) == {"Auth": "Bearer x"}
    assert _normalize_headers({"X": 42}) == {"X": "42"}
    assert _normalize_headers({}) is None
    assert _normalize_headers(None) is None
    assert _normalize_headers({"   ": "x"}) is None


@pytest.mark.parametrize(
    "headers",
    [
        pytest.param({"BAD\x00NAME": "value"}, id = "nul-name"),
        pytest.param({"NAME": "bad\x00value"}, id = "nul-value"),
        pytest.param({"BAD=NAME": "value"}, id = "equals-name"),
    ],
)
def test_invalid_headers_and_environment_are_rejected_before_side_effects(
    headers, tmp_path, monkeypatch
):
    from models.mcp_servers import McpServerUpdate
    import asyncio
    import routes.mcp_servers as routes_mcp

    from models.mcp_servers import (
        McpServerCreate,
        McpServerImportRequest,
        McpServerTestRequest,
        McpServerUpdate,
    )

    _reset_db(tmp_path, monkeypatch)
    monkeypatch.setattr(routes_mcp, "stdio_mcp_enabled", lambda: True)
    probes: list[str] = []

    async def unexpected_probe(**kwargs):
        probes.append("probe")
        return []

    monkeypatch.setattr(routes_mcp, "list_tools_async", unexpected_probe)
    with pytest.raises(HTTPException):
        asyncio.run(
            routes_mcp.create_mcp_server(
                McpServerCreate(display_name = "bad", url = "python server.py", headers = headers),
                current_subject = "u",
            )
        )
    assert mcp_servers_db.list_servers() == []

    mcp_servers_db.create_server(id = "seed", display_name = "seed", url = "python server.py")
    with pytest.raises(HTTPException):
        asyncio.run(
            routes_mcp.update_mcp_server(
                "seed", McpServerUpdate(headers = headers), current_subject = "u"
            )
        )
    assert mcp_servers_db.get_server("seed")["headers_json"] is None

    with pytest.raises(HTTPException):
        asyncio.run(
            routes_mcp.test_mcp_server(
                McpServerTestRequest(url = "python server.py", headers = headers),
                current_subject = "u",
            )
        )

    imported = asyncio.run(
        routes_mcp.import_mcp_servers(
            McpServerImportRequest(
                config = {
                    "mcpServers": {
                        "bad": {"command": "python", "args": ["server.py"], "env": headers}
                    }
                }
            ),
            current_subject = "u",
        )
    )
    assert imported.created == []
    assert len(imported.errors) == 1
    assert [row["id"] for row in mcp_servers_db.list_servers()] == ["seed"]
    assert probes == []


def test_changes_from_payload_tristate_headers():
    from models.mcp_servers import McpServerUpdate
    from routes.mcp_servers import _changes_from_payload

    assert "headers_json" not in _changes_from_payload(McpServerUpdate(display_name = "x"))
    assert _changes_from_payload(McpServerUpdate(headers = None))["headers_json"] is None
    assert (
        _changes_from_payload(McpServerUpdate(headers = {"a": "1"}))["headers_json"] == '{"a": "1"}'
    )


def test_mcp_specs_alias_oversized_names():
    import hashlib

    from core.inference.tools import _mcp_specs_for_server

    server = {"id": "s" * 30, "display_name": "S"}
    tools = [
        {"name": "ok", "description": "fine"},
        {"name": "x" * 40, "description": "too long"},
    ]
    specs = _mcp_specs_for_server(server, tools)
    digest = hashlib.sha256(b"x" * 40).hexdigest()[:8]
    assert [spec["function"]["name"] for spec in specs] == [
        f"mcp__{'s' * 30}__ok",
        f"mcp__{'s' * 30}__{'x' * 18}_{digest}",
    ]
    assert len(specs[1]["function"]["name"]) == 64
    assert specs[1]["function"]["description"] == f"[S] ({'x' * 40}) too long"
    assert specs[0]["function"]["description"] == "[S] fine"


def test_execute_tool_malformed_mcp_name():
    from core.inference.tools import execute_tool
    out = execute_tool("mcp__no_double_underscore", {})
    assert out.startswith("Error: malformed MCP tool name")


def test_execute_tool_unknown_server(tmp_path, monkeypatch):
    from core.inference.tools import execute_tool
    _reset_db(tmp_path, monkeypatch)
    assert (
        execute_tool("mcp__missing__do_thing", {})
        == "Error: MCP server for tool 'do_thing' not found"
    )


def test_execute_tool_disabled_server(tmp_path, monkeypatch):
    from core.inference.tools import execute_tool

    _reset_db(tmp_path, monkeypatch)
    mcp_servers_db.create_server(
        id = "srv1",
        display_name = "A",
        url = "https://a/m",
        is_enabled = False,
    )

    assert execute_tool("mcp__srv1__do_thing", {}) == "Error: MCP server 'A' is disabled"


def test_mcp_specs_alias_invalid_openai_function_names():
    """OpenAI requires function.name ^[a-zA-Z0-9_-]{1,64}$; bad names 400 the request."""
    import re

    from core.inference.tools import _mcp_specs_for_server

    server = {"id": "srv", "display_name": "S"}
    tools = [
        {"name": "ok"},
        {"name": "with.dot"},
        {"name": "weird/slash"},
        {"name": "has space"},
        {"name": "good-dash_ok"},
    ]
    names = [s["function"]["name"] for s in _mcp_specs_for_server(server, tools)]
    assert names[0] == "mcp__srv__ok"
    assert names[4] == "mcp__srv__good-dash_ok"
    assert [name.rsplit("_", 1)[0] for name in names[1:4]] == [
        "mcp__srv__with_dot",
        "mcp__srv__weird_slash",
        "mcp__srv__has_space",
    ]
    assert all(re.fullmatch(r"[a-zA-Z0-9_-]{1,64}", name) for name in names)


def test_mcp_specs_aliases_stay_unique_and_never_take_a_valid_name():
    import hashlib

    from core.inference.tools import _mcp_specs_for_server

    taken = "with_dot_" + hashlib.sha256(b"with.dot").hexdigest()[:8]
    tools = [
        {"name": "a.b"},
        {"name": "a/b"},
        {"name": "a_b"},
        {"name": "with.dot"},
        {"name": taken},
    ]
    specs = _mcp_specs_for_server({"id": "srv", "display_name": "S"}, tools)
    assert [spec["function"]["name"] for spec in specs] == [
        "mcp__srv__a_b_" + hashlib.sha256(b"a.b").hexdigest()[:8],
        "mcp__srv__a_b_" + hashlib.sha256(b"a/b").hexdigest()[:8],
        "mcp__srv__a_b",
        f"mcp__srv__{taken}",
    ]


def _cache_backstage_tools(tmp_path, monkeypatch, raw_names):
    from core.inference import mcp_client

    _reset_db(tmp_path, monkeypatch)
    monkeypatch.setattr(mcp_client, "_tool_cache", {})
    mcp_servers_db.create_server(
        id = "0123456789abcdef",
        display_name = "Backstage",
        url = "https://backstage/mcp",
        is_enabled = True,
    )
    tools = [{"name": name} for name in raw_names]
    mcp_client.cache_tools("0123456789abcdef", tools)
    return mcp_servers_db.get_server("0123456789abcdef"), tools


def test_execute_tool_dispatches_an_alias_to_the_raw_mcp_name(tmp_path, monkeypatch):
    from core.inference import tools as tools_mod

    raw_names = [
        "get_weather",
        "catalog.get-catalog-entity",
        "summarize_repository_pull_request_review_comments",
        "get_repository_branch_protection_rules_v1",
        "get_repository_branch_protection_rules_v12",
    ]
    server, tools = _cache_backstage_tools(tmp_path, monkeypatch, raw_names)
    calls = []

    def fake_call_tool_sync(**kwargs):
        calls.append(kwargs["name"])
        return "ok"

    monkeypatch.setattr(tools_mod, "call_tool_sync", fake_call_tool_sync)
    names = [spec["function"]["name"] for spec in tools_mod._mcp_specs_for_server(server, tools)]
    assert names[0] == "mcp__0123456789abcdef__get_weather"
    assert names[3] == "mcp__0123456789abcdef__get_repository_branch_protection_rules_v1"
    assert len(set(names)) == 5
    assert [tools_mod.execute_tool(name, {}) for name in names] == ["ok"] * 5
    assert calls == raw_names
    mcp_servers_db.delete_server(server["id"])
    assert tools_mod.execute_tool(names[1], {}) == (
        "Error: MCP server for tool 'catalog.get-catalog-entity' not found"
    )


def test_mcp_approval_classifies_an_alias_by_its_raw_name(tmp_path, monkeypatch):
    from core.inference import tools as tools_mod

    server, tools = _cache_backstage_tools(
        tmp_path, monkeypatch, ["get_repository_branch_protection_rules_then_delete"]
    )
    alias = tools_mod._mcp_specs_for_server(server, tools)[0]["function"]["name"]
    unresolved = "mcp__missing__" + alias.split("__", 2)[2]
    assert not tools_mod.is_potentially_unsafe_tool_call(unresolved, {})
    assert not tools_mod.is_high_risk_tool_call(unresolved, {})
    assert tools_mod.is_potentially_unsafe_tool_call(alias, {})
    assert tools_mod.is_high_risk_tool_call(alias, {})


def test_mcp_alias_is_shown_to_the_user_by_its_raw_name(tmp_path, monkeypatch):
    from core.inference import studio_tool_loop
    from core.inference import tool_loop_controller as controller
    from core.inference.tools import _mcp_specs_for_server

    raw = "catalog.get-catalog-entity"
    server, tools = _cache_backstage_tools(tmp_path, monkeypatch, ["get_weather", raw])
    plain, alias = [spec["function"]["name"] for spec in _mcp_specs_for_server(server, tools)]
    assert alias != f"mcp__{server['id']}__{raw}"
    assert controller.mcp_display_parts(plain) == ("Backstage", "get_weather")
    assert controller.mcp_display_parts(alias) == ("Backstage", raw)
    assert controller.status_for_tool(alias, {}) == f"Calling: Backstage · {raw}"
    assert controller.awaiting_approval_status(alias) == f"Waiting for approval: Backstage · {raw}"
    decision = controller.ToolLoopController(tools = None).prepare_call(
        {"function": {"name": alias, "arguments": {}}}
    )
    for provenance in (
        decision.provenance,
        controller.provisional_tool_provenance(alias),
        studio_tool_loop._unrun_provenance(alias, 0),
    ):
        assert provenance["mcp_server"] == "Backstage"
        assert provenance["mcp_tool"] == raw
    assert controller.provisional_tool_provenance(plain)["mcp_tool"] == "get_weather"


def test_in_flight_alias_still_dispatches_after_the_tool_cache_is_evicted(tmp_path, monkeypatch):
    from core.inference import mcp_client
    from core.inference import tool_loop_controller as controller
    from core.inference import tools as tools_mod

    server, tools = _cache_backstage_tools(
        tmp_path, monkeypatch, ["catalog.get-catalog-entity", "delete.catalog-entity"]
    )
    calls = []
    monkeypatch.setattr(
        tools_mod, "call_tool_sync", lambda **kwargs: calls.append(kwargs["name"]) or "ok"
    )
    names = [spec["function"]["name"] for spec in tools_mod._mcp_specs_for_server(server, tools)]
    mcp_servers_db.update_server(server["id"], {"headers_json": '{"Authorization": "Bearer new"}'})
    mcp_client.invalidate_tool_cache(server["id"])
    assert mcp_client.get_cached_tools(server["id"]) is None
    assert tools_mod.is_potentially_unsafe_tool_call(names[1], {})
    assert controller.mcp_display_parts(names[0]) == ("Backstage", "catalog.get-catalog-entity")
    assert tools_mod.execute_tool(names[0], {}) == "ok"
    assert calls == ["catalog.get-catalog-entity"]


def test_a_direct_name_is_not_resolved_through_a_retired_alias(tmp_path, monkeypatch):
    import hashlib

    from core.inference import mcp_client
    from core.inference import tools as tools_mod

    monkeypatch.setattr(tools_mod, "_MCP_TOOL_ALIASES", {})
    server, tools = _cache_backstage_tools(tmp_path, monkeypatch, ["with.dot"])
    alias = tools_mod._mcp_specs_for_server(server, tools)[0]["function"]["name"]
    taken = "with_dot_" + hashlib.sha256(b"with.dot").hexdigest()[:8]
    assert alias == f"mcp__{server['id']}__{taken}"
    calls = []
    monkeypatch.setattr(
        tools_mod, "call_tool_sync", lambda **kwargs: calls.append(kwargs["name"]) or "ok"
    )
    refreshed = [{"name": taken}]
    mcp_client.cache_tools(server["id"], refreshed)
    assert tools_mod._mcp_specs_for_server(server, refreshed)[0]["function"]["name"] == alias
    assert tools_mod.execute_tool(alias, {}) == "ok"
    assert calls == [taken]


def test_mcp_specs_skip_empty_tool_name():
    from core.inference.tools import _mcp_specs_for_server

    server = {"id": "srv", "display_name": "S"}
    specs = _mcp_specs_for_server(server, [{"name": "", "description": "x"}])
    assert specs == []


def test_mcp_specs_skip_app_only_tools():
    """MCP Apps tools marked _meta.ui.visibility without "model" are for the
    server's rendered widget, not the LLM; keep them out of the schema set."""
    from core.inference.tools import _mcp_specs_for_server

    server = {"id": "srv", "display_name": "S"}
    tools = [
        {"name": "shown"},
        {"name": "widget_only", "meta": {"ui": {"visibility": ["app"]}}},
        {"name": "both", "meta": {"ui": {"visibility": ["app", "model"]}}},
        {"name": "flat_key", "meta": {"ui/visibility": ["app"]}},
        {"name": "underscore_meta", "_meta": {"ui": {"visibility": ["app"]}}},
        {"name": "unrelated_meta", "meta": {"ui": {"resourceUri": "ui://x"}}},
    ]
    specs = _mcp_specs_for_server(server, tools)
    names = {s["function"]["name"] for s in specs}
    assert names == {"mcp__srv__shown", "mcp__srv__both", "mcp__srv__unrelated_meta"}


def test_mcp_specs_read_visibility_from_either_meta_spelling():
    """A "meta" holding unrelated keys must not mask an app-only "_meta"."""
    from core.inference.tools import _mcp_specs_for_server

    server = {"id": "srv", "display_name": "S"}
    tools = [
        {
            "name": "widget_only",
            "meta": {"vendor": "x"},
            "_meta": {"ui": {"visibility": ["app"]}},
        },
        {"name": "shown", "meta": {"vendor": "x"}, "_meta": {"ui": {"visibility": ["model"]}}},
    ]
    specs = _mcp_specs_for_server(server, tools)
    assert {s["function"]["name"] for s in specs} == {"mcp__srv__shown"}


@pytest.mark.parametrize(
    "visibility, visible",
    [
        (["model"], True),
        (["app"], False),
        ([], False),
        ("model", True),
        (None, True),
        (["Model"], False),
    ],
)
def test_mcp_specs_visibility_shapes(visibility, visible):
    from core.inference.tools import _mcp_specs_for_server

    tool = {"name": "t", "meta": {"ui": {"visibility": visibility}}}
    specs = _mcp_specs_for_server({"id": "srv", "display_name": "S"}, [tool])
    assert bool(specs) is visible


@pytest.mark.parametrize("schema_key", ["inputSchema", "input_schema"])
def test_mcp_specs_keep_the_tool_arguments(schema_key):
    """Reading one schema spelling only drops every tool's arguments after an mcp 2.x bump."""
    from core.inference.tools import _mcp_specs_for_server

    schema = {"type": "object", "properties": {"q": {"type": "string"}}}
    tool = {"name": "search", "description": "d", schema_key: schema}
    specs = _mcp_specs_for_server({"id": "srv", "display_name": "S"}, [tool])
    assert specs[0]["function"]["parameters"] == schema


def test_mcp_specs_match_the_installed_sdk_dump():
    """Whichever spelling the pinned SDK emits, the arguments must survive."""
    from core.inference.tools import _mcp_specs_for_server

    from mcp.types import Tool

    schema = {"type": "object", "properties": {"q": {"type": "string"}}}
    dumped = Tool(name = "search", description = "d", inputSchema = schema).model_dump(exclude_none = True)
    specs = _mcp_specs_for_server({"id": "srv", "display_name": "S"}, [dumped])
    assert specs[0]["function"]["parameters"] == schema


def test_mcp_specs_drops_duplicate_names():
    """Duplicate tool names from one server -> OpenAI rejects; drop before forwarding."""
    from core.inference.tools import _mcp_specs_for_server

    server = {"id": "srv", "display_name": "S"}
    tools = [{"name": "echo"}, {"name": "echo"}]
    specs = _mcp_specs_for_server(server, tools)
    assert len(specs) == 1


def test_call_tool_sync_respects_pre_set_cancel_event(monkeypatch):
    """Pre-set cancel_event -> immediate cancellation, no network round-trip."""
    from core.inference import mcp_client
    import threading

    class _StubClient:
        async def __aenter__(self):
            return self

        async def __aexit__(self, *args):
            return False

        async def call_tool(
            self,
            name,
            args,
            raise_on_error = True,
        ):
            import asyncio as _asyncio
            await _asyncio.sleep(30)

    monkeypatch.setattr(mcp_client, "_client", lambda *a, **kw: _StubClient())

    cancel = threading.Event()
    cancel.set()
    out = mcp_client.call_tool_sync(
        url = "https://example/mcp",
        headers = None,
        name = "slow",
        args = {},
        timeout = 30.0,
        cancel_event = cancel,
    )
    assert "cancelled" in out.lower()


def test_clear_oauth_tokens_async_no_op_safe(tmp_path, monkeypatch):
    """clear_oauth_tokens_async on a URL with no stored token must not raise;
    the delete + update handlers call it best-effort regardless of state."""
    from core.inference import mcp_client
    import asyncio

    monkeypatch.setenv("UNSLOTH_STUDIO_HOME", str(tmp_path))

    monkeypatch.setattr(mcp_client, "_oauth_token_store", None)
    asyncio.run(mcp_client.clear_oauth_tokens_async("https://example.com/mcp"))


def test_delete_server_calls_oauth_cleanup_when_oauth_was_on(tmp_path, monkeypatch):
    """delete_mcp_server route helper must call clear_oauth_tokens_async
    when the deleted row had use_oauth=true."""
    from core.inference import mcp_client
    import asyncio
    import routes.mcp_servers as routes_mcp

    _reset_db(tmp_path, monkeypatch)

    monkeypatch.setattr(mcp_client, "_oauth_token_store", None)
    mcp_servers_db.create_server(
        id = "oauth1",
        display_name = "GH",
        url = "https://gh-mcp.example/mcp",
        is_enabled = True,
        use_oauth = True,
    )

    calls: list[str] = []

    async def fake_clear(url):
        calls.append(url)

    monkeypatch.setattr(mcp_client, "clear_oauth_tokens_async", fake_clear)

    monkeypatch.setattr(routes_mcp, "clear_oauth_tokens_async", fake_clear)
    asyncio.run(routes_mcp.delete_mcp_server("oauth1", current_subject = "u"))
    assert calls == ["https://gh-mcp.example/mcp"]
    assert mcp_servers_db.get_server("oauth1") is None


def test_delete_server_skips_oauth_cleanup_when_oauth_off(tmp_path, monkeypatch):
    """No OAuth token cleanup when the deleted server never had OAuth."""
    from core.inference import mcp_client
    import asyncio
    import routes.mcp_servers as routes_mcp

    _reset_db(tmp_path, monkeypatch)

    monkeypatch.setattr(mcp_client, "_oauth_token_store", None)
    mcp_servers_db.create_server(
        id = "noauth",
        display_name = "Plain",
        url = "https://plain/mcp",
        is_enabled = True,
        use_oauth = False,
    )
    calls: list[str] = []

    async def fake_clear(url):
        calls.append(url)

    monkeypatch.setattr(routes_mcp, "clear_oauth_tokens_async", fake_clear)
    asyncio.run(routes_mcp.delete_mcp_server("noauth", current_subject = "u"))
    assert calls == []


def test_update_server_clears_oauth_on_url_change(tmp_path, monkeypatch):
    """Changing an OAuth server's URL must drop the old tokens, or the new URL inherits them."""
    from core.inference import mcp_client
    from models.mcp_servers import McpServerUpdate
    import asyncio
    import routes.mcp_servers as routes_mcp

    _reset_db(tmp_path, monkeypatch)

    monkeypatch.setattr(mcp_client, "_oauth_token_store", None)
    mcp_servers_db.create_server(
        id = "s1",
        display_name = "A",
        url = "https://old/mcp",
        is_enabled = True,
        use_oauth = True,
    )
    calls: list[str] = []

    async def fake_clear(url):
        calls.append(url)

    monkeypatch.setattr(routes_mcp, "clear_oauth_tokens_async", fake_clear)
    asyncio.run(
        routes_mcp.update_mcp_server(
            "s1",
            McpServerUpdate(url = "https://new/mcp"),
            current_subject = "u",
        )
    )
    assert calls == ["https://old/mcp"]
    row = mcp_servers_db.get_server("s1")
    assert row["url"] == "https://new/mcp"


def test_update_server_clears_oauth_when_oauth_disabled(tmp_path, monkeypatch):
    """Flipping use_oauth false must drop the old URL's tokens."""
    from core.inference import mcp_client
    from models.mcp_servers import McpServerUpdate
    import asyncio
    import routes.mcp_servers as routes_mcp

    _reset_db(tmp_path, monkeypatch)

    monkeypatch.setattr(mcp_client, "_oauth_token_store", None)
    mcp_servers_db.create_server(
        id = "s1",
        display_name = "A",
        url = "https://u/mcp",
        is_enabled = True,
        use_oauth = True,
    )
    calls: list[str] = []

    async def fake_clear(url):
        calls.append(url)

    monkeypatch.setattr(routes_mcp, "clear_oauth_tokens_async", fake_clear)
    asyncio.run(
        routes_mcp.update_mcp_server(
            "s1",
            McpServerUpdate(use_oauth = False),
            current_subject = "u",
        )
    )
    assert calls == ["https://u/mcp"]


def test_changes_from_payload_rejects_null_is_enabled():
    """Explicit null for is_enabled used to hit int(None) -> TypeError 500."""
    from models.mcp_servers import McpServerUpdate
    from routes.mcp_servers import _changes_from_payload

    with pytest.raises(HTTPException) as exc:
        _changes_from_payload(McpServerUpdate(is_enabled = None))
    assert exc.value.status_code == 400


def test_changes_from_payload_rejects_null_use_oauth():
    """Explicit null for use_oauth used to hit int(None) -> TypeError 500."""
    from models.mcp_servers import McpServerUpdate
    from routes.mcp_servers import _changes_from_payload

    with pytest.raises(HTTPException) as exc:
        _changes_from_payload(McpServerUpdate(use_oauth = None))
    assert exc.value.status_code == 400


def test_test_endpoint_surfaces_url_validation_as_400(tmp_path, monkeypatch):
    """POST /api/mcp/servers/test must return 400 on an invalid URL, as create and update do."""
    import asyncio

    _reset_db(tmp_path, monkeypatch)
    from routes.mcp_servers import test_mcp_server
    from models.mcp_servers import McpServerTestRequest

    with pytest.raises(HTTPException) as exc:
        asyncio.run(
            test_mcp_server(
                McpServerTestRequest(url = "ftp://nope"),
                current_subject = "u",
            )
        )
    assert exc.value.status_code == 400


def test_tool_xml_parser_handles_hyphenated_parameter_names():
    """Hyphenated property names like `issue-number` must round-trip through the
    XML parser (the old `<parameter=\\w+>` regex dropped them)."""
    import json as _json

    from core.inference.tool_call_parser import parse_tool_calls_from_text

    calls = parse_tool_calls_from_text(
        "<function=mcp__srv__create-issue>"
        "<parameter=issue-title>Bug report</parameter>"
        "<parameter=repo-name>octocat/hello</parameter>"
        "</function>"
    )
    assert len(calls) == 1
    args = _json.loads(calls[0]["function"]["arguments"])
    assert args == {"issue-title": "Bug report", "repo-name": "octocat/hello"}


def test_tool_healing_strip_handles_hyphenated_function_names():
    """core/tool_healing.py keeps its own XML strip regex, which the shared-parser fix missed."""
    from core.tool_healing import strip_tool_call_markup

    out = strip_tool_call_markup(
        "before <function=mcp__srv__list-issues><parameter=q>x</parameter></function> after"
    )
    assert out == "before  after"


def test_tool_healing_strip_handles_gemma_native_tool_call():
    from core.tool_healing import strip_tool_call_markup
    out = strip_tool_call_markup(
        'before <|tool_call>call:mcp__srv__list-issues{repo:"octocat/hello"}<tool_call|> after'
    )
    assert out == "before  after"


def test_tool_healing_strip_handles_gemma_close_only_marker():
    from core.tool_healing import strip_tool_call_markup
    assert strip_tool_call_markup("before <tool_call|> after") == "before  after"
    assert strip_tool_call_markup("before <tool_call|> after", final = True) == "before  after"


def test_tool_healing_parser_handles_gemma_native_windows_path():
    import json as _json

    from core.tool_healing import parse_tool_calls_from_text

    calls = parse_tool_calls_from_text(
        r'<|tool_call>call:ls{path:<|"|>C:\Users\wasim\repo<|"|>}<tool_call|>'
    )
    assert len(calls) == 1
    assert calls[0]["function"]["name"] == "ls"
    assert _json.loads(calls[0]["function"]["arguments"]) == {"path": r"C:\Users\wasim\repo"}


def test_tool_healing_json_parser_preserves_literal_gemma_quote_token():
    import json as _json

    from core.tool_healing import parse_tool_calls_from_text

    text = (
        "<tool_call>"
        + _json.dumps({"name": "python", "arguments": {"code": "print('<|\"|>')"}})
        + "</tool_call>"
    )
    calls = parse_tool_calls_from_text(text, allow_incomplete = False)
    assert len(calls) == 1
    assert _json.loads(calls[0]["function"]["arguments"]) == {"code": "print('<|\"|>')"}


def test_gguf_allow_list_blocks_unadvertised_tool(monkeypatch):
    """An unadvertised tool call must be refused by the GGUF agentic loop, as on safetensors."""
    from core.inference import tools as tools_mod

    captured: list[str] = []

    def fake_execute(name, args, **kw):
        captured.append(name)
        return "executed"

    monkeypatch.setattr(tools_mod, "execute_tool", fake_execute)

    def _gate(tools_advertised, called_name, args):
        allowed = {
            (t.get("function") or {}).get("name")
            for t in (tools_advertised or [])
            if (t.get("function") or {}).get("name")
        }
        if allowed and called_name not in allowed:
            return "Error: tool '" + called_name + "' is not enabled"
        return fake_execute(called_name, args)

    out = _gate(
        [{"function": {"name": "mcp__srv__echo"}}],
        "terminal",
        {"command": "echo x"},
    )
    assert "not enabled" in out
    assert captured == []
    out = _gate(
        [{"function": {"name": "mcp__srv__echo"}}],
        "mcp__srv__echo",
        {"text": "hi"},
    )
    assert out == "executed"
    assert captured == ["mcp__srv__echo"]


def test_call_tool_sync_short_circuits_on_pre_set_cancel(monkeypatch):
    """A pre-set cancel_event must skip the HTTP request, not open a transport first."""
    from core.inference import mcp_client
    import threading

    opened: list[str] = []

    class _StubClient:
        async def __aenter__(self):
            opened.append("opened")
            return self

        async def __aexit__(self, *args):
            return False

        async def call_tool(
            self,
            name,
            args,
            raise_on_error = True,
        ):
            return "ran"

    monkeypatch.setattr(mcp_client, "_client", lambda *a, **kw: _StubClient())

    ev = threading.Event()
    ev.set()
    out = mcp_client.call_tool_sync(
        url = "https://example/mcp",
        headers = None,
        name = "x",
        args = {},
        timeout = 5.0,
        cancel_event = ev,
    )
    assert "cancelled" in out.lower()
    assert opened == []


def test_clear_oauth_tokens_swallows_constructor_errors(tmp_path, monkeypatch):
    """clear_oauth_tokens_async is best-effort; an OAuth constructor failure
    must not bubble into a 500 from the delete/update routes."""
    from core.inference import mcp_client
    import asyncio

    monkeypatch.setenv("UNSLOTH_STUDIO_HOME", str(tmp_path))
    monkeypatch.setattr(mcp_client, "_oauth_token_store", None)

    class _BoomOAuth:
        def __init__(self, *a, **kw):
            raise RuntimeError("simulated")

    import sys as _sys

    fake_mod = type(_sys)("fastmcp.client.auth")
    fake_mod.OAuth = _BoomOAuth
    monkeypatch.setitem(_sys.modules, "fastmcp.client.auth", fake_mod)
    asyncio.run(mcp_client.clear_oauth_tokens_async("https://x/mcp"))


def test_tool_xml_parser_handles_hyphenated_function_names():
    """Hyphenated tool names like `mcp__srv__list-issues` must parse, else the
    model can call the tool but Unsloth can't dispatch."""
    import json as _json

    from core.inference.tool_call_parser import parse_tool_calls_from_text

    calls = parse_tool_calls_from_text(
        "<function=mcp__srv__list-issues><parameter=repo>octocat/hello</parameter></function>"
    )
    assert len(calls) == 1
    assert calls[0]["function"]["name"] == "mcp__srv__list-issues"

    args = _json.loads(calls[0]["function"]["arguments"])
    assert args == {"repo": "octocat/hello"}


def test_tool_xml_strip_handles_hyphenated_function_names():
    """routes/inference.py:_TOOL_XML_RE must strip a `<function=name-with-dash>`
    block; else hyphenated MCP tool-call XML leaks into chat history."""
    import re as _re
    from pathlib import Path

    from core.inference.tool_call_parser import _DEEPSEEK_OPEN_RE_SRC as _DS_OPEN_SRC

    src = (Path(__file__).resolve().parent.parent / "routes/inference.py").read_text(
        encoding = "utf-8"
    )
    m = _re.search(r"_TOOL_XML_RE = _re\.compile\((.*?)\n\)", src, _re.DOTALL)
    assert m, "could not extract _TOOL_XML_RE"
    ns: dict = {"_re": _re, "_DS_OPEN_SRC": _DS_OPEN_SRC}
    exec(f"_TOOL_XML_RE = _re.compile({m.group(1)})", ns)
    rx = ns["_TOOL_XML_RE"]
    stripped = rx.sub(
        "",
        "before <function=mcp__srv__list-issues><parameter=q>x</parameter></function> after",
    )
    assert stripped == "before  after"


def test_safetensors_agentic_empty_allowlist_still_means_allow_all():
    """Contract: at the safetensors_agentic layer tools=[] means "no
    constraint". The MCP-only-no-discovery fix lives at the route level in
    inference.py, which refuses use_tools when the resolved list is empty."""
    import threading

    from core.inference.safetensors_agentic import run_safetensors_tool_loop

    calls: list[str] = []

    def fake_execute(name, args, **kw):
        calls.append(name)
        return "ran"

    iteration = {"n": 0}

    def fake_single_turn(messages):
        iteration["n"] += 1
        if iteration["n"] == 1:
            txt = '<tool_call>{"name":"python","arguments":{"code":"1"}}</tool_call>'
            buf = ""
            for ch in txt:
                buf += ch
                yield buf
        else:
            yield "done"

    list(
        run_safetensors_tool_loop(
            single_turn = fake_single_turn,
            messages = [{"role": "user", "content": "x"}],
            tools = [],
            execute_tool = fake_execute,
            cancel_event = threading.Event(),
            max_tool_iterations = 1,
        )
    )
    assert calls == [("python", {"code": "1"})] or len(calls) >= 1


def _one_tool(name = "echo"):
    return [{"name": name, "inputSchema": {"type": "object", "properties": {}}}]


def test_get_enabled_mcp_tools_caches_discovery(tmp_path, monkeypatch):
    """A second send must serve tools from cache instead of re-probing."""
    from core.inference import mcp_client
    from core.inference import tools as tools_mod
    import asyncio

    _reset_db(tmp_path, monkeypatch)

    monkeypatch.setattr(mcp_client, "_tool_cache", {})
    mcp_servers_db.create_server(id = "s1", display_name = "A", url = "https://x/mcp", is_enabled = True)

    calls: list[str] = []

    async def fake(
        url,
        headers = None,
        timeout = None,
        use_oauth = False,
    ):
        calls.append(url)
        return _one_tool()

    monkeypatch.setattr(tools_mod, "list_tools_async", fake)

    first = asyncio.run(tools_mod.get_enabled_mcp_tools())
    second = asyncio.run(tools_mod.get_enabled_mcp_tools())

    assert len(calls) == 1
    assert [t["function"]["name"] for t in first] == ["mcp__s1__echo"]
    assert first == second


def test_disabled_decision_api_hides_saved_decisions_tools(tmp_path, monkeypatch):
    from core.inference import mcp_client
    from core.inference import tools as tools_mod
    from utils import systemone_settings
    import asyncio

    _reset_db(tmp_path, monkeypatch)
    monkeypatch.setattr(mcp_client, "_tool_cache", {})
    mcp_servers_db.create_server(
        id = "decisions",
        display_name = "Unsloth Decisions",
        url = "http://127.0.0.1:8888/mcp/decisions/",
        is_enabled = True,
    )
    mcp_client.cache_tools("decisions", _one_tool("decide"))
    monkeypatch.setattr(systemone_settings, "get_enabled", lambda: False)

    assert tools_mod.cached_mcp_tools() == ([], True)
    assert asyncio.run(tools_mod.get_enabled_mcp_tools()) == []

    monkeypatch.setattr(systemone_settings, "get_enabled", lambda: True)
    cached, complete = tools_mod.cached_mcp_tools()
    assert complete is True
    assert [tool["function"]["name"] for tool in cached] == ["mcp__decisions__decide"]


def test_get_enabled_mcp_tools_does_not_cache_failures(tmp_path, monkeypatch):
    """A failed probe isn't cached: once the cool-off elapses, it's retried."""
    from core.inference import mcp_client
    from core.inference import tools as tools_mod
    import asyncio

    _reset_db(tmp_path, monkeypatch)

    monkeypatch.setattr(mcp_client, "_tool_cache", {})
    monkeypatch.setattr(mcp_client, "_probe_cooloff_until", {})
    mcp_servers_db.create_server(id = "s1", display_name = "A", url = "https://x/mcp", is_enabled = True)

    attempts = {"n": 0}

    async def fake(
        url,
        headers = None,
        timeout = None,
        use_oauth = False,
    ):
        attempts["n"] += 1
        if attempts["n"] == 1:
            raise RuntimeError("server down")
        return _one_tool()

    monkeypatch.setattr(tools_mod, "list_tools_async", fake)

    assert asyncio.run(tools_mod.get_enabled_mcp_tools()) == []
    mcp_client._probe_cooloff_until["s1"] = 0.0
    second = asyncio.run(tools_mod.get_enabled_mcp_tools())
    assert attempts["n"] == 2
    assert [t["function"]["name"] for t in second] == ["mcp__s1__echo"]


def test_refresh_warms_tool_cache(tmp_path, monkeypatch):
    """Clicking Refresh must populate the cache the chat path reads."""
    from core.inference import mcp_client
    from core.inference import tools as tools_mod
    import asyncio
    import routes.mcp_servers as routes_mcp

    _reset_db(tmp_path, monkeypatch)

    monkeypatch.setattr(mcp_client, "_tool_cache", {})
    mcp_servers_db.create_server(id = "s1", display_name = "A", url = "https://x/mcp", is_enabled = True)

    async def fake_refresh(
        url,
        headers = None,
        timeout = None,
        use_oauth = False,
    ):
        return _one_tool()

    monkeypatch.setattr(routes_mcp, "list_tools_async", fake_refresh)
    res = asyncio.run(routes_mcp.refresh_mcp_server_tools("s1", current_subject = "u"))
    assert res.ok and res.tool_count == 1

    def boom(*a, **k):
        raise AssertionError("chat path re-probed despite a warm cache")

    monkeypatch.setattr(tools_mod, "list_tools_async", boom)
    specs = asyncio.run(tools_mod.get_enabled_mcp_tools())
    assert [t["function"]["name"] for t in specs] == ["mcp__s1__echo"]


def test_update_url_evicts_tool_cache(tmp_path, monkeypatch):
    """Re-pointing the URL must drop the old endpoint's cached tools."""
    from core.inference import mcp_client
    from models.mcp_servers import McpServerUpdate
    import asyncio
    import routes.mcp_servers as routes_mcp

    _reset_db(tmp_path, monkeypatch)

    monkeypatch.setattr(mcp_client, "_tool_cache", {"s1": _one_tool("stale")})
    mcp_servers_db.create_server(id = "s1", display_name = "A", url = "https://old/mcp", is_enabled = True)

    asyncio.run(
        routes_mcp.update_mcp_server(
            "s1", McpServerUpdate(url = "https://new/mcp"), current_subject = "u"
        )
    )
    assert mcp_client.get_cached_tools("s1") is None


def test_update_display_name_keeps_tool_cache(tmp_path, monkeypatch):
    """A rename touches no endpoint, so the cache must survive it."""
    from core.inference import mcp_client
    from models.mcp_servers import McpServerUpdate
    import asyncio
    import routes.mcp_servers as routes_mcp

    _reset_db(tmp_path, monkeypatch)

    cached = _one_tool()
    monkeypatch.setattr(mcp_client, "_tool_cache", {"s1": cached})
    mcp_servers_db.create_server(id = "s1", display_name = "A", url = "https://x/mcp", is_enabled = True)

    asyncio.run(
        routes_mcp.update_mcp_server("s1", McpServerUpdate(display_name = "B"), current_subject = "u")
    )
    assert mcp_client.get_cached_tools("s1") == cached


def test_update_rename_keeps_stdio_session(tmp_path, monkeypatch):
    """The edit dialog resends url/headers/oauth on a rename, so only a real endpoint or auth change
    may close the live stdio session."""
    from models.mcp_servers import McpServerUpdate
    import asyncio
    import routes.mcp_servers as routes_mcp

    import json

    _reset_db(tmp_path, monkeypatch)

    closed: list = []
    monkeypatch.setattr(routes_mcp, "stdio_mcp_enabled", lambda: True)
    monkeypatch.setattr(routes_mcp, "close_mcp_sessions", lambda *a, **k: closed.append(a))
    mcp_servers_db.create_server(
        id = "s1",
        display_name = "A",
        url = "npx demo-server",
        headers_json = json.dumps({"API_KEY": "x"}),
        is_enabled = True,
    )
    asyncio.run(
        routes_mcp.update_mcp_server(
            "s1",
            McpServerUpdate(
                display_name = "B",
                url = "npx demo-server",
                headers = {"API_KEY": "x"},
                use_oauth = False,
            ),
            current_subject = "u",
        )
    )
    assert closed == []
    assert mcp_servers_db.get_server("s1")["display_name"] == "B"


def test_update_stdio_command_change_closes_session(tmp_path, monkeypatch):
    """A real command change must still close the old stdio session."""
    from models.mcp_servers import McpServerUpdate
    import asyncio
    import routes.mcp_servers as routes_mcp

    _reset_db(tmp_path, monkeypatch)

    closed: list = []
    monkeypatch.setattr(routes_mcp, "stdio_mcp_enabled", lambda: True)
    monkeypatch.setattr(routes_mcp, "close_mcp_sessions", lambda *a, **k: closed.append(a))
    mcp_servers_db.create_server(
        id = "s1",
        display_name = "A",
        url = "npx demo-server",
        is_enabled = True,
    )
    asyncio.run(
        routes_mcp.update_mcp_server(
            "s1", McpServerUpdate(url = "npx other-server"), current_subject = "u"
        )
    )
    assert len(closed) == 1


def test_stdio_arguments_update_preserves_untouched_bytes_then_invalidates_once(
    tmp_path, monkeypatch
):
    from core.inference import mcp_client
    from models.mcp_servers import McpServerUpdate
    from models.mcp_servers import McpStdioCommand, McpStdioDecodeRequest
    import asyncio
    import routes.mcp_servers as routes_mcp

    import json

    from models.mcp_servers import McpServerUpdate, McpStdioCommand

    _reset_db(tmp_path, monkeypatch)
    monkeypatch.setattr(routes_mcp, "stdio_mcp_enabled", lambda: True)
    invalidated: list[str] = []
    closed: list[tuple] = []
    monkeypatch.setattr(routes_mcp, "invalidate_tool_cache", invalidated.append)
    monkeypatch.setattr(routes_mcp, "close_mcp_sessions", lambda *args: closed.append(args))
    cached = _one_tool()
    monkeypatch.setattr(mcp_client, "_tool_cache", {"s1": cached})

    original_url = "python  -m mod"
    env = {"API_KEY": "secret"}
    mcp_servers_db.create_server(
        id = "s1",
        display_name = "A",
        url = original_url,
        headers_json = json.dumps(env),
        is_enabled = True,
    )
    asyncio.run(
        routes_mcp.update_mcp_server(
            "s1",
            McpServerUpdate(display_name = "B", url = original_url, headers = env),
            current_subject = "u",
        )
    )
    assert mcp_servers_db.get_server("s1")["url"] == original_url
    assert mcp_client.get_cached_tools("s1") == cached
    assert invalidated == []
    assert closed == []

    encoded = routes_mcp.encode_stdio_command(
        McpStdioCommand(command = "python", arguments = ["-m", "mod", "--name", "a b", ""]),
        current_subject = "u",
    )
    asyncio.run(
        routes_mcp.update_mcp_server("s1", McpServerUpdate(url = encoded.url), current_subject = "u")
    )
    assert mcp_servers_db.get_server("s1")["url"] == encoded.url
    assert mcp_client.parse_stdio_command(encoded.url) == [
        "python",
        "-m",
        "mod",
        "--name",
        "a b",
        "",
    ]
    assert invalidated == ["s1"]
    assert closed == [(original_url, env)]


def test_update_disable_evicts_tool_cache(tmp_path, monkeypatch):
    """Disabling a server must drop its cached tools, not leave them unread."""
    from core.inference import mcp_client
    from models.mcp_servers import McpServerUpdate
    import asyncio
    import routes.mcp_servers as routes_mcp

    _reset_db(tmp_path, monkeypatch)

    monkeypatch.setattr(mcp_client, "_tool_cache", {"s1": _one_tool()})
    mcp_servers_db.create_server(id = "s1", display_name = "A", url = "https://x/mcp", is_enabled = True)

    asyncio.run(
        routes_mcp.update_mcp_server("s1", McpServerUpdate(is_enabled = False), current_subject = "u")
    )
    assert mcp_client.get_cached_tools("s1") is None


def test_delete_evicts_tool_cache(tmp_path, monkeypatch):
    """Deleting a server must not leave its tools cached."""
    from core.inference import mcp_client
    import asyncio
    import routes.mcp_servers as routes_mcp

    _reset_db(tmp_path, monkeypatch)

    monkeypatch.setattr(mcp_client, "_tool_cache", {"s1": _one_tool()})
    mcp_servers_db.create_server(id = "s1", display_name = "A", url = "https://x/mcp", is_enabled = True)
    asyncio.run(routes_mcp.delete_mcp_server("s1", current_subject = "u"))
    assert mcp_client.get_cached_tools("s1") is None


def test_invalidate_tool_cache_clears_all(monkeypatch):
    from core.inference import mcp_client

    monkeypatch.setattr(mcp_client, "_tool_cache", {"a": _one_tool(), "b": _one_tool()})
    mcp_client.invalidate_tool_cache()
    assert mcp_client.get_cached_tools("a") is None
    assert mcp_client.get_cached_tools("b") is None


def test_get_enabled_mcp_tools_probes_only_uncached(tmp_path, monkeypatch):
    """An already-cached server must not be re-probed alongside a cold one."""
    from core.inference import mcp_client
    from core.inference import tools as tools_mod
    import asyncio

    _reset_db(tmp_path, monkeypatch)

    monkeypatch.setattr(mcp_client, "_tool_cache", {"s1": _one_tool("cached")})
    mcp_servers_db.create_server(id = "s1", display_name = "A", url = "https://a/mcp", is_enabled = True)
    mcp_servers_db.create_server(id = "s2", display_name = "B", url = "https://b/mcp", is_enabled = True)

    probed: list[str] = []

    async def fake(
        url,
        headers = None,
        timeout = None,
        use_oauth = False,
    ):
        probed.append(url)
        return _one_tool("fresh")

    monkeypatch.setattr(tools_mod, "list_tools_async", fake)

    specs = asyncio.run(tools_mod.get_enabled_mcp_tools())
    assert probed == ["https://b/mcp"]
    assert sorted(t["function"]["name"] for t in specs) == ["mcp__s1__cached", "mcp__s2__fresh"]


def test_get_enabled_mcp_tools_partial_failure_caches_healthy(tmp_path, monkeypatch):
    """One server failing must not stop the others from being cached/served."""
    from core.inference import mcp_client
    from core.inference import tools as tools_mod
    import asyncio

    _reset_db(tmp_path, monkeypatch)

    monkeypatch.setattr(mcp_client, "_tool_cache", {})
    monkeypatch.setattr(mcp_client, "_probe_cooloff_until", {})
    mcp_servers_db.create_server(id = "s1", display_name = "A", url = "https://bad/mcp", is_enabled = True)
    mcp_servers_db.create_server(id = "s2", display_name = "B", url = "https://good/mcp", is_enabled = True)

    async def fake(
        url,
        headers = None,
        timeout = None,
        use_oauth = False,
    ):
        if "bad" in url:
            raise RuntimeError("down")
        return _one_tool("ok")

    monkeypatch.setattr(tools_mod, "list_tools_async", fake)

    specs = asyncio.run(tools_mod.get_enabled_mcp_tools())
    assert [t["function"]["name"] for t in specs] == ["mcp__s2__ok"]
    assert mcp_client.get_cached_tools("s1") is None
    assert mcp_client.get_cached_tools("s2") == _one_tool("ok")


def test_get_enabled_mcp_tools_caches_empty_tool_list(tmp_path, monkeypatch):
    """A server exposing zero tools is cached as [] (a hit), not re-probed."""
    from core.inference import mcp_client
    from core.inference import tools as tools_mod
    import asyncio

    _reset_db(tmp_path, monkeypatch)

    monkeypatch.setattr(mcp_client, "_tool_cache", {})
    mcp_servers_db.create_server(id = "s1", display_name = "A", url = "https://x/mcp", is_enabled = True)

    calls: list[str] = []

    async def fake(
        url,
        headers = None,
        timeout = None,
        use_oauth = False,
    ):
        calls.append(url)
        return []

    monkeypatch.setattr(tools_mod, "list_tools_async", fake)

    assert asyncio.run(tools_mod.get_enabled_mcp_tools()) == []
    assert asyncio.run(tools_mod.get_enabled_mcp_tools()) == []
    assert len(calls) == 1
    assert mcp_client.get_cached_tools("s1") == []


def test_update_headers_evicts_tool_cache(tmp_path, monkeypatch):
    """Changing auth headers must drop tools discovered under the old headers."""
    from core.inference import mcp_client
    from models.mcp_servers import McpServerUpdate
    import asyncio
    import routes.mcp_servers as routes_mcp

    _reset_db(tmp_path, monkeypatch)

    monkeypatch.setattr(mcp_client, "_tool_cache", {"s1": _one_tool()})
    mcp_servers_db.create_server(id = "s1", display_name = "A", url = "https://x/mcp", is_enabled = True)

    asyncio.run(
        routes_mcp.update_mcp_server(
            "s1",
            McpServerUpdate(headers = {"Authorization": "Bearer new"}),
            current_subject = "u",
        )
    )
    assert mcp_client.get_cached_tools("s1") is None


def test_get_enabled_mcp_tools_skips_cache_when_config_changes_mid_probe(tmp_path, monkeypatch):
    """A config edit during a probe must not be clobbered by the stale probe result (a race)."""
    from core.inference import mcp_client
    from core.inference import tools as tools_mod
    import asyncio

    _reset_db(tmp_path, monkeypatch)

    monkeypatch.setattr(mcp_client, "_tool_cache", {})
    mcp_servers_db.create_server(id = "s1", display_name = "A", url = "https://old/mcp", is_enabled = True)

    async def fake(
        url,
        headers = None,
        timeout = None,
        use_oauth = False,
    ):
        mcp_servers_db.update_server("s1", {"url": "https://new/mcp"})
        return _one_tool()

    monkeypatch.setattr(tools_mod, "list_tools_async", fake)

    specs = asyncio.run(tools_mod.get_enabled_mcp_tools())
    assert specs == []
    assert mcp_client.get_cached_tools("s1") is None


def test_get_enabled_mcp_tools_no_cooloff_when_config_changes_mid_failed_probe(
    tmp_path, monkeypatch
):
    """An edit made while a probe of the old config fails must not park a cool-off on the new
    config, which would skip the fixed server."""
    from core.inference import mcp_client
    from core.inference import tools as tools_mod
    import asyncio

    _reset_db(tmp_path, monkeypatch)

    monkeypatch.setattr(mcp_client, "_tool_cache", {})
    monkeypatch.setattr(mcp_client, "_probe_cooloff_until", {})
    mcp_servers_db.create_server(id = "s1", display_name = "A", url = "https://old/mcp", is_enabled = True)

    async def fake(
        url,
        headers = None,
        timeout = None,
        use_oauth = False,
    ):
        mcp_servers_db.update_server("s1", {"url": "https://new/mcp"})
        raise RuntimeError("old endpoint down")

    monkeypatch.setattr(tools_mod, "list_tools_async", fake)

    assert asyncio.run(tools_mod.get_enabled_mcp_tools()) == []
    assert not mcp_client.in_failure_cooloff("s1")


def test_get_enabled_mcp_tools_no_cooloff_when_server_deleted_mid_failed_probe(
    tmp_path, monkeypatch
):
    """A delete during a failing probe must not leave an orphan cool-off for the removed id."""
    from core.inference import mcp_client
    from core.inference import tools as tools_mod
    import asyncio

    _reset_db(tmp_path, monkeypatch)

    monkeypatch.setattr(mcp_client, "_tool_cache", {})
    monkeypatch.setattr(mcp_client, "_probe_cooloff_until", {})
    mcp_servers_db.create_server(id = "s1", display_name = "A", url = "https://x/mcp", is_enabled = True)

    async def fake(
        url,
        headers = None,
        timeout = None,
        use_oauth = False,
    ):
        mcp_servers_db.delete_server("s1")
        raise RuntimeError("down")

    monkeypatch.setattr(tools_mod, "list_tools_async", fake)

    assert asyncio.run(tools_mod.get_enabled_mcp_tools()) == []
    assert "s1" not in mcp_client._probe_cooloff_until


def test_get_enabled_mcp_tools_skips_failed_server_during_cooloff(tmp_path, monkeypatch):
    """A down server is probed once, then skipped during the cool-off, not re-hung per send."""
    from core.inference import mcp_client
    from core.inference import tools as tools_mod
    import asyncio

    _reset_db(tmp_path, monkeypatch)

    monkeypatch.setattr(mcp_client, "_tool_cache", {})
    monkeypatch.setattr(mcp_client, "_probe_cooloff_until", {})
    mcp_servers_db.create_server(id = "s1", display_name = "A", url = "https://x/mcp", is_enabled = True)

    attempts = {"n": 0}

    async def fake(
        url,
        headers = None,
        timeout = None,
        use_oauth = False,
    ):
        attempts["n"] += 1
        raise RuntimeError("down")

    monkeypatch.setattr(tools_mod, "list_tools_async", fake)

    assert asyncio.run(tools_mod.get_enabled_mcp_tools()) == []
    assert asyncio.run(tools_mod.get_enabled_mcp_tools()) == []
    assert asyncio.run(tools_mod.get_enabled_mcp_tools()) == []
    assert attempts["n"] == 1


def test_cache_tools_clears_failure_cooloff(monkeypatch):
    """A successful probe lifts a server's failure cool-off."""
    from core.inference import mcp_client

    monkeypatch.setattr(mcp_client, "_tool_cache", {})
    monkeypatch.setattr(mcp_client, "_probe_cooloff_until", {})
    mcp_client.record_probe_failure("s1")
    assert mcp_client.in_failure_cooloff("s1")
    mcp_client.cache_tools("s1", _one_tool())
    assert not mcp_client.in_failure_cooloff("s1")


def test_oauth_failure_cools_off_longer_than_plain(monkeypatch):
    """An OAuth server's failure cools off longer than a plain server's, so its
    multi-minute probe hang doesn't recur every minute."""
    from core.inference import mcp_client

    monkeypatch.setattr(mcp_client, "_probe_cooloff_until", {})
    mcp_client.record_probe_failure("plain", use_oauth = False)
    mcp_client.record_probe_failure("oauth", use_oauth = True)
    assert mcp_client._probe_cooloff_until["oauth"] > mcp_client._probe_cooloff_until["plain"]


def test_invalidate_clears_failure_cooloff(monkeypatch):
    """Eviction drops the failure cool-off so an edited server re-probes at once."""
    from core.inference import mcp_client

    monkeypatch.setattr(mcp_client, "_tool_cache", {})
    monkeypatch.setattr(mcp_client, "_probe_cooloff_until", {"s1": 1.0, "s2": 2.0})
    mcp_client.invalidate_tool_cache("s1")
    assert "s1" not in mcp_client._probe_cooloff_until
    assert "s2" in mcp_client._probe_cooloff_until
    mcp_client.invalidate_tool_cache()
    assert mcp_client._probe_cooloff_until == {}


def test_refresh_failure_records_cooloff(tmp_path, monkeypatch):
    """A failed manual refresh starts the cool-off so the next chat send does not hang."""
    from core.inference import mcp_client
    import asyncio
    import routes.mcp_servers as routes_mcp

    _reset_db(tmp_path, monkeypatch)

    monkeypatch.setattr(mcp_client, "_tool_cache", {})
    monkeypatch.setattr(mcp_client, "_probe_cooloff_until", {})
    mcp_servers_db.create_server(id = "s1", display_name = "A", url = "https://x/mcp", is_enabled = True)

    async def boom(
        url,
        headers = None,
        timeout = None,
        use_oauth = False,
    ):
        raise RuntimeError("down")

    monkeypatch.setattr(routes_mcp, "list_tools_async", boom)
    res = asyncio.run(routes_mcp.refresh_mcp_server_tools("s1", current_subject = "u"))
    assert res.ok is False
    assert mcp_client.in_failure_cooloff("s1")


def test_refresh_drops_result_when_config_changes_mid_probe(tmp_path, monkeypatch):
    """A refresh must not cache tools from an old config if the server is edited mid-probe."""
    from core.inference import mcp_client
    import asyncio
    import routes.mcp_servers as routes_mcp

    _reset_db(tmp_path, monkeypatch)

    monkeypatch.setattr(mcp_client, "_tool_cache", {})
    mcp_servers_db.create_server(id = "s1", display_name = "A", url = "https://old/mcp", is_enabled = True)

    async def fake_refresh(
        url,
        headers = None,
        timeout = None,
        use_oauth = False,
    ):
        mcp_servers_db.update_server("s1", {"url": "https://new/mcp"})
        return _one_tool("stale")

    monkeypatch.setattr(routes_mcp, "list_tools_async", fake_refresh)
    res = asyncio.run(routes_mcp.refresh_mcp_server_tools("s1", current_subject = "u"))
    assert res.ok and res.tool_count == 1
    assert mcp_client.get_cached_tools("s1") is None


def test_refresh_failure_no_cooloff_when_config_changes_mid_probe(tmp_path, monkeypatch):
    """A refresh failure for an old config must not cool off the freshly edited server."""
    from core.inference import mcp_client
    import asyncio
    import routes.mcp_servers as routes_mcp

    _reset_db(tmp_path, monkeypatch)

    monkeypatch.setattr(mcp_client, "_tool_cache", {})
    monkeypatch.setattr(mcp_client, "_probe_cooloff_until", {})
    mcp_servers_db.create_server(id = "s1", display_name = "A", url = "https://old/mcp", is_enabled = True)

    async def boom(
        url,
        headers = None,
        timeout = None,
        use_oauth = False,
    ):
        mcp_servers_db.update_server("s1", {"url": "https://new/mcp"})
        raise RuntimeError("old endpoint down")

    monkeypatch.setattr(routes_mcp, "list_tools_async", boom)
    res = asyncio.run(routes_mcp.refresh_mcp_server_tools("s1", current_subject = "u"))
    assert res.ok is False
    assert not mcp_client.in_failure_cooloff("s1")


def test_get_enabled_mcp_tools_drops_result_when_server_deleted_mid_probe(tmp_path, monkeypatch):
    """A delete during a probe must drop the orphan result (the `fresh is None` arm of the mid-probe
    TOCTOU guard), which is neither served nor cached."""
    from core.inference import mcp_client
    from core.inference import tools as tools_mod
    import asyncio

    _reset_db(tmp_path, monkeypatch)

    monkeypatch.setattr(mcp_client, "_tool_cache", {})
    monkeypatch.setattr(mcp_client, "_probe_cooloff_until", {})
    mcp_servers_db.create_server(id = "s1", display_name = "A", url = "https://x/mcp", is_enabled = True)

    async def fake(
        url,
        headers = None,
        timeout = None,
        use_oauth = False,
    ):
        mcp_servers_db.delete_server("s1")
        return _one_tool()

    monkeypatch.setattr(tools_mod, "list_tools_async", fake)

    specs = asyncio.run(tools_mod.get_enabled_mcp_tools())
    assert specs == []
    assert mcp_client.get_cached_tools("s1") is None


def test_oauth_probe_failure_in_chat_path_uses_long_cooloff(tmp_path, monkeypatch):
    """An OAuth server failing discovery in chat must record the long OAuth cool-off, not the plain
    one, or its browser hang recurs every minute."""
    from core.inference import mcp_client
    from core.inference import tools as tools_mod
    import asyncio

    import time

    _reset_db(tmp_path, monkeypatch)

    monkeypatch.setattr(mcp_client, "_tool_cache", {})
    monkeypatch.setattr(mcp_client, "_probe_cooloff_until", {})
    mcp_servers_db.create_server(
        id = "s1",
        display_name = "A",
        url = "https://x/mcp",
        is_enabled = True,
        use_oauth = True,
    )

    async def boom(
        url,
        headers = None,
        timeout = None,
        use_oauth = False,
    ):
        raise RuntimeError("oauth down")

    monkeypatch.setattr(tools_mod, "list_tools_async", boom)

    assert asyncio.run(tools_mod.get_enabled_mcp_tools()) == []
    assert mcp_client.in_failure_cooloff("s1")
    remaining = mcp_client._probe_cooloff_until["s1"] - time.monotonic()
    assert remaining > mcp_client.FAILED_PROBE_COOLOFF_SECONDS


def test_status_for_tool_uses_mcp_display_name(tmp_path, monkeypatch):
    _reset_db(tmp_path, monkeypatch)
    mcp_servers_db.create_server(id = "srv1", display_name = "GitHub", url = "https://a/m")
    from core.inference.tool_loop_controller import status_for_tool

    assert status_for_tool("mcp__srv1__create_issue", {}) == "Calling: GitHub · create_issue"


def test_status_for_tool_unknown_mcp_server_keeps_raw_name(tmp_path, monkeypatch):
    _reset_db(tmp_path, monkeypatch)
    from core.inference.tool_loop_controller import status_for_tool
    assert status_for_tool("mcp__missing__x", {}) == "Calling: mcp__missing__x"


def test_awaiting_approval_status_uses_mcp_display_name(tmp_path, monkeypatch):
    _reset_db(tmp_path, monkeypatch)
    mcp_servers_db.create_server(id = "srv1", display_name = "GitHub", url = "https://a/m")
    from core.inference.tool_loop_controller import awaiting_approval_status

    assert (
        awaiting_approval_status("mcp__srv1__create_issue")
        == "Waiting for approval: GitHub · create_issue"
    )


def test_prepare_call_stamps_mcp_server_provenance(tmp_path, monkeypatch):
    _reset_db(tmp_path, monkeypatch)
    mcp_servers_db.create_server(id = "srv1", display_name = "GitHub", url = "https://a/m")
    from core.inference.tool_loop_controller import ToolLoopController

    controller = ToolLoopController(tools = None)
    decision = controller.prepare_call(
        {"function": {"name": "mcp__srv1__create_issue", "arguments": {}}}
    )
    assert decision.provenance["mcp_server"] == "GitHub"

    plain = controller.prepare_call({"function": {"name": "python", "arguments": {}}})
    assert "mcp_server" not in plain.provenance


def test_provisional_tool_provenance_stamps_mcp_display_name(tmp_path, monkeypatch):
    _reset_db(tmp_path, monkeypatch)
    mcp_servers_db.create_server(id = "srv1", display_name = "GitHub", url = "https://a/m")
    from core.inference.tool_loop_controller import provisional_tool_provenance

    prov = provisional_tool_provenance("mcp__srv1__create_issue")
    assert prov["provisional"] is True
    assert prov["mcp_server"] == "GitHub"

    assert "mcp_server" not in provisional_tool_provenance("python")
    assert "mcp_server" not in provisional_tool_provenance("mcp__missing__x")


def test_display_names_never_reach_the_callable_tool_name(tmp_path, monkeypatch):
    """Routing, approvals and replay key off mcp__<serverId>__<tool>, never a display name."""
    from core.inference.tools import _mcp_specs_for_server

    _reset_db(tmp_path, monkeypatch)
    mcp_servers_db.create_server(id = "srv1", display_name = "GitHub", url = "https://a/m")
    from core.inference.tool_loop_controller import (
        mcp_display_parts,
        provisional_tool_provenance,
    )

    specs = _mcp_specs_for_server(
        {"id": "srv1", "display_name": "GitHub"}, [{"name": "create_issue"}]
    )
    assert specs[0]["function"]["name"] == "mcp__srv1__create_issue"
    assert "GitHub" in specs[0]["function"]["description"]
    assert provisional_tool_provenance("mcp__srv1__create_issue")["mcp_server"] == "GitHub"
    assert mcp_display_parts("mcp__srv1__create_issue") == ("GitHub", "create_issue")


def test_two_servers_sharing_a_display_name_stay_separately_routable(tmp_path, monkeypatch):
    """Duplicate display names must not collapse two servers into one route."""
    from core.inference.tools import _mcp_specs_for_server

    _reset_db(tmp_path, monkeypatch)
    for sid in ("srv1", "srv2"):
        mcp_servers_db.create_server(id = sid, display_name = "GitHub", url = f"https://{sid}/m")

    names = {
        _mcp_specs_for_server({"id": sid, "display_name": "GitHub"}, [{"name": "run"}])[0][
            "function"
        ]["name"]
        for sid in ("srv1", "srv2")
    }
    assert names == {"mcp__srv1__run", "mcp__srv2__run"}


@pytest.mark.parametrize(
    "display",
    ["line\nbreak", "**bold**", "<script>", "‮gnitseT", "x" * 1000],
)
def test_adversarial_display_names_do_not_break_provenance(tmp_path, monkeypatch, display):
    _reset_db(tmp_path, monkeypatch)
    mcp_servers_db.create_server(id = "srv1", display_name = display, url = "https://a/m")
    from core.inference.tool_loop_controller import provisional_tool_provenance

    assert provisional_tool_provenance("mcp__srv1__run")["mcp_server"] == display


def _big_mcp_tool():
    return {
        "name": "query",
        "description": "Query rows. Use SQL mode by default.\nLong details follow.",
        "inputSchema": {
            "type": "object",
            "properties": {
                "data": {
                    "anyOf": [
                        {
                            "type": "object",
                            "properties": {"q": {"type": "string", "description": "x" * 900}},
                        },
                        {"type": "object"},
                    ]
                },
                "mode": {"type": "string", "enum": ["sql", "rows"], "description": "y" * 800},
                "tags": {"type": "array", "items": {"type": "string"}},
            },
            "required": ["data"],
        },
    }


def _cache_server_tools(tmp_path, monkeypatch, tools):
    from core.inference import mcp_client, tools as tools_mod

    _reset_db(tmp_path, monkeypatch)
    monkeypatch.setattr(mcp_client, "_tool_cache", {})
    monkeypatch.setattr(tools_mod, "_MCP_LOADED_THREADS", OrderedDict())
    monkeypatch.setattr(tools_mod, "_MCP_HELD_THREADS", OrderedDict())
    mcp_servers_db.create_server(id = "srv1", display_name = "A", url = "https://a.example/mcp")
    mcp_client.cache_tools("srv1", tools)


@pytest.fixture
def listing_window():
    from core.inference import tools as tools_mod

    tokens = []

    def _set(context_tokens):
        tokens.append(tools_mod._MCP_LISTING_CONTEXT_TOKENS.set(context_tokens))
        return context_tokens

    yield _set
    for token in reversed(tokens):
        tools_mod._MCP_LISTING_CONTEXT_TOKENS.reset(token)


@pytest.fixture
def searching(monkeypatch, listing_window):
    from core.inference import tools as tools_mod
    monkeypatch.setattr(tools_mod, "_MCP_TOOL_SEARCH_SHARE", 0.0)
    return listing_window(100_000)


_PING = {
    "name": "ping",
    "description": "Ping. Returns pong.",
    "inputSchema": {
        "type": "object",
        "properties": {"n": {"type": "integer", "description": "count"}},
    },
}


def _names(specs):
    return [s["function"]["name"] for s in specs]


def _search_spec(specs):
    return next(s for s in specs if s["function"]["name"] == "mcp_tool_search")


def test_mcp_listing_stays_full_when_it_fits_the_window(tmp_path, monkeypatch, listing_window):
    from core.inference import tools as tools_mod

    _cache_server_tools(tmp_path, monkeypatch, [_PING, _big_mcp_tool()])
    unsized = tools_mod.cached_mcp_tools()[0]
    assert _names(unsized) == ["mcp__srv1__ping", "mcp__srv1__query"]
    assert unsized[1]["function"]["parameters"] == _big_mcp_tool()["inputSchema"]

    listing_window(1_000_000)
    assert tools_mod.cached_mcp_tools()[0] == unsized

    listing_window(1_000)
    specs = tools_mod.cached_mcp_tools()[0]
    assert _names(specs) == ["mcp_tool_search"]
    # Too small to name them within its share, so it only counts them.
    assert _search_spec(specs)["function"]["description"].endswith(
        "Tools:\n2 tools, found by searching."
    )


def test_mcp_listing_defers_every_tool_past_its_share(tmp_path, monkeypatch, listing_window):
    from core.inference import mcp_client, tools as tools_mod

    huge = dict(_big_mcp_tool(), name = "huge")
    huge["inputSchema"] = dict(huge["inputSchema"], description = "z" * 20_000)
    _cache_server_tools(tmp_path, monkeypatch, [_PING, _big_mcp_tool(), huge])
    mcp_servers_db.create_server(id = "srv2", display_name = "B", url = "https://b.example/mcp")
    mcp_client.cache_tools("srv2", [{"name": "echo"}])
    full = tools_mod.cached_mcp_tools()[0]
    full_tokens = tools_mod._text_token_cost(json.dumps(full, separators = (",", ":")), 10_000)

    # Over the share by a little: the small tools are deferred too, so none is called in place of a deferred one.
    listing_window(int(full_tokens * 0.9 / tools_mod._MCP_TOOL_SEARCH_SHARE))
    specs = tools_mod.cached_mcp_tools()[0]
    assert _names(specs) == ["mcp_tool_search"]
    assert _search_spec(specs)["function"]["description"].endswith(
        "Tools:\nA:\n- ping: Ping.\n- query: Query rows.\n- huge: Query rows.\nB:\n- echo"
    )
    listing_window(int(full_tokens * 1.1 / tools_mod._MCP_TOOL_SEARCH_SHARE))
    assert tools_mod.cached_mcp_tools()[0] == full


def test_mcp_tool_search_lists_a_bounded_number_of_names(monkeypatch):
    from core.inference import tools as tools_mod

    monkeypatch.setattr(tools_mod, "_MCP_TOOL_SEARCH_MAX_NAMES", 2)
    spec = tools_mod._mcp_tool_search_spec(
        [("A", [("a", "Does a."), ("b", ""), ("c", "")]), ("B", [("d", "")])]
    )
    assert spec["function"]["description"].endswith(
        "Tools:\nA:\n- a: Does a.\n- b\n- and 1 more\nB:\n- and 1 more"
    )


def test_mcp_summary_caps_a_description_without_a_sentence_end():
    from core.inference.tools import _mcp_summary

    assert _mcp_summary("  Fetch a page\n by id.  Then more. ") == "Fetch a page by id."
    assert _mcp_summary("## Overview\n\nCreates pages. Details.") == "Overview Creates pages."
    long = _mcp_summary("word " * 100)
    assert len(long) == 240 and long.endswith("...")


def test_mcp_tool_lists_offer_the_search_tool_only_when_something_was_deferred(
    tmp_path, monkeypatch, searching
):
    import asyncio

    from core.inference import mcp_client, tools as tools_mod

    _cache_server_tools(tmp_path, monkeypatch, [])
    assert tools_mod.cached_mcp_tools() == ([], True)

    mcp_client.cache_tools("srv1", [{"name": "ping"}, _big_mcp_tool()])
    names = _names(tools_mod.cached_mcp_tools()[0])
    assert names == ["mcp_tool_search"]
    assert _names(asyncio.run(tools_mod.get_enabled_mcp_tools())) == names


_NOTES = [
    _PING,
    _big_mcp_tool(),
    {"name": "create-pages", "description": "Create one or more pages in a workspace."},
    {"name": "move-pages", "description": "Move pages to a new parent page."},
    {"name": "get-users", "description": "List the users in the workspace."},
]


def test_mcp_tool_search_loads_exact_names_then_ranked_matches(tmp_path, monkeypatch):
    from core.inference import tools as tools_mod

    _cache_server_tools(tmp_path, monkeypatch, _NOTES)
    search = tools_mod.mcp_tool_search_specs

    assert _names(search({"query": "mcp__srv1__query"})) == ["mcp__srv1__query"]
    assert _names(search({"query": "move-pages, get-users"})) == [
        "mcp__srv1__move-pages",
        "mcp__srv1__get-users",
    ]
    assert _names(search({"query": "create a new page"}))[0] == "mcp__srv1__create-pages"
    assert _names(search({"query": "move my page under another parent", "limit": 1})) == [
        "mcp__srv1__move-pages"
    ]
    assert _names(search({"query": "who are the users"})) == ["mcp__srv1__get-users"]
    # An exact name loads whatever the ranked matches are (openai/codex#21503).
    assert _names(search({"query": "ping and the users", "limit": 1})) == ["mcp__srv1__ping"]
    assert search({"query": "  "}) == search({}) == []

    out = tools_mod.execute_tool("mcp_tool_search", {"query": "query rows with sql"})
    assert out.startswith("Loaded 1 MCP tool. Call the one that fits directly")
    assert "- mcp__srv1__query: [A] Query rows." in out
    assert (
        "schema: " + json.dumps(tools_mod.mcp_tool_spec("mcp__srv1__query"), separators = (",", ":"))
        in out
    )
    assert tools_mod.execute_tool("mcp_tool_search", {"query": "zzzz"}).startswith(
        "No MCP tool matched 'zzzz'."
    )
    assert tools_mod.execute_tool("mcp_tool_search", {}).startswith(
        "Error: mcp_tool_search needs a query"
    )
    assert not tools_mod.is_potentially_unsafe_tool_call("mcp_tool_search", {"query": "x"})
    assert not tools_mod.is_high_risk_tool_call("mcp_tool_search", {"query": "x"})


def test_mcp_listing_lists_the_tools_the_user_message_asks_for(tmp_path, monkeypatch, searching):
    import contextvars

    from core.inference import tools as tools_mod

    _cache_server_tools(tmp_path, monkeypatch, _NOTES)

    def listing_for(messages, thread_id = None):
        ctx = contextvars.copy_context()
        ctx.run(tools_mod.set_mcp_listing_context_tokens, searching, thread_id, messages)
        return ctx.run(lambda: _names(tools_mod.cached_mcp_tools()[0]))

    ask = [{"role": "user", "content": "Move my roadmap page under the Archive page."}]
    listed = listing_for(ask)
    assert listed[:2] == ["mcp_tool_search", "mcp__srv1__move-pages"]
    assert len(listed) <= 1 + tools_mod._MCP_TOOL_PRELOAD
    assert listing_for([{"role": "user", "content": "hello"}]) == ["mcp_tool_search"]
    # Nothing ranked fits a window this small, so only the search tool is listed.
    monkeypatch.setattr(tools_mod, "_MCP_TOOL_PRELOAD_SHARE", 0.0)
    assert listing_for(ask) == ["mcp_tool_search"]


def _thread_listing(tools_mod, searching, messages):
    import contextvars

    ctx = contextvars.copy_context()
    ctx.run(tools_mod.set_mcp_listing_context_tokens, searching, "thread-1", messages)
    return ctx.run(lambda: tools_mod.cached_mcp_tools()[0])


def test_mcp_listing_holds_while_the_best_match_stays_listed(tmp_path, monkeypatch, searching):
    from core.inference import tools as tools_mod

    _cache_server_tools(tmp_path, monkeypatch, _NOTES)
    rankings = {"first": [0, 1], "second": [0, 2]}
    monkeypatch.setattr(tools_mod, "_mcp_ranked", lambda specs, query: (rankings[query], 0))

    first = _thread_listing(tools_mod, searching, [{"role": "user", "content": "first"}])
    second = _thread_listing(tools_mod, searching, [{"role": "user", "content": "second"}])

    assert len(_names(first)) > 1 and second == first


def test_mcp_listing_lists_a_best_match_that_did_not_fit_before(tmp_path, monkeypatch, searching):
    from core.inference import tools as tools_mod

    _cache_server_tools(tmp_path, monkeypatch, _NOTES)
    real_cost = tools_mod._text_token_cost

    def cost(text, ctx):
        if '"name":"mcp_tool_search"' in text:
            return 0
        return 100 if text.startswith("{") else real_cost(text, ctx)

    monkeypatch.setattr(tools_mod, "_text_token_cost", cost)
    monkeypatch.setattr(tools_mod, "_MCP_TOOL_PRELOAD_SHARE", 150 / searching)
    rankings = {"first": [0, 1], "second": [1, 0]}
    seen = []

    def ranked(specs, query):
        seen[:] = [spec["function"]["name"] for spec in specs]
        return rankings[query], 0

    monkeypatch.setattr(tools_mod, "_mcp_ranked", ranked)

    first = _thread_listing(tools_mod, searching, [{"role": "user", "content": "first"}])
    assert seen[0] in _names(first) and seen[1] not in _names(first)
    second = _thread_listing(tools_mod, searching, [{"role": "user", "content": "second"}])
    assert seen[1] in _names(second)


@pytest.mark.parametrize("how", ["forced", "ran"])
def test_mcp_listing_ranks_the_first_message_when_its_best_match_is_listed(
    tmp_path, monkeypatch, searching, how
):
    import contextvars

    from core.inference import tools as tools_mod

    _cache_server_tools(tmp_path, monkeypatch, _NOTES)
    best = "mcp__srv1__move-pages"
    other = []

    def ranked(specs, query):
        names = [spec["function"]["name"] for spec in specs]
        first = names.index(best)
        second = 0 if first else 1
        other[:] = [names[second]]
        return [first, second], 0

    monkeypatch.setattr(tools_mod, "_mcp_ranked", ranked)
    choice = None
    if how == "forced":
        choice = {"type": "function", "function": {"name": best}}
    else:
        tools_mod.mcp_record_loaded_tools("thread-1", [best])
    ctx = contextvars.copy_context()
    ctx.run(
        tools_mod.set_mcp_listing_context_tokens,
        searching,
        "thread-1",
        [{"role": "user", "content": "move it"}],
        choice,
    )
    names = _names(ctx.run(lambda: tools_mod.cached_mcp_tools()[0]))

    assert best in names and other[0] in names


def test_mcp_listing_lists_a_tool_a_later_message_needs(tmp_path, monkeypatch, searching):
    from core.inference import tools as tools_mod

    _cache_server_tools(tmp_path, monkeypatch, _NOTES)
    chat = [{"role": "user", "content": "hello"}]
    assert "mcp__srv1__move-pages" not in _names(_thread_listing(tools_mod, searching, chat))
    chat += [
        {"role": "assistant", "content": "Hi."},
        {"role": "user", "content": "Move my roadmap page under the Archive page."},
    ]
    assert "mcp__srv1__move-pages" in _names(_thread_listing(tools_mod, searching, chat))


def test_mcp_listing_reranks_when_no_held_tool_still_fits(tmp_path, monkeypatch, searching):
    from core.inference import tools as tools_mod

    _cache_server_tools(tmp_path, monkeypatch, _NOTES)
    sizes = {"ping": 100, "create-pages": 60, "move-pages": 40}
    real_cost = tools_mod._text_token_cost

    def cost(text, ctx):
        if '"name":"mcp_tool_search"' in text:
            return 0
        for name, size in sizes.items():
            if text.startswith("{") and f'"name":"mcp__srv1__{name}"' in text:
                return size
        return 1000 if text.startswith("{") else real_cost(text, ctx)

    monkeypatch.setattr(tools_mod, "_text_token_cost", cost)
    monkeypatch.setattr(tools_mod, "_MCP_TOOL_PRELOAD_SHARE", 110 / searching)
    held, ran, best = (f"mcp__srv1__{name}" for name in sizes)
    rankings = {"first": [held], "second": [ran, best]}

    def ranked(specs, query):
        names = [spec["function"]["name"] for spec in specs]
        return [names.index(name) for name in rankings[query]], 0

    monkeypatch.setattr(tools_mod, "_mcp_ranked", ranked)

    assert held in _names(
        _thread_listing(tools_mod, searching, [{"role": "user", "content": "first"}])
    )
    tools_mod.mcp_record_loaded_tools("thread-1", [ran])
    chat = [{"role": "user", "content": "second"}]
    second = _thread_listing(tools_mod, searching, chat)
    assert _names(second) == ["mcp_tool_search", ran, best]
    assert _thread_listing(tools_mod, searching, chat) == second


def test_mcp_listing_keeps_its_order_when_a_listed_tool_runs(tmp_path, monkeypatch, searching):
    from core.inference import tools as tools_mod

    _cache_server_tools(tmp_path, monkeypatch, _NOTES)
    ping, create, move = (f"mcp__srv1__{name}" for name in ("ping", "create-pages", "move-pages"))
    names = [spec["function"]["name"] for spec in tools_mod._cached_mcp_catalog()]
    monkeypatch.setattr(
        tools_mod, "_mcp_ranked", lambda specs, query: ([names.index(ping), names.index(create)], 0)
    )
    chat = [{"role": "user", "content": "first"}]
    first = _thread_listing(tools_mod, searching, chat)
    assert _names(first) == ["mcp_tool_search", ping, create]

    for ran in ([create], [ping], [create, ping]):
        tools_mod.mcp_record_loaded_tools("thread-1", ran)
        assert _thread_listing(tools_mod, searching, chat) == first

    tools_mod.mcp_record_loaded_tools("thread-1", [move])
    assert _names(_thread_listing(tools_mod, searching, chat)) == [*_names(first), move]


def test_mcp_listing_token_count_leaves_the_held_listing_alone(tmp_path, monkeypatch, searching):
    import contextvars

    from core.inference import tools as tools_mod

    _cache_server_tools(tmp_path, monkeypatch, _NOTES)
    a, b, c = (f"mcp__srv1__{name}" for name in ("ping", "create-pages", "move-pages"))
    names = [spec["function"]["name"] for spec in tools_mod._cached_mcp_catalog()]
    rankings = {"ab": [a, b], "cb": [c, b]}
    monkeypatch.setattr(
        tools_mod,
        "_mcp_ranked",
        lambda specs, query: ([names.index(name) for name in rankings[query]], 0),
    )

    def count(messages):
        ctx = contextvars.copy_context()
        ctx.run(
            tools_mod.set_mcp_listing_context_tokens,
            searching,
            "thread-1",
            messages,
            remember = False,
        )
        return ctx.run(lambda: _names(tools_mod.cached_mcp_tools()[0]))

    chat = [{"role": "user", "content": "ab"}]
    first = _thread_listing(tools_mod, searching, chat)
    assert _names(first) == ["mcp_tool_search", a, b]
    assert count([{"role": "user", "content": "cb"}]) == ["mcp_tool_search", b, c]
    assert _thread_listing(tools_mod, searching, chat) == first


def test_mcp_listing_holds_when_the_best_match_cannot_fit(tmp_path, monkeypatch, searching):
    from core.inference import tools as tools_mod

    _cache_server_tools(tmp_path, monkeypatch, _NOTES)
    sizes = {"ping": 40, "create-pages": 40, "query": 1000}
    real_cost = tools_mod._text_token_cost

    def cost(text, ctx):
        if '"name":"mcp_tool_search"' in text:
            return 0
        for name, size in sizes.items():
            if text.startswith("{") and f'"name":"mcp__srv1__{name}"' in text:
                return size
        return 40 if text.startswith("{") else real_cost(text, ctx)

    monkeypatch.setattr(tools_mod, "_text_token_cost", cost)
    monkeypatch.setattr(tools_mod, "_MCP_TOOL_PRELOAD_SHARE", 100 / searching)
    rankings = {"first": ["ping", "create-pages"], "second": ["query", "move-pages"]}

    def ranked(specs, query):
        names = [spec["function"]["name"] for spec in specs]
        return [names.index(f"mcp__srv1__{name}") for name in rankings[query]], 0

    monkeypatch.setattr(tools_mod, "_mcp_ranked", ranked)

    first = _thread_listing(tools_mod, searching, [{"role": "user", "content": "first"}])
    assert _names(first) == ["mcp_tool_search", "mcp__srv1__ping", "mcp__srv1__create-pages"]
    assert _thread_listing(tools_mod, searching, [{"role": "user", "content": "second"}]) == first


def test_mcp_listing_follows_a_change_of_subject(tmp_path, monkeypatch, searching):
    from core.inference import tools as tools_mod

    _cache_server_tools(tmp_path, monkeypatch, _NOTES)
    chat = [{"role": "user", "content": "Who are the users in the workspace?"}]
    _thread_listing(tools_mod, searching, chat)
    chat += [
        {"role": "assistant", "content": "Two people."},
        {"role": "user", "content": "Move my roadmap page under the Archive page."},
    ]
    assert "mcp__srv1__move-pages" in _names(_thread_listing(tools_mod, searching, chat))


def test_mcp_listing_matches_a_write_verb_to_the_tool_named_with_another(
    tmp_path, monkeypatch, searching
):
    """ "Add a comment" lists create-comments, not only the update/fetch siblings sharing its noun (#13601)."""
    import contextvars

    from core.inference import tools as tools_mod

    catalog = [
        {"name": "search-pages", "description": "Search pages in the workspace by title or text."},
        {"name": "fetch-page", "description": "Fetch a page and its content by page id."},
        {"name": "fetch-comment", "description": "Fetch one comment on a page by comment id."},
        {"name": "search-comments", "description": "Search comments on a page."},
        {"name": "update-comment", "description": "Update the text of a comment by comment id."},
        {
            "name": "create-comments",
            "description": "Start a discussion on a page, or reply to one.",
        },
        {"name": "delete-page", "description": "Move a page to the trash."},
    ]
    _cache_server_tools(tmp_path, monkeypatch, catalog)
    monkeypatch.setattr(tools_mod, "_MCP_TOOL_PRELOAD", 3)

    def listing_for(prompt):
        ctx = contextvars.copy_context()
        messages = [{"role": "user", "content": prompt}]
        ctx.run(tools_mod.set_mcp_listing_context_tokens, searching, None, messages)
        return ctx.run(lambda: _names(tools_mod.cached_mcp_tools()[0]))

    add = listing_for("Add a comment to the Roadmap Q3 page saying the launch moved to September.")
    assert "mcp__srv1__create-comments" in add
    assert "mcp__srv1__delete-page" in listing_for("Remove the Roadmap Q3 page.")
    assert "mcp__srv1__update-comment" in listing_for("Edit my comment on the Roadmap page.")
    # Read verbs are not expanded, so "find" does not pull every search tool in.
    assert tools_mod._MCP_VERB_SYNONYMS.get("find") is None
    assert tools_mod._MCP_VERB_SYNONYMS.get("news") is None


def test_mcp_tool_search_exact_name_loads_it_on_every_server(tmp_path, monkeypatch):
    from core.inference import mcp_client, tools as tools_mod

    _cache_server_tools(tmp_path, monkeypatch, [{"name": "search", "description": "Search A."}])
    mcp_servers_db.create_server(id = "srv2", display_name = "B", url = "https://b.example/mcp")
    mcp_client.cache_tools("srv2", [{"name": "search", "description": "Search B."}])
    assert _names(tools_mod.mcp_tool_search_specs({"query": "search"})) == [
        "mcp__srv1__search",
        "mcp__srv2__search",
    ]


def test_mcp_tool_search_never_finds_an_app_only_tool(tmp_path, monkeypatch, searching):
    from core.inference import tools as tools_mod

    hidden = {
        "name": "widget_refresh",
        "description": "Refresh the widget.",
        "_meta": {"ui": {"visibility": ["app"]}},
    }
    _cache_server_tools(tmp_path, monkeypatch, [_big_mcp_tool(), hidden])
    specs = tools_mod.cached_mcp_tools()[0]
    assert "widget_refresh" not in json.dumps(specs)
    assert tools_mod.mcp_tool_search_specs({"query": "refresh the widget"}) == []
    assert tools_mod.mcp_tool_spec("mcp__srv1__widget_refresh") is None


def test_mcp_tool_search_finds_cjk_descriptions(tmp_path, monkeypatch):
    from core.inference import tools as tools_mod

    _cache_server_tools(
        tmp_path,
        monkeypatch,
        [
            _PING,
            {"name": "refund", "description": "处理退款申请"},
            {"name": "henkin", "description": "返金を処理します"},
            {"name": "hwanbul", "description": "환불 처리"},
        ],
    )
    search = tools_mod.mcp_tool_search_specs
    assert _names(search({"query": "退款"})) == ["mcp__srv1__refund"]
    assert _names(search({"query": "返金"})) == ["mcp__srv1__henkin"]
    assert _names(search({"query": "환불"})) == ["mcp__srv1__hwanbul"]


def test_mcp_tool_search_finds_an_alias_by_its_raw_name(tmp_path, monkeypatch):
    from core.inference import tools as tools_mod

    tool = dict(_big_mcp_tool(), name = "catalog.query")
    _cache_server_tools(tmp_path, monkeypatch, [tool])
    found = tools_mod.mcp_tool_search_specs({"query": "catalog.query"})
    assert len(found) == 1
    assert found[0]["function"]["name"] != "mcp__srv1__catalog.query"
    assert found[0]["function"]["parameters"] == tool["inputSchema"]


def test_controller_loads_searched_and_named_mcp_tools(tmp_path, monkeypatch, searching):
    import contextvars

    from core.inference import tools as tools_mod
    from core.inference.tool_loop_controller import ToolLoopController

    _cache_server_tools(tmp_path, monkeypatch, _NOTES)

    def listing_for(thread_id):
        ctx = contextvars.copy_context()
        ctx.run(tools_mod.set_mcp_listing_context_tokens, searching, thread_id)
        return ctx.run(lambda: tools_mod.cached_mcp_tools()[0])

    listing = listing_for("thread-1")
    assert _names(listing) == ["mcp_tool_search"]

    controller = ToolLoopController(tools = listing, thread_id = "thread-1")
    call = {
        "function": {"name": "mcp_tool_search", "arguments": '{"query": "move pages", "limit": 1}'}
    }
    decision = controller.prepare_call(call)
    result = tools_mod.execute_tool("mcp_tool_search", decision.arguments)
    controller.record_result(decision, result)
    assert _names(controller.active_tools()) == ["mcp_tool_search"]
    assert "schema: " in result
    assert (
        json.dumps(tools_mod.mcp_tool_spec("mcp__srv1__move-pages"), separators = (",", ":"))
        in result
    )
    moved_call = controller.prepare_call(
        {"function": {"name": "mcp__srv1__move-pages", "arguments": "{}"}}
    )
    assert moved_call.action == "execute"
    assert _names(controller.active_tools()) == ["mcp_tool_search"]

    named = controller.prepare_call(
        {"function": {"name": "mcp__srv1__ping", "arguments": '{"n": "3"}'}}
    )
    assert named.action == "execute" and named.arguments == {"n": 3}
    assert "mcp__srv1__ping" not in _names(controller.active_tools())

    # Later turns of the thread list the tools it ran, newest first; a tool only loaded is not relisted.
    assert _names(listing_for("thread-1")) == ["mcp_tool_search"]
    controller.record_result(named, "pong")
    moved = controller.prepare_call(
        {"function": {"name": "mcp__srv1__move-pages", "arguments": "{}"}}
    )
    controller.record_result(moved, "moved")
    assert _names(listing_for("thread-1")) == [
        "mcp_tool_search",
        "mcp__srv1__move-pages",
        "mcp__srv1__ping",
    ]
    assert _names(listing_for("thread-2")) == ["mcp_tool_search"]
    # Relisted tools share the preload room, so a small window drops them rather than overflow.
    monkeypatch.setattr(tools_mod, "_MCP_TOOL_PRELOAD_SHARE", 0.0)
    assert _names(listing_for("thread-1")) == ["mcp_tool_search"]


def test_a_search_loads_only_what_fits_the_window(tmp_path, monkeypatch):
    from core.inference import tools as tools_mod

    big = [dict(_big_mcp_tool(), name = f"query-{i}") for i in range(4)]
    _cache_server_tools(tmp_path, monkeypatch, big)
    cost = tools_mod._text_token_cost(json.dumps(tools_mod.mcp_tool_spec("mcp__srv1__query-0")), 1)
    window = lambda share: lambda: int(share * cost / tools_mod._MCP_TOOL_LOAD_SHARE)  # noqa: E731
    monkeypatch.setattr(tools_mod, "_window_context_tokens", window(2.5))
    assert len(tools_mod.mcp_tool_search_specs({"query": "query rows"})) == 2

    monkeypatch.setattr(tools_mod, "_window_context_tokens", window(0.5))
    assert tools_mod.mcp_tool_search_specs({"query": "query rows"}) == []
    out = tools_mod.execute_tool("mcp_tool_search", {"query": "query rows"})
    assert out.startswith("Error: the matching MCP tools (mcp__srv1__query-0, ")
    assert out.endswith("are too large for this model's context window.")


def test_controller_keeps_the_declared_tools_stable_across_searches(tmp_path, monkeypatch):
    from core.inference import tools as tools_mod
    from core.inference.tool_loop_controller import ToolLoopController

    big = [dict(_big_mcp_tool(), name = f"query-{i}") for i in range(4)]
    _cache_server_tools(tmp_path, monkeypatch, big)
    cost = tools_mod._text_token_cost(json.dumps(tools_mod.mcp_tool_spec("mcp__srv1__query-0")), 1)
    monkeypatch.setattr(
        tools_mod,
        "_window_context_tokens",
        lambda: int(2.5 * cost / tools_mod._MCP_TOOL_LOAD_SHARE),
    )
    controller = ToolLoopController(tools = [tools_mod._mcp_tool_search_spec([])])
    before = controller.active_tools()
    for name in ("query-0", "query-1", "query-2"):
        decision = controller.prepare_call(
            {"function": {"name": "mcp_tool_search", "arguments": json.dumps({"query": name})}}
        )
        controller.record_result(decision, "Loaded")
    assert controller.active_tools() == before
    for name in ("query-0", "query-2"):
        assert (
            controller.prepare_call(
                {"function": {"name": f"mcp__srv1__{name}", "arguments": "{}"}}
            ).action
            == "execute"
        )
    assert controller.active_tools() == before


def test_forced_and_image_mapped_tools_stay_listed(tmp_path, monkeypatch, searching):
    import contextvars

    from core.inference import tools as tools_mod

    _cache_server_tools(tmp_path, monkeypatch, _NOTES)

    def listing_for(messages, tool_choice = None):
        ctx = contextvars.copy_context()
        ctx.run(tools_mod.set_mcp_listing_context_tokens, searching, None, messages, tool_choice)
        return ctx.run(lambda: _names(tools_mod.cached_mcp_tools()[0]))

    forced = {"type": "function", "function": {"name": "mcp__srv1__get-users"}}
    assert listing_for(None, forced) == ["mcp_tool_search", "mcp__srv1__get-users"]

    monkeypatch.setattr(
        tools_mod, "image_mapping", lambda server, tool: tool and tool.get("name") == "ping"
    )
    image = {"type": "image_url", "image_url": {"url": "data:image/png;base64,AA=="}}
    asked = [{"role": "user", "content": [{"type": "text", "text": "hi"}, image]}]
    assert listing_for(asked) == ["mcp_tool_search", "mcp__srv1__ping"]
    # Without an attachment the mapped tool is deferred like any other.
    assert listing_for([{"role": "user", "content": "hi"}]) == ["mcp_tool_search"]
    # A tool-only image is sent as mcp_image, never in the messages.
    ctx = contextvars.copy_context()
    hi = [{"role": "user", "content": "hi"}]
    ctx.run(
        tools_mod.set_mcp_listing_context_tokens,
        searching,
        None,
        hi,
        None,
        "data:image/png;base64,AA==",
    )
    assert ctx.run(lambda: _names(tools_mod.cached_mcp_tools()[0])) == [
        "mcp_tool_search",
        "mcp__srv1__ping",
    ]


def test_the_search_declaration_fits_its_share_of_the_window(tmp_path, monkeypatch, listing_window):
    from core.inference import tools as tools_mod

    # One token a character, as CJK summaries cost.
    wide = [{"name": f"t{i}", "description": "\u8868" * 200 + "\u3002"} for i in range(40)]
    _cache_server_tools(tmp_path, monkeypatch, wide)
    ctx = listing_window(20_000)
    specs = tools_mod.cached_mcp_tools()[0]
    assert _names(specs) == ["mcp_tool_search"]
    cost = tools_mod._text_token_cost(json.dumps(specs, separators = (",", ":")), ctx)
    assert cost <= ctx * tools_mod._MCP_TOOL_SEARCH_SHARE


def test_malformed_schemas_and_limits_do_not_break_the_search(tmp_path, monkeypatch):
    from core.inference import tools as tools_mod

    odd = {
        "name": "odd",
        "description": "Odd rows.",
        "inputSchema": {"type": "object", "properties": "x"},
    }
    _cache_server_tools(tmp_path, monkeypatch, [odd])
    assert _names(
        tools_mod.mcp_tool_search_specs({"query": "odd rows", "limit": float("inf")})
    ) == ["mcp__srv1__odd"]


def test_the_search_tool_names_tools_within_a_character_budget():
    from core.inference import tools as tools_mod

    catalog = [("A", [("t" * 60, "s" * 80) for _ in range(10)])]
    description = tools_mod._mcp_tool_search_spec(catalog, 500)["function"]["description"]
    assert description.count("- " + "t" * 60) == 3
    assert description.endswith("- and 7 more")


def test_a_repeated_search_runs_again_and_tools_run_unsearched_are_remembered(
    tmp_path, monkeypatch
):
    import contextvars

    from core.inference import tools as tools_mod
    from core.inference.tool_loop_controller import ToolLoopController

    _cache_server_tools(tmp_path, monkeypatch, _NOTES)
    controller = ToolLoopController(tools = [tools_mod._mcp_tool_search_spec([])])
    call = {"function": {"name": "mcp_tool_search", "arguments": '{"query": "move pages"}'}}
    controller.record_result(controller.prepare_call(call), "Loaded")
    assert controller.prepare_call(call).action == "execute"

    # A catalog listed in full has no search tool, and what the thread ran is still remembered.
    full = ToolLoopController(tools = tools_mod.cached_mcp_tools()[0], thread_id = "t9")
    ran = full.prepare_call({"function": {"name": "mcp__srv1__get-users", "arguments": "{}"}})
    full.record_result(ran, "users")
    ctx = contextvars.copy_context()
    ctx.run(tools_mod.set_mcp_listing_context_tokens, 100_000, "t9")
    monkeypatch.setattr(tools_mod, "_MCP_TOOL_SEARCH_SHARE", 0.0)
    assert ctx.run(lambda: _names(tools_mod.cached_mcp_tools()[0])) == [
        "mcp_tool_search",
        "mcp__srv1__get-users",
    ]


def test_controller_without_the_search_tool_never_loads_mcp_tools(tmp_path, monkeypatch):
    from core.inference.tool_loop_controller import ToolLoopController

    _cache_server_tools(tmp_path, monkeypatch, _NOTES)
    controller = ToolLoopController(tools = [])
    decision = controller.prepare_call({"function": {"name": "mcp__srv1__ping", "arguments": "{}"}})
    assert decision.action == "disabled"
    assert controller.active_tools() == []


STUDIO_TOOLS_URL = "http://127.0.0.1/mcp/studio-tools"


@pytest.mark.parametrize("credential", ["via_api_key", "no_credential"])
def test_only_the_ui_can_add_or_repoint_the_studio_tools_row(tmp_path, monkeypatch, credential):
    import asyncio
    import routes.mcp_servers as routes
    from models.mcp_servers import McpServerCreate, McpServerImportRequest, McpServerUpdate

    _reset_db(tmp_path, monkeypatch)
    mcp_servers_db.create_server(id = "web", display_name = "Web", url = "https://a/mcp")
    add = McpServerCreate(display_name = "Unsloth Studio", url = STUDIO_TOOLS_URL)
    studio = asyncio.run(routes.create_mcp_server(add, current_subject = "u")).id
    key = {"current_subject": "u", credential: True}
    for refused in (
        routes.create_mcp_server(add, **key),
        routes.update_mcp_server("web", McpServerUpdate(url = STUDIO_TOOLS_URL), **key),
        routes.update_mcp_server(studio, McpServerUpdate(url = "https://b/mcp"), **key),
    ):
        with pytest.raises(HTTPException) as exc:
            asyncio.run(refused)
        assert exc.value.status_code == 403
    config = {"mcpServers": {"studio": {"url": "http://localhost:8888/mcp/studio-tools"}}}
    result = asyncio.run(routes.import_mcp_servers(McpServerImportRequest(config = config), **key))
    assert result.created == [] and len(result.errors) == 1
    off = asyncio.run(routes.update_mcp_server(studio, McpServerUpdate(is_enabled = False), **key))
    assert off.is_enabled is False and off.url == STUDIO_TOOLS_URL


def test_the_studio_tools_row_is_reprobed_every_send_and_never_falls_back(tmp_path, monkeypatch):
    import asyncio
    from unittest.mock import AsyncMock

    from core.inference import mcp_client, tools as tools_mod

    _reset_db(tmp_path, monkeypatch)
    monkeypatch.setattr(mcp_client, "_tool_cache", {})
    monkeypatch.setattr(mcp_client, "_probe_cooloff_until", {})
    for id, url in (("web", "https://x"), ("studio", STUDIO_TOOLS_URL)):
        mcp_servers_db.create_server(id = id, display_name = id, url = url, is_enabled = True)
    answers = [_one_tool(), _one_tool("a"), _one_tool("b"), RuntimeError("listing failed")]
    monkeypatch.setattr(tools_mod, "list_tools_async", fake := AsyncMock(side_effect = answers))
    for studio_tools in (["mcp__studio__a"], ["mcp__studio__b"], []):
        listed = asyncio.run(tools_mod.get_enabled_mcp_tools())
        assert [t["function"]["name"] for t in listed] == ["mcp__web__echo", *studio_tools]
    assert [c.kwargs["url"] for c in fake.call_args_list] == ["https://x", *[STUDIO_TOOLS_URL] * 3]


@pytest.mark.parametrize("searched", [False, True])
def test_deferred_mcp_calls_keep_catalog_coercion_on_every_call(monkeypatch, searched):
    from core.inference import tool_loop_controller as controller_mod

    ping = {
        "type": "function",
        "function": {
            "name": "mcp__srv1__ping",
            "parameters": {"type": "object", "properties": {"n": {"type": "integer"}}},
        },
    }
    monkeypatch.setattr(
        controller_mod,
        "_mcp_tool_spec",
        lambda name: ping if name == "mcp__srv1__ping" else None,
    )
    monkeypatch.setattr(controller_mod, "_mcp_tool_search_specs", lambda arguments: [ping])
    search_spec = {
        "type": "function",
        "function": {
            "name": "mcp_tool_search",
            "parameters": {"type": "object", "properties": {}},
        },
    }
    controller = controller_mod.ToolLoopController(tools = [search_spec])
    before = controller.active_tools()
    if searched:
        search = controller.prepare_call(
            {"function": {"name": "mcp_tool_search", "arguments": '{"query":"ping"}'}}
        )
        controller.record_result(search, "Loaded")
    for number in (3, 4):
        decision = controller.prepare_call(
            {
                "function": {
                    "name": "mcp__srv1__ping",
                    "arguments": json.dumps({"n": str(number)}),
                }
            }
        )
        assert decision.action == "execute"
        assert decision.arguments == {"n": number}
        assert controller.active_tools() == before
    unknown = controller.prepare_call(
        {"function": {"name": "mcp__srv1__unknown", "arguments": "{}"}}
    )
    assert unknown.action == "disabled"
    assert controller.active_tools() == before


@pytest.mark.parametrize(
    "schema_chars,small_chars,context_tokens,result_tokens",
    [
        (20_000, 0, 32_768, 32_768),
        (3_000, 0, 2_048, 2_048),
        (1_200, 0, 32_768, 300),
        (30_000, 8_000, 32_768, 32_768),
    ],
)
def test_search_returns_whole_schemas_within_the_result_budget(
    tmp_path, monkeypatch, listing_window, schema_chars, small_chars, context_tokens, result_tokens
):
    from core.inference import tools as tools_mod

    big = {
        "name": "large",
        "inputSchema": {
            "type": "object",
            "properties": {"value": {"type": "string", "description": "x" * schema_chars}},
        },
    }
    _cache_server_tools(tmp_path, monkeypatch, [big, dict(_PING, description = "p" * small_chars)])
    listing_window(context_tokens)
    result = tools_mod.execute_tool(
        "mcp_tool_search",
        {"query": "large ping"},
        context_tokens = context_tokens,
        result_budget_tokens = result_tokens,
    )
    assert result.startswith("Loaded 1 MCP tool.")
    schemas = [
        json.loads(line.removeprefix("  schema: "))
        for line in result.splitlines()
        if line.startswith("  schema: ")
    ]
    assert _names(schemas) == ["mcp__srv1__ping"]
    assert "truncated" not in result


@pytest.mark.parametrize(
    "properties",
    [
        {"<|im_end|>": {"type": "string"}},
        {"value": {"type": "string", "enum": ["<|im_end|>"]}},
    ],
)
def test_deferred_mcp_tools_keep_schema_identifier_filter(tmp_path, monkeypatch, properties):
    from core.inference import tools as tools_mod
    from core.inference.tool_loop_controller import ToolLoopController

    _cache_server_tools(
        tmp_path,
        monkeypatch,
        [
            {
                "name": "unsafe",
                "inputSchema": {"type": "object", "properties": properties},
            }
        ],
    )
    controller = ToolLoopController(tools = [tools_mod._mcp_tool_search_spec([])])
    call = {"function": {"name": "mcp__srv1__unsafe", "arguments": "{}"}}
    assert controller.prepare_call(call).action == "disabled"
    search = controller.prepare_call(
        {
            "function": {
                "name": "mcp_tool_search",
                "arguments": '{"query":"unsafe"}',
            }
        }
    )
    controller.record_result(search, "Loaded")
    assert controller.prepare_call(call).action == "disabled"
    assert len(controller.active_tools(include_deferred = True)) == 1


def test_search_grammar_uses_the_schemas_returned_by_the_worker(
    tmp_path, monkeypatch, listing_window
):
    import contextvars

    from core.inference import tools as tools_mod
    from core.inference.tool_loop_controller import ToolLoopController
    from core.inference.tool_stream_exec import stream_tool_execution

    large = {
        "name": "large",
        "inputSchema": {
            "type": "object",
            "properties": {"value": {"type": "string", "description": "x" * 30_000}},
        },
    }
    _cache_server_tools(tmp_path, monkeypatch, [large, dict(_PING, description = "p" * 4_000)])
    listing_window(32_768)
    monkeypatch.setattr(
        tools_mod,
        "_REQUEST_RESULT_BUDGET",
        contextvars.ContextVar("test_result_budget", default = None),
    )
    controller = ToolLoopController(tools = [tools_mod._mcp_tool_search_spec([])])
    arguments = {"query": "large ping"}
    decision = controller.prepare_call(
        {"function": {"name": "mcp_tool_search", "arguments": json.dumps(arguments)}}
    )
    stream = stream_tool_execution(
        lambda callback: tools_mod.execute_tool(
            "mcp_tool_search", arguments, context_tokens = 32_768, result_budget_tokens = 3_000
        ),
        tool_name = "mcp_tool_search",
    )
    while True:
        try:
            next(stream)
        except StopIteration as stop:
            result = stop.value
            break
    assert "- mcp__srv1__ping:" in result
    assert "- mcp__srv1__large:" not in result
    assert tools_mod._REQUEST_RESULT_BUDGET.get() is None
    controller.record_result(decision, result)
    assert _names(controller.active_tools(include_deferred = True)) == [
        "mcp_tool_search",
        "mcp__srv1__ping",
    ]