Skip to content

Run frontier MoE models on hardware you already own — pure C, zero deps, experts streamed from disk. Tiny engine, immense model. 🐦

C

fix(mcp): release completed tool workers between calls

Rudy Celekli28cfe11db52e
diff --git a/c/mcp_server.py b/c/mcp_server.py
index e9088346..b13a1cc0 100644
--- a/c/mcp_server.py
+++ b/c/mcp_server.py
@@ -345,6 +345,9 @@ class Server:
elif method == "tools/list":
self.result(msg_id, {"tools": TOOLS})
elif method == "tools/call":
+ # Keep EOF draining limited to calls still in flight, rather than
+ # retaining every completed worker for the lifetime of the session.
+ self.threads = [worker for worker in self.threads if worker.is_alive()]
thread = threading.Thread(target=self.call_tool, args=(msg_id, params), daemon=True)
self.threads.append(thread)
thread.start()
diff --git a/c/tests/test_mcp_thread_lifecycle.py b/c/tests/test_mcp_thread_lifecycle.py
new file mode 100644
index 00000000..90435138
--- /dev/null
+++ b/c/tests/test_mcp_thread_lifecycle.py
@@ -0,0 +1,71 @@
+"""Completed MCP calls are released while EOF still waits for active workers."""
+import io
+import json
+import sys
+import threading
+import unittest
+from pathlib import Path
+from unittest import mock
+
+C_DIR = Path(__file__).resolve().parent.parent
+sys.path.insert(0, str(C_DIR))
+import mcp_server
+
+
+def call(number):
+ return {"jsonrpc": "2.0", "id": number, "method": "tools/call",
+ "params": {"name": "status", "arguments": {}}}
+
+
+class ThreadLifecycle(unittest.TestCase):
+ def test_finished_calls_do_not_accumulate(self):
+ output = io.StringIO()
+ server = mcp_server.Server(out=output)
+ with mock.patch.dict(mcp_server.HANDLERS, {"status": lambda args, notify: {"ok": True}}):
+ for number in range(50):
+ server.handle(call(number))
+ for worker in server.threads:
+ worker.join(timeout=2)
+ self.assertFalse(worker.is_alive())
+ self.assertLessEqual(len(server.threads), 1)
+ replies = [json.loads(line) for line in output.getvalue().splitlines()]
+ self.assertEqual({reply['id'] for reply in replies}, set(range(50)))
+ self.assertTrue(all(reply['result']['isError'] is False for reply in replies))
+
+ def test_eof_preserves_and_waits_for_active_calls(self):
+ output = io.StringIO()
+ server = mcp_server.Server(out=output)
+ entered = threading.Event()
+ release = threading.Event()
+
+ def handler(args, notify):
+ entered.set()
+ self.assertTrue(release.wait(timeout=3))
+ return {"ok": True}
+
+ with mock.patch.dict(mcp_server.HANDLERS, {"status": handler}):
+ server.handle(call(1))
+ active = server.threads[-1]
+ self.assertTrue(entered.wait(timeout=2))
+ with mock.patch.dict(mcp_server.HANDLERS, {"status": lambda args, notify: {"ok": True}}):
+ server.handle(call(2))
+ server.threads[-1].join(timeout=2)
+ self.assertIn(active, server.threads)
+ draining = threading.Thread(target=server.serve, args=(io.StringIO(""),))
+ draining.start()
+ try:
+ draining.join(timeout=.1)
+ self.assertTrue(draining.is_alive())
+ finally:
+ release.set()
+ draining.join(timeout=3)
+ active.join(timeout=3)
+ self.assertFalse(draining.is_alive())
+ self.assertFalse(active.is_alive())
+ replies = [json.loads(line) for line in output.getvalue().splitlines()]
+ self.assertEqual({reply['id'] for reply in replies}, {1, 2})
+ self.assertTrue(all(reply['result']['isError'] is False for reply in replies))
+
+
+if __name__ == "__main__":
+ unittest.main()