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.
Python agentaichatgptdeepseekfine-tuninggemmaimage-generationllamallmllmsopenaipythonqwenreinforcement-learningself-hostedstable-diffusiontext-to-speechttsuiunsloth
# 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",
]