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
from __future__ import annotations
import asyncio
import sys
import threading
import time
from pathlib import Path
from types import SimpleNamespace
import pytest
_BACKEND_DIR = str(Path(__file__).resolve().parent.parent)
if _BACKEND_DIR not in sys.path:
sys.path.insert(0, _BACKEND_DIR)
from core.inference import mcp_client
from core.inference.mcp_client import call_tool_sync, close_mcp_sessions
STDIO_URL = "npx fake-stateful-server"
HTTP_URL = "https://mcp.example.test/mcp"
def _settled(
client,
expected: int = 1,
timeout: float = 10.0,
) -> int:
"""Discarded sessions close on the cleanup worker, so a check must wait for the close to land."""
deadline = time.monotonic() + timeout
while client.exited < expected and time.monotonic() < deadline:
time.sleep(0.005)
return client.exited
def _result(text: str) -> SimpleNamespace:
return SimpleNamespace(
content = [SimpleNamespace(type = "text", text = text)],
is_error = False,
structured_content = None,
)
class FakeClient:
instances: list["FakeClient"] = []
def __init__(self, url: str):
self.url = url
self.entered = 0
self.exited = 0
self.calls: list[tuple[str, dict]] = []
self.connected = False
self.fail_next = False
self.call_delay = 0.0
# Real Client.is_connected() stays True after the subprocess dies, so probe the transport.
self.dead = False
self.probe_ok = True
self.probe_error = False
self.probes = 0
self.transport = SimpleNamespace(_is_session_dead = lambda: self.dead)
FakeClient.instances.append(self)
async def list_tools_mcp(self) -> SimpleNamespace:
self.probes += 1
if self.probe_error:
raise RuntimeError("probe failed")
if not self.probe_ok:
await asyncio.sleep(30)
return SimpleNamespace(tools = [])
async def list_tools(self) -> list:
raise AssertionError("the liveness probe must use the single-page tools/list")
async def __aenter__(self):
self.entered += 1
self.connected = True
return self
async def __aexit__(self, *exc):
self.exited += 1
self.connected = False
def is_connected(self) -> bool:
return self.connected
async def call_tool(
self,
name: str,
args: dict,
raise_on_error: bool = True,
):
if self.call_delay:
await asyncio.sleep(self.call_delay)
if self.fail_next:
self.fail_next = False
self.connected = False
raise RuntimeError("transport closed")
self.calls.append((name, args))
return _result(f"call-{len(self.calls)}")
@pytest.fixture
def fake_clients(monkeypatch):
FakeClient.instances = []
monkeypatch.setattr(
mcp_client, "_client", lambda url, headers, use_oauth = False: FakeClient(url)
)
yield FakeClient.instances
close_mcp_sessions()
def test_stdio_call_without_scope_is_one_shot(fake_clients):
r1 = call_tool_sync(STDIO_URL, None, "browser_navigate", {"url": "https://x.test"})
r2 = call_tool_sync(STDIO_URL, None, "browser_take_screenshot", {})
assert r1 == "call-1"
assert r2 == "call-1"
assert len(fake_clients) == 2
assert all(client.entered == 1 and _settled(client) == 1 for client in fake_clients)
def test_stdio_sessions_keyed_by_url_and_env(fake_clients):
call_tool_sync(STDIO_URL, None, "t", {})
call_tool_sync("npx other-server", None, "t", {})
call_tool_sync(STDIO_URL, {"ENV_VAR": "1"}, "t", {})
assert len(fake_clients) == 3
def test_stdio_sessions_scoped_per_chat(fake_clients):
call_tool_sync(STDIO_URL, None, "t", {}, scope = "chat-a")
call_tool_sync(STDIO_URL, None, "t", {}, scope = "chat-b")
call_tool_sync(STDIO_URL, None, "t", {}, scope = "chat-a")
assert len(fake_clients) == 2
assert fake_clients[0].calls and len(fake_clients[0].calls) == 2
def test_dead_stdio_session_recovers(fake_clients):
assert call_tool_sync(STDIO_URL, None, "t", {}, scope = "chat") == "call-1"
fake_clients[0].dead = True
assert call_tool_sync(STDIO_URL, None, "t", {}, scope = "chat") == "call-1"
assert len(fake_clients) == 2
assert _settled(fake_clients[0]) == 1
def test_tool_error_does_not_recycle_session(fake_clients, monkeypatch):
from fastmcp.exceptions import ToolError
class ToolFailure(FakeClient):
async def call_tool(
self,
name,
args,
raise_on_error = True,
):
if name == "boom":
raise ToolError("tool exploded")
return await super().call_tool(name, args, raise_on_error)
monkeypatch.setattr(
mcp_client, "_client", lambda url, headers, use_oauth = False: ToolFailure(url)
)
assert call_tool_sync(STDIO_URL, None, "boom", {}, scope = "chat").startswith("Error: MCP tool")
assert call_tool_sync(STDIO_URL, None, "t", {}, scope = "chat") == "call-1"
assert len(fake_clients) == 1
def test_timeout_keeps_a_responsive_stdio_session(fake_clients):
call_tool_sync(STDIO_URL, None, "t", {}, scope = "chat")
fake_clients[0].call_delay = 0.5
out = call_tool_sync(
STDIO_URL,
None,
"slow",
{},
timeout = 0.05,
cancel_event = threading.Event(),
scope = "chat",
)
assert "timed out" in out
fake_clients[0].call_delay = 0.0
assert call_tool_sync(STDIO_URL, None, "t", {}, scope = "chat") == "call-2"
assert len(fake_clients) == 1
assert fake_clients[0].exited == 0
def test_timeout_replaces_a_wedged_stdio_session(fake_clients):
call_tool_sync(STDIO_URL, None, "t", {}, scope = "chat")
key = mcp_client._session_key(STDIO_URL, None, "chat")
fake_clients[0].call_delay = 0.5
fake_clients[0].probe_ok = False
out = call_tool_sync(
STDIO_URL,
None,
"slow",
{},
timeout = 0.05,
cancel_event = threading.Event(),
scope = "chat",
)
assert "timed out" in out
assert call_tool_sync(STDIO_URL, None, "t", {}, scope = "chat") == "call-1"
assert len(fake_clients) == 2
assert _settled(fake_clients[0]) == 1
assert key in mcp_client._mcp_sessions
def test_dirty_session_probe_stays_inside_the_caller_timeout(fake_clients):
call_tool_sync(STDIO_URL, None, "t", {}, scope = "chat")
fake_clients[0].call_delay = 0.5
fake_clients[0].probe_ok = False
call_tool_sync(
STDIO_URL,
None,
"slow",
{},
timeout = 0.05,
cancel_event = threading.Event(),
scope = "chat",
)
started = time.monotonic()
call_tool_sync(STDIO_URL, None, "t", {}, timeout = 0.2, scope = "chat")
assert time.monotonic() - started < mcp_client._SESSION_LIVENESS_TIMEOUT
def test_failed_probe_replaces_the_session(fake_clients):
# Only a completed round-trip proves the abandoned call is done.
call_tool_sync(STDIO_URL, None, "t", {}, scope = "chat")
fake_clients[0].call_delay = 0.5
fake_clients[0].probe_error = True
call_tool_sync(
STDIO_URL,
None,
"slow",
{},
timeout = 0.05,
cancel_event = threading.Event(),
scope = "chat",
)
fake_clients[0].call_delay = 0.0
assert call_tool_sync(STDIO_URL, None, "t", {}, scope = "chat") == "call-1"
assert len(fake_clients) == 2
assert _settled(fake_clients[0]) == 1
def test_successful_probe_is_not_repeated(fake_clients):
call_tool_sync(STDIO_URL, None, "t", {}, scope = "chat")
fake_clients[0].call_delay = 0.5
call_tool_sync(
STDIO_URL,
None,
"slow",
{},
timeout = 0.05,
cancel_event = threading.Event(),
scope = "chat",
)
fake_clients[0].call_delay = 0.0
assert call_tool_sync(STDIO_URL, None, "t", {}, scope = "chat") == "call-2"
assert call_tool_sync(STDIO_URL, None, "t", {}, scope = "chat") == "call-3"
assert fake_clients[0].probes == 1
def test_stop_interrupts_a_hanging_dirty_probe(fake_clients):
call_tool_sync(STDIO_URL, None, "t", {}, scope = "chat")
fake_clients[0].call_delay = 0.5
fake_clients[0].probe_ok = False
call_tool_sync(
STDIO_URL,
None,
"slow",
{},
timeout = 0.05,
cancel_event = threading.Event(),
scope = "chat",
)
cancel = threading.Event()
threading.Timer(0.1, cancel.set).start()
started = time.monotonic()
out = call_tool_sync(
STDIO_URL,
None,
"t",
{},
scope = "chat",
cancel_event = cancel,
timeout = 30,
)
assert out == "Error: MCP tool 't' cancelled"
assert time.monotonic() - started < mcp_client._SESSION_LIVENESS_TIMEOUT
def test_unwind_budget_comes_out_of_the_caller_deadline():
budget = mcp_client._unwind_budget
assert budget(2.0, 0.05, 0.05) == 0.0
assert budget(2.0, 300.0, 2.0) == 2.0
assert budget(2.0, 3.0, 2.5) == pytest.approx(0.5)
assert budget(2.0, None, 99.0) == 2.0
assert budget(0.0, 300.0, 1.0) == 0.0
def test_liveness_probe_runs_without_the_wedge_margin(fake_clients, monkeypatch):
# The probe's budget is its whole window, so a wedged loop must not add the 15s margin.
margins = []
real_run = mcp_client._McpSession.run
def spy(
self,
coro,
timeout,
margin = mcp_client._SESSION_WEDGE_MARGIN,
):
margins.append(margin)
return real_run(self, coro, timeout, margin)
monkeypatch.setattr(mcp_client._McpSession, "run", spy)
call_tool_sync(STDIO_URL, None, "t", {}, scope = "chat")
fake_clients[0].call_delay = 0.5
call_tool_sync(
STDIO_URL,
None,
"slow",
{},
timeout = 0.05,
cancel_event = threading.Event(),
scope = "chat",
)
fake_clients[0].call_delay = 0.0
margins.clear()
call_tool_sync(STDIO_URL, None, "t", {}, scope = "chat")
assert margins == [0.0, mcp_client._SESSION_WEDGE_MARGIN]
def test_unwind_wait_only_for_cached_sessions(fake_clients, monkeypatch):
# Only cached sessions need the cancelled call to unwind; others must return without waiting.
seen = []
real = mcp_client._race_tool_call
async def spy(
coro,
timeout,
cancel_event,
unwind_timeout = 0.0,
):
seen.append(unwind_timeout)
return await real(coro, timeout, cancel_event, unwind_timeout)
monkeypatch.setattr(mcp_client, "_race_tool_call", spy)
call_tool_sync(HTTP_URL, None, "t", {})
call_tool_sync(STDIO_URL, None, "t", {})
call_tool_sync(STDIO_URL, None, "t", {}, scope = "chat")
assert seen == [0.0, 0.0, mcp_client._CANCEL_UNWIND_TIMEOUT]
def test_cancel_preserves_stateful_session(fake_clients):
call_tool_sync(STDIO_URL, None, "browser_navigate", {}, scope = "chat")
fake_clients[0].call_delay = 1.0
cancel = threading.Event()
threading.Timer(0.1, cancel.set).start()
out = call_tool_sync(
STDIO_URL,
None,
"browser_snapshot",
{},
scope = "chat",
cancel_event = cancel,
timeout = 5,
)
assert out == "Error: MCP tool 'browser_snapshot' cancelled"
fake_clients[0].call_delay = 0.0
assert call_tool_sync(STDIO_URL, None, "browser_snapshot", {}, scope = "chat") == "call-2"
assert len(fake_clients) == 1
def test_no_timeout_allows_long_call(fake_clients):
call_tool_sync(STDIO_URL, None, "t", {}, scope = "chat")
fake_clients[0].call_delay = 0.2
assert call_tool_sync(STDIO_URL, None, "slow", {}, timeout = None, scope = "chat") == "call-2"
def test_connect_races_cancel_event(fake_clients, monkeypatch):
class SlowStart(FakeClient):
async def __aenter__(self):
await asyncio.sleep(5.0)
return await super().__aenter__()
monkeypatch.setattr(mcp_client, "_client", lambda url, headers, use_oauth = False: SlowStart(url))
ev = threading.Event()
threading.Timer(0.1, ev.set).start()
start = time.monotonic()
out = call_tool_sync(STDIO_URL, None, "t", {}, cancel_event = ev)
assert out == "Error: MCP tool 't' cancelled"
assert time.monotonic() - start < 3.0
assert mcp_client._mcp_sessions == {}
def test_connect_respects_caller_timeout(fake_clients, monkeypatch):
class SlowStart(FakeClient):
async def __aenter__(self):
await asyncio.sleep(5.0)
return await super().__aenter__()
monkeypatch.setattr(mcp_client, "_client", lambda url, headers, use_oauth = False: SlowStart(url))
start = time.monotonic()
out = call_tool_sync(STDIO_URL, None, "t", {}, timeout = 0.2)
assert "timed out" in out
assert time.monotonic() - start < 3.0
assert mcp_client._mcp_sessions == {}
def test_connect_failure_timeout_surfaces_immediately(fake_clients, monkeypatch):
class InitTimeout(FakeClient):
async def __aenter__(self):
raise asyncio.TimeoutError
monkeypatch.setattr(
mcp_client, "_client", lambda url, headers, use_oauth = False: InitTimeout(url)
)
start = time.monotonic()
out = call_tool_sync(STDIO_URL, None, "t", {}, timeout = 30.0)
assert "timed out" in out
assert time.monotonic() - start < 5.0
assert mcp_client._mcp_sessions == {}
def test_key_lock_wait_honors_cancel_and_timeout(fake_clients, monkeypatch):
class SlowStart(FakeClient):
async def __aenter__(self):
await asyncio.sleep(1.5)
return await super().__aenter__()
monkeypatch.setattr(mcp_client, "_client", lambda url, headers, use_oauth = False: SlowStart(url))
first = threading.Thread(target = lambda: call_tool_sync(STDIO_URL, None, "t", {}, scope = "chat"))
first.start()
key = mcp_client._session_key(STDIO_URL, None, "chat")
deadline = time.monotonic() + 5.0
while time.monotonic() < deadline:
key_lock = mcp_client._mcp_key_locks.get(key)
if key_lock is not None and key_lock.lock.locked():
break
time.sleep(0.01)
ev = threading.Event()
threading.Timer(0.2, ev.set).start()
start = time.monotonic()
out = call_tool_sync(STDIO_URL, None, "t", {}, cancel_event = ev, scope = "chat")
assert out == "Error: MCP tool 't' cancelled"
assert time.monotonic() - start < 1.0
start = time.monotonic()
out = call_tool_sync(STDIO_URL, None, "t", {}, timeout = 0.2, scope = "chat")
assert "timed out" in out
assert time.monotonic() - start < 1.0
first.join(10.0)
assert not first.is_alive()
def test_cancel_pre_set_spawns_nothing(fake_clients):
ev = threading.Event()
ev.set()
out = call_tool_sync(STDIO_URL, None, "t", {}, cancel_event = ev)
assert out == "Error: MCP tool 't' cancelled"
assert fake_clients == []
def test_idle_reap_closes_session(fake_clients, monkeypatch):
call_tool_sync(STDIO_URL, None, "t", {}, scope = "chat")
key = mcp_client._session_key(STDIO_URL, None, "chat")
assert key in mcp_client._mcp_key_locks
monkeypatch.setattr(mcp_client, "_SESSION_IDLE_TTL", 0.0)
mcp_client._reap_idle_sessions()
assert _settled(fake_clients[0]) == 1
assert mcp_client._mcp_sessions == {}
assert key not in mcp_client._mcp_key_locks
assert call_tool_sync(STDIO_URL, None, "t", {}, scope = "chat") == "call-1"
assert len(fake_clients) == 2
def test_reap_skips_in_flight_session(fake_clients, monkeypatch):
call_tool_sync(STDIO_URL, None, "t", {}, scope = "chat")
monkeypatch.setattr(mcp_client, "_SESSION_IDLE_TTL", 0.0)
session = next(iter(mcp_client._mcp_sessions.values()))
with mcp_client._mcp_sessions_lock:
session.in_flight = 1
try:
mcp_client._reap_idle_sessions()
assert fake_clients[0].exited == 0
finally:
with mcp_client._mcp_sessions_lock:
session.in_flight = 0
def test_close_during_connect_is_not_cached(fake_clients, monkeypatch):
class SlowStart(FakeClient):
async def __aenter__(self):
await asyncio.sleep(0.5)
return await super().__aenter__()
monkeypatch.setattr(mcp_client, "_client", lambda url, headers, use_oauth = False: SlowStart(url))
results: list[str] = []
worker = threading.Thread(
target = lambda: results.append(call_tool_sync(STDIO_URL, None, "t", {}, scope = "chat"))
)
worker.start()
deadline = time.monotonic() + 5.0
while not fake_clients and time.monotonic() < deadline:
time.sleep(0.01)
assert fake_clients
close_mcp_sessions(STDIO_URL)
worker.join(10.0)
assert results and results[0].startswith("Error: MCP tool 't' failed")
assert mcp_client._mcp_sessions == {}
assert _settled(fake_clients[0]) == 1
def test_connect_abort_race_still_closes_client(fake_clients, monkeypatch):
class WinsRace(FakeClient):
async def __aenter__(self):
try:
await asyncio.sleep(5.0)
except asyncio.CancelledError:
pass
return await super().__aenter__()
monkeypatch.setattr(mcp_client, "_client", lambda url, headers, use_oauth = False: WinsRace(url))
out = call_tool_sync(STDIO_URL, None, "t", {}, timeout = 0.1)
assert "timed out" in out
assert fake_clients[0].entered == 1
assert _settled(fake_clients[0]) == 1
assert mcp_client._mcp_sessions == {}
def test_close_unblocks_no_limit_call(fake_clients):
call_tool_sync(STDIO_URL, None, "t", {}, scope = "chat")
session = next(iter(mcp_client._mcp_sessions.values()))
fake_clients[0].call_delay = 30.0
results: list[str] = []
worker = threading.Thread(
target = lambda: results.append(
call_tool_sync(STDIO_URL, None, "slow", {}, timeout = None, scope = "chat")
)
)
worker.start()
deadline = time.monotonic() + 5.0
while time.monotonic() < deadline:
with mcp_client._mcp_sessions_lock:
if session.in_flight >= 1:
break
time.sleep(0.01)
close_mcp_sessions(STDIO_URL)
worker.join(5.0)
assert not worker.is_alive()
assert results and results[0].startswith("Error: MCP tool 'slow' failed")
def test_lock_wait_timeout_spares_the_borrowed_session(fake_clients):
call_tool_sync(STDIO_URL, None, "t", {}, scope = "chat")
session = next(iter(mcp_client._mcp_sessions.values()))
fake_clients[0].call_delay = 1.0
results: list[str] = []
slow = threading.Thread(
target = lambda: results.append(
call_tool_sync(STDIO_URL, None, "slow", {}, timeout = None, scope = "chat")
)
)
slow.start()
deadline = time.monotonic() + 5.0
while time.monotonic() < deadline:
with mcp_client._mcp_sessions_lock:
if session.in_flight >= 1:
break
time.sleep(0.01)
out = call_tool_sync(STDIO_URL, None, "fast", {}, timeout = 0.05, scope = "chat")
assert "timed out" in out
assert fake_clients[0].exited == 0
slow.join(10.0)
assert results == ["call-2"]
assert fake_clients[0].exited == 0
assert len(mcp_client._mcp_sessions) == 1
def test_stale_session_close_deferred_until_borrower_drains(fake_clients):
call_tool_sync(STDIO_URL, None, "t", {}, scope = "chat")
session = next(iter(mcp_client._mcp_sessions.values()))
fake_clients[0].call_delay = 0.8
results: list[str] = []
slow = threading.Thread(
target = lambda: results.append(
call_tool_sync(STDIO_URL, None, "slow", {}, timeout = None, scope = "chat")
)
)
slow.start()
deadline = time.monotonic() + 5.0
while time.monotonic() < deadline:
with mcp_client._mcp_sessions_lock:
if session.in_flight >= 1:
break
time.sleep(0.01)
fake_clients[0].connected = False
out = call_tool_sync(STDIO_URL, None, "t", {}, scope = "chat")
assert out == "call-1"
assert len(fake_clients) == 2
assert fake_clients[0].exited == 0
slow.join(10.0)
assert results == ["call-2"]
assert _settled(fake_clients[0]) == 1
assert len(mcp_client._mcp_sessions) == 1
def test_error_on_closed_session_does_not_retry(fake_clients):
call_tool_sync(STDIO_URL, None, "t", {}, scope = "chat")
session = next(iter(mcp_client._mcp_sessions.values()))
# A close can surface as a plain transport error, which must not be retried as a crash.
fake_clients[0].fail_next = True
session.closed.set()
out = call_tool_sync(STDIO_URL, None, "t", {}, scope = "chat")
assert out == "Error: MCP tool 't' failed: MCP server was updated or removed during the call"
assert len(fake_clients) == 1
def test_config_check_blocks_stale_publish(fake_clients):
out = call_tool_sync(STDIO_URL, None, "t", {}, scope = "chat", config_check = lambda: False)
assert out.startswith("Error: MCP tool 't' failed")
assert mcp_client._mcp_sessions == {}
assert _settled(fake_clients[0]) == 1
def test_close_generation_keys_hold_no_secrets(fake_clients):
secret_url = "npx server --token sk-url-secret"
secret_env = {"API_KEY": "sk-env-secret"}
# These maps are module-level and never pruned, so each half needs its own live session.
before = set(mcp_client._mcp_cfg_close_gen) | set(mcp_client._mcp_url_close_gen)
call_tool_sync(secret_url, secret_env, "t", {}, scope = "chat")
close_mcp_sessions(secret_url, secret_env)
call_tool_sync(secret_url, secret_env, "t", {}, scope = "chat")
close_mcp_sessions(secret_url)
gen_keys = list(mcp_client._mcp_cfg_close_gen) + list(mcp_client._mcp_url_close_gen)
recorded = set(gen_keys) - before
assert recorded, (
"closing a live session recorded no close generation, so the secret check below would "
f"pass over an empty map: cfg={mcp_client._mcp_cfg_close_gen}, "
f"url={mcp_client._mcp_url_close_gen}"
)
# These maps are never pruned, so neither command/URL nor env may persist in keys.
assert all("sk-url-secret" not in repr(k) and "sk-env-secret" not in repr(k) for k in gen_keys)
def test_overlapping_calls_serialize_on_shared_session(fake_clients, monkeypatch):
class OverlapDetect(FakeClient):
active = 0
max_active = 0
async def call_tool(
self,
name,
args,
raise_on_error = True,
):
OverlapDetect.active += 1
OverlapDetect.max_active = max(OverlapDetect.max_active, OverlapDetect.active)
try:
await asyncio.sleep(0.2)
return await super().call_tool(name, args, raise_on_error)
finally:
OverlapDetect.active -= 1
monkeypatch.setattr(
mcp_client, "_client", lambda url, headers, use_oauth = False: OverlapDetect(url)
)
call_tool_sync(STDIO_URL, None, "t", {}, scope = "chat")
workers = [
threading.Thread(target = lambda: call_tool_sync(STDIO_URL, None, "t", {}, scope = "chat"))
for _ in range(2)
]
for worker in workers:
worker.start()
for worker in workers:
worker.join(10.0)
assert OverlapDetect.max_active == 1
assert len(fake_clients) == 1
def test_timeout_budget_spans_connect_and_call(fake_clients, monkeypatch):
class SlowBoth(FakeClient):
async def __aenter__(self):
await asyncio.sleep(0.4)
return await super().__aenter__()
async def call_tool(
self,
name,
args,
raise_on_error = True,
):
await asyncio.sleep(0.5)
return await super().call_tool(name, args, raise_on_error)
monkeypatch.setattr(mcp_client, "_client", lambda url, headers, use_oauth = False: SlowBoth(url))
start = time.monotonic()
out = call_tool_sync(STDIO_URL, None, "t", {}, timeout = 0.6, scope = "chat")
assert "timed out" in out
assert time.monotonic() - start < 2.0
def test_close_narrowed_by_headers_spares_other_env(fake_clients):
call_tool_sync(STDIO_URL, None, "t", {}, scope = "chat")
call_tool_sync(STDIO_URL, {"ENV_VAR": "b"}, "t", {}, scope = "chat")
close_mcp_sessions(STDIO_URL, None)
assert _settled(fake_clients[0]) == 1
assert fake_clients[1].exited == 0
assert len(mcp_client._mcp_sessions) == 1
close_mcp_sessions(STDIO_URL)
assert _settled(fake_clients[1]) == 1
assert mcp_client._mcp_sessions == {}
def test_close_stdio_sessions_by_url(fake_clients):
call_tool_sync(STDIO_URL, None, "t", {}, scope = "chat")
call_tool_sync("npx other-server", None, "t", {}, scope = "chat")
key = mcp_client._session_key(STDIO_URL, None, "chat")
close_mcp_sessions(STDIO_URL)
assert _settled(fake_clients[0]) == 1
assert fake_clients[1].exited == 0
assert len(mcp_client._mcp_sessions) == 1
assert key not in mcp_client._mcp_key_locks
def test_execute_tool_mcp_scope_is_per_thread(tmp_path, monkeypatch):
# session_id can be shared project-wide, so the scope must also carry the thread id.
from core.inference import tools as tools_mod
from storage import mcp_servers_db
monkeypatch.setenv("UNSLOTH_STUDIO_HOME", str(tmp_path))
monkeypatch.setattr(mcp_servers_db, "_schema_ready", set())
monkeypatch.setattr(tools_mod, "stdio_mcp_enabled", lambda: True)
mcp_servers_db.create_server(id = "s1", display_name = "S", url = STDIO_URL, is_enabled = True)
scopes: list = []
def fake_call_tool_sync(**kwargs):
scopes.append(kwargs["scope"])
return "ok"
monkeypatch.setattr(tools_mod, "call_tool_sync", fake_call_tool_sync)
tools_mod.execute_tool("mcp__s1__t", {}, session_id = "project-p1", thread_id = "thread-a")
tools_mod.execute_tool("mcp__s1__t", {}, session_id = "project-p1", thread_id = "thread-b")
tools_mod.execute_tool("mcp__s1__t", {}, session_id = "sess-only")
tools_mod.execute_tool("mcp__s1__t", {}, thread_id = "thread-a")
assert scopes == ["s=project-p1:t=thread-a", "s=project-p1:t=thread-b", None, "s=:t=thread-a"]
tools_mod.execute_tool("mcp__s1__t", {}, session_id = "a:b", thread_id = "c")
tools_mod.execute_tool("mcp__s1__t", {}, session_id = "a", thread_id = "b:c")
assert scopes[-2] != scopes[-1]
tools_mod.execute_tool("mcp__s1__t", {}, session_id = "same")
tools_mod.execute_tool("mcp__s1__t", {}, thread_id = "same")
assert scopes[-2] != scopes[-1]
def test_execute_tool_config_check_tracks_row(tmp_path, monkeypatch):
from core.inference import tools as tools_mod
from storage import mcp_servers_db
monkeypatch.setenv("UNSLOTH_STUDIO_HOME", str(tmp_path))
monkeypatch.setattr(mcp_servers_db, "_schema_ready", set())
monkeypatch.setattr(tools_mod, "stdio_mcp_enabled", lambda: True)
mcp_servers_db.create_server(id = "s1", display_name = "S", url = STDIO_URL, is_enabled = True)
captured: dict = {}
monkeypatch.setattr(tools_mod, "call_tool_sync", lambda **kw: captured.update(kw) or "ok")
tools_mod.execute_tool("mcp__s1__t", {})
check = captured["config_check"]
assert check() is True
mcp_servers_db.update_server("s1", {"url": "npx different-server"})
assert check() is False
def test_multi_block_result_flattens_through_session(fake_clients):
async def _rich_call(
name,
args,
raise_on_error = True,
):
return SimpleNamespace(
content = [
SimpleNamespace(type = "text", text = "### Page"),
SimpleNamespace(type = "text", text = "- Page URL: https://example.com/"),
],
is_error = False,
structured_content = None,
)
call_tool_sync(STDIO_URL, None, "t", {}, scope = "chat")
fake_clients[0].call_tool = _rich_call
out = call_tool_sync(STDIO_URL, None, "browser_snapshot", {}, scope = "chat")
assert out == "### Page\n- Page URL: https://example.com/"
def test_stdio_cache_trims_overshoot_after_burst(fake_clients, monkeypatch):
# Insert-time eviction only reclaims idle sessions, so release-time trimming restores the cap.
monkeypatch.setattr(mcp_client, "_MAX_SESSIONS", 2)
def slow_client(
url,
headers,
use_oauth = False,
):
client = FakeClient(url)
client.call_delay = 0.5
return client
monkeypatch.setattr(mcp_client, "_client", slow_client)
errors: list = []
def worker(i: int):
try:
call_tool_sync(STDIO_URL, None, "t", {}, scope = f"chat-{i}")
except Exception as exc: # noqa: BLE001
errors.append(exc)
threads = [threading.Thread(target = worker, args = (i,)) for i in range(5)]
for thread in threads:
thread.start()
for thread in threads:
thread.join(10.0)
assert not errors, errors
assert len(mcp_client._mcp_sessions) <= 2
def test_close_with_nothing_cached_creates_no_tombstone(fake_clients):
before_cfg = len(mcp_client._mcp_cfg_close_gen)
before_url = len(mcp_client._mcp_url_close_gen)
for i in range(50):
close_mcp_sessions(f"https://mcp-{i}.example/mcp", {"K": str(i)})
close_mcp_sessions(f"https://mcp-{i}.example/mcp")
assert len(mcp_client._mcp_cfg_close_gen) == before_cfg
assert len(mcp_client._mcp_url_close_gen) == before_url
cfg = mcp_client._cfg_close_key(STDIO_URL, None)
before_gen = mcp_client._mcp_cfg_close_gen.get(cfg, 0)
call_tool_sync(STDIO_URL, None, "t", {}, scope = "chat")
close_mcp_sessions(STDIO_URL, None)
assert mcp_client._mcp_cfg_close_gen[cfg] == before_gen + 1
def test_http_session_reused_across_calls_in_one_scope(fake_clients):
save = call_tool_sync(HTTP_URL, None, "save_note", {"text": "buy milk"}, scope = "chat")
assert save == "call-1"
assert call_tool_sync(HTTP_URL, None, "list_notes", {}, scope = "chat") == "call-2"
assert len(fake_clients) == 1
assert fake_clients[0].entered == 1
assert fake_clients[0].exited == 0
def test_http_sessions_scoped_and_keyed(fake_clients):
call_tool_sync(HTTP_URL, None, "t", {}, scope = "chat-a")
call_tool_sync(HTTP_URL, None, "t", {}, scope = "chat-b")
call_tool_sync(HTTP_URL, {"Authorization": "Bearer x"}, "t", {}, scope = "chat-a")
call_tool_sync(HTTP_URL, None, "t", {}, scope = "chat-a")
assert len(fake_clients) == 3
assert len(fake_clients[0].calls) == 2
def test_http_call_without_scope_is_one_shot(fake_clients):
call_tool_sync(HTTP_URL, None, "t", {})
call_tool_sync(HTTP_URL, None, "t", {})
assert len(fake_clients) == 2
assert all(client.entered == 1 and _settled(client) == 1 for client in fake_clients)
assert mcp_client._mcp_sessions == {}
def test_http_oauth_call_stays_one_shot(fake_clients):
call_tool_sync(HTTP_URL, None, "t", {}, scope = "chat", use_oauth = True)
call_tool_sync(HTTP_URL, None, "t", {}, scope = "chat", use_oauth = True)
assert len(fake_clients) == 2
assert mcp_client._mcp_sessions == {}
def test_close_mcp_sessions_drops_http_session(fake_clients):
call_tool_sync(HTTP_URL, None, "t", {}, scope = "chat")
assert len(mcp_client._mcp_sessions) == 1
close_mcp_sessions(HTTP_URL, None)
assert mcp_client._mcp_sessions == {}
assert _settled(fake_clients[0]) == 1
call_tool_sync(HTTP_URL, None, "t", {}, scope = "chat")
assert len(fake_clients) == 2
def test_dead_http_session_recovers(monkeypatch, fake_clients):
"""The idle recheck, not the dead-session flag, catches an HTTP session the server dropped."""
monkeypatch.setattr(mcp_client, "_HTTP_IDLE_RECHECK", 0.0)
assert call_tool_sync(HTTP_URL, None, "t", {}, scope = "chat") == "call-1"
fake_clients[0].probe_error = True
assert call_tool_sync(HTTP_URL, None, "t", {}, scope = "chat") == "call-1"
assert len(fake_clients) == 2
assert _settled(fake_clients[0]) == 1
def test_live_idle_http_session_survives_the_recheck(monkeypatch, fake_clients):
"""The recheck is one tools/list; a live HTTP session that answers keeps its state."""
monkeypatch.setattr(mcp_client, "_HTTP_IDLE_RECHECK", 0.0)
assert call_tool_sync(HTTP_URL, None, "t", {}, scope = "chat") == "call-1"
assert call_tool_sync(HTTP_URL, None, "t", {}, scope = "chat") == "call-2"
assert len(fake_clients) == 1
assert fake_clients[0].probes == 1
def test_recently_used_http_session_is_not_reprobed(fake_clients):
"""Back-to-back calls must not pay a probe each; only an idle gap triggers it."""
call_tool_sync(HTTP_URL, None, "t", {}, scope = "chat")
call_tool_sync(HTTP_URL, None, "t", {}, scope = "chat")
assert fake_clients[0].probes == 0
def test_idle_stdio_session_is_not_reprobed(monkeypatch, fake_clients):
"""stdio is exempt: _transport_dead answers there, and a live subprocess does
not expire on its own the way a server-side HTTP session does."""
monkeypatch.setattr(mcp_client, "_HTTP_IDLE_RECHECK", 0.0)
call_tool_sync(STDIO_URL, None, "t", {}, scope = "chat")
call_tool_sync(STDIO_URL, None, "t", {}, scope = "chat")
assert fake_clients[0].probes == 0
assert len(fake_clients) == 1
def test_http_tool_error_keeps_session(fake_clients):
from fastmcp.exceptions import ToolError
call_tool_sync(HTTP_URL, None, "t", {}, scope = "chat")
async def _tool_error(
name,
args,
raise_on_error = True,
):
raise ToolError("nope")
session_client = fake_clients[0]
session_client.call_tool = _tool_error
assert call_tool_sync(HTTP_URL, None, "t", {}, scope = "chat").startswith("Error:")
assert len(mcp_client._mcp_sessions) == 1
assert len(fake_clients) == 1