Reason Network: your team's coding agents, talking to each other. The engine behind `reason network`.
Rust agent-to-agentai-agentsclaude-codecodexcoding-agentscursorgrokirohmcpmcp-servermulti-agentpeer-to-peerreason
"""Exercise the native Hermes adapter against a real, isolated Reason daemon.
Build the engine, then run with Hermes on PYTHONPATH (no model or account needed):
PYTHONPATH=/path/to/hermes-agent python tests/e2e/hermes.py
"""
import importlib.util
import json
import os
from pathlib import Path
import subprocess
import tempfile
import threading
import time
import unittest
from types import SimpleNamespace
import shutil
import sys
ROOT = Path(__file__).resolve().parents[2]
BIN = Path(os.environ.get("REASON_TEST_BIN", ROOT / "target/debug/reason-network"))
spec = importlib.util.spec_from_file_location("reason_hermes", ROOT / "integrations/hermes/__init__.py")
plugin = importlib.util.module_from_spec(spec)
spec.loader.exec_module(plugin)
class Context:
profile_name = "test"
def __init__(self, directory, wake=True):
self.directory = str(directory)
self.route = "route-first"
self.wake = wake
self.executable = str(BIN)
self.accept = True
self.received = []
self.delivered = threading.Event()
data = {}
self.state = SimpleNamespace(get=data.get, set=data.__setitem__, data_dir=directory / "plugin-data")
def is_interrupted(self):
from tools.interrupt import is_interrupted
return is_interrupted()
def session_supports_async_delivery(self):
return True
def get_config(self, key, default=None):
return {"executable": self.executable, "wake": self.wake}.get(key, default)
def session_cwd(self):
return self.directory
def session_surface(self):
return "desktop"
def session_key(self):
return self.route
def inject_message(self, text, *, session_key=None):
self.received.append((session_key, text))
self.delivered.set()
return self.accept
STAND_IN_ENGINE = '''
import json, sys, time
for line in sys.stdin:
call = json.loads(line)
result = {}
if call.get("op") == "register":
key = call["session"]["key"]
if key.endswith(":slow"):
open(MARKER, "w").close()
time.sleep(8)
result = {"address": key}
elif call.get("op") == "unread":
result = {"count": 0}
print(json.dumps({"id": call["id"], "ok": True, "result": result}), flush=True)
'''
class ObservedTurnLock:
"""Observe lock contention without guessing how long a worker takes."""
def __init__(self, lock, watched_name):
self.lock = lock
self.watched_name = watched_name
self.observed = threading.Event()
self.acquired_immediately = None
def __enter__(self):
if threading.current_thread().name == self.watched_name and not self.observed.is_set():
acquired = self.lock.acquire(blocking=False)
self.acquired_immediately = acquired
self.observed.set()
if not acquired:
self.lock.acquire()
else:
self.lock.acquire()
return self
def __exit__(self, *_):
self.lock.release()
class NativeHermes(unittest.TestCase):
@classmethod
def setUpClass(cls):
# Windows's system temp lives under protected AppData. Use a real project
# workspace for the positive attachment case, keeping credential guards intact.
scratch = ROOT / "target"
scratch.mkdir(exist_ok=True)
cls.temporary = tempfile.TemporaryDirectory(prefix="reason-hermes-", dir=scratch)
cls.root = Path(cls.temporary.name)
cls.previous = dict(os.environ)
os.environ.update(
REASON_NETWORK_HOME=str(cls.root / "network"), REASON_NETWORK_NO_MDNS="1",
REASON_NETWORK_NO_SERVICE="1", REASON_NETWORK_NO_TRAY="1", REASON_NETWORK_NO_UPDATE="1",
REASON_NETWORK_MACHINE="isolated-hermes-test", CLAUDE_CONFIG_DIR=str(cls.root / "claude"),
)
cls.cli("init", "hermes-adapter-test", "--as", "tester", "--no-setup")
@classmethod
def cli(cls, *args):
result = subprocess.run([str(BIN), *args], text=True, capture_output=True, timeout=30)
if result.returncode:
raise RuntimeError(result.stderr or result.stdout)
return result.stdout
@classmethod
def tearDownClass(cls):
cls.cli("stop")
os.environ.clear()
os.environ.update(cls.previous)
cls.temporary.cleanup()
def setUp(self):
self.directory = self.root / self._testMethodName
self.directory.mkdir()
self.context = Context(self.directory)
self.context.profile_name = self._testMethodName
self.network = plugin.Network(self.context)
def tearDown(self):
self.network.close()
def start(self, ident="first", **kwargs):
self.context.route = f"route-{ident}"
result = self.network.before_turn(session_id=ident, platform="desktop", **kwargs)
self.assertIsNotNone(result)
return self.network.session(ident)
def send(self, sender, target, body="test message", **kwargs):
return sender["bridge"].request("send", **{"from": sender["key"]},
to=target["registration"]["address"], body=body, **kwargs)
def assert_acknowledged(self, session, network=None):
network = network or self.network
deadline = time.monotonic() + 5
while time.monotonic() < deadline:
network.register_session(session)
if session["registration"]["unread"] == 0:
return
time.sleep(0.01)
self.fail("Host accepted delivery but the adapter did not acknowledge it")
def test_two_conversations_use_captured_routes_and_teardown_independently(self):
first = self.start()
self.context.route = "route-second"
second = self.start("second")
self.assertNotEqual(first["registration"]["address"], second["registration"]["address"])
self.send(first, second)
self.assertTrue(self.context.delivered.wait(5))
self.assertEqual(self.context.received[0][0], "route-second")
self.assertIn("<reason-message", self.context.received[0][1])
self.assert_acknowledged(second)
self.network.finalize(session_id="first")
self.assertFalse(first["bridge"].alive)
self.assertTrue(second["bridge"].alive)
listing = second["bridge"].request("who", me=second["key"])
self.assertIn(second["registration"]["name"], listing)
self.assertNotIn(first["registration"]["name"] + " ", listing)
def test_failed_push_stays_unread(self):
sender = self.start()
target = self.start("denied")
self.context.accept = False
self.send(sender, target, "keep this unread")
self.assertTrue(self.context.delivered.wait(5))
# Waiting for a barrier request keeps the assertion independent of reader scheduling.
target["bridge"].request("who", me=target["key"])
inbox = self.network.inbox(target)
self.assertIn("keep this unread", inbox)
self.assertEqual(self.network.inbox(target), "No messages.")
def test_pull_mode_reads_at_the_next_turn_without_waking(self):
self.context.wake = False
first, second = self.start(), self.start("pull")
self.send(first, second, "next turn")
result = self.network.before_turn(session_id="pull", platform="desktop")
self.assertIn("unread", result["context"])
self.assertIn("next turn", self.network.inbox(second))
self.assertEqual(self.context.received, [])
def test_disabling_wake_applies_before_another_turn_and_can_be_reenabled(self):
sender, target = self.start(), self.start("live-setting")
address = target["registration"]["address"]
demoted = threading.Event()
register = self.network.register_session
def observe_registration(session):
register(session)
if session is target and not session["wake"]:
demoted.set()
self.network.register_session = observe_registration
self.context.wake = False
self.send(sender, target, "disabled while idle")
self.assertTrue(demoted.wait(5))
self.assertFalse(target["wake"])
self.assertEqual(self.context.received, [])
self.assertIn("disabled while idle", self.network.inbox(target))
self.context.wake = True
self.network.before_turn(session_id="live-setting", platform="desktop")
self.assertEqual(target["registration"]["address"], address)
self.send(sender, target, "enabled again")
self.assertTrue(self.context.delivered.wait(5))
self.assertIn("enabled again", self.context.received[0][1])
self.assert_acknowledged(target)
def test_tool_first_session_gains_wake_only_after_a_bound_interactive_turn(self):
target = self.network.session("tool-first")
self.assertFalse(target["wake"])
self.network.before_turn(session_id="tool-first", platform="desktop")
self.assertTrue(target["wake"])
sender = self.start("sender")
self.send(sender, target, "interactive route ready")
self.assertTrue(self.context.delivered.wait(5))
self.assertEqual(self.context.received[0][0], "route-first")
self.assert_acknowledged(target)
def test_transient_registration_failure_is_retried_on_the_next_bound_turn(self):
target = self.network.session("retry-registration")
request = target["bridge"].request
attempts = []
def fail_once(operation, **kwargs):
if operation == "register":
attempts.append(operation)
if len(attempts) == 1:
raise RuntimeError("temporary test registration failure")
return request(operation, **kwargs)
target["bridge"].request = fail_once
self.assertIsNone(self.network.before_turn(session_id="retry-registration", platform="desktop"))
self.assertIsNotNone(self.network.before_turn(session_id="retry-registration", platform="desktop"))
self.assertEqual(len(attempts), 2)
sender = self.start("sender")
self.send(sender, target, "registration recovered")
self.assertTrue(self.context.delivered.wait(5))
self.assertIn("registration recovered", self.context.received[0][1])
self.assert_acknowledged(target)
def test_rejected_push_cannot_demote_a_newer_bound_turn(self):
sender, target = self.start("sender"), self.start("target")
refused, release, refusal_done, turn_done, fresh_delivery = (threading.Event() for _ in range(5))
result = []
watched_name = "test-bound-turn"
# The conversation's own lock: a bound turn waits for its stale refusal, other conversations don't.
observed_lock = ObservedTurnLock(target["lock"], watched_name)
target["lock"] = self.network._turns["target"] = observed_lock
request = target["bridge"].request
inject = self.context.inject_message
receive = self.network.receive
def controlled_request(op, **kwargs):
answer = request(op, **kwargs)
if op == "push_failed" and not refused.is_set():
refused.set()
if not release.wait(5):
raise TimeoutError("test did not release the refused push")
return answer
def observed_inject(text, **kwargs):
accepted = inject(text, **kwargs)
if accepted and "fresh message after recovery" in text:
fresh_delivery.set()
return accepted
def observed_receive(session, event):
try:
return receive(session, event)
finally:
if "rejected before the next turn" in event["text"]:
refusal_done.set()
def bound_turn():
try:
result.append(self.network.before_turn(session_id="target", platform="desktop"))
finally:
turn_done.set()
target["bridge"].request = controlled_request
self.context.inject_message = observed_inject
self.network.receive = observed_receive
self.context.accept = False
worker = threading.Thread(target=bound_turn, name=watched_name, daemon=True)
try:
self.send(sender, target, "rejected before the next turn")
self.assertTrue(refused.wait(5))
self.context.accept = True
self.context.route = "route-target"
worker.start()
self.assertTrue(observed_lock.observed.wait(5))
# With the defect, the turn completes while the stale rejection is
# paused; fixed code contends, and finishes after that rejection.
if observed_lock.acquired_immediately:
self.assertTrue(turn_done.wait(5))
release.set()
self.assertTrue(refusal_done.wait(5))
self.assertTrue(turn_done.wait(5))
worker.join(timeout=5)
self.assertFalse(worker.is_alive())
self.assertIsNotNone(result[0])
self.assertTrue(target["wake"], "stale rejection overwrote the newer turn's push mode")
self.send(sender, target, "fresh message after recovery")
self.assertTrue(fresh_delivery.wait(5))
self.assertEqual(target["route"], "route-target")
self.assert_acknowledged(target)
finally:
release.set()
if worker.ident is not None:
worker.join(timeout=5)
def test_bridge_refuses_admin_commands_other_identities_and_raw_files(self):
first, other = self.start(), self.start("other")
bridge = first["bridge"]
for op, arguments in (
("who", {"me": other["key"]}), ("leave", {}),
("send", {"from": first["key"], "to": other["registration"]["address"],
"body": "no", "files": [{"name": "secret", "content": "bypass"}]}),
):
with self.subTest(op=op), self.assertRaises(RuntimeError):
bridge.request(op, **arguments)
def test_text_files_are_confined_and_received(self):
self.context.wake = False
first, second = self.start(), self.start("files")
(self.directory / "notes.txt").write_text("useful text", encoding="utf-8")
self.send(first, second, "see notes", paths=["notes.txt"])
inbox = self.network.inbox(second)
self.assertIn("notes.txt", inbox)
# This must be outside the repository too: attachments may use the entire repo.
with tempfile.TemporaryDirectory(prefix="reason-hermes-excluded-") as excluded:
outside = Path(excluded) / "outside.txt"
outside.write_text("must stay outside", encoding="utf-8")
with self.assertRaises(RuntimeError):
self.send(first, second, paths=[str(outside)])
def test_subagents_never_borrow_the_parent_wake_route(self):
result = self.network.before_turn(session_id="child", platform="subagent")
self.assertIsNotNone(result)
self.assertFalse(self.network.session("child")["wake"])
def test_history_compaction_keeps_identity_and_refreshes_the_delivery_route(self):
original = self.start("before-compression")
self.network.compacted(session_id="after-compression", old_session_id="before-compression")
self.context.route = "new-routing-key"
self.network.before_turn(session_id="after-compression", platform="desktop")
continuation = self.network.session("after-compression")
self.assertIs(continuation, original)
self.assertEqual(continuation["route"], "new-routing-key")
self.assertNotIn("before-compression", self.network._sessions)
self.network.finalize(session_id="after-compression")
self.assertFalse(original["bridge"].alive)
def assert_late_delivery_is_ignored(self, close):
sender, target = self.start("sender"), self.start("closing")
entered, release, finished = (threading.Event() for _ in range(3))
receive = self.network.receive
def paused_receive(session, event):
entered.set()
try:
if not release.wait(10):
raise TimeoutError("test did not release the pending callback")
return receive(session, event)
finally:
finished.set()
self.network.receive = paused_receive
try:
self.send(sender, target, "message arriving while closing")
self.assertTrue(entered.wait(5))
close()
self.assertNotIn("closing", self.network._sessions)
self.assertFalse(target["bridge"].alive)
release.set()
self.assertTrue(finished.wait(5))
self.assertEqual(self.context.received, [], "an old callback injected into a closed conversation")
finally:
release.set()
target["bridge"]._delivery.join(timeout=5)
def test_finalization_ignores_a_delivery_callback_already_in_flight(self):
self.assert_late_delivery_is_ignored(lambda: self.network.finalize(session_id="closing"))
def test_unload_ignores_a_delivery_callback_already_in_flight(self):
self.assert_late_delivery_is_ignored(self.network.close)
def test_cancelled_inbox_releases_the_wait_without_consuming_future_mail(self):
from tools.interrupt import clear_current_thread_interrupt, set_interrupt
self.context.wake = False
sender, target = self.start(), self.start("cancelled")
entered = threading.Event()
finished = threading.Event()
result = []
def wait():
entered.set()
try:
result.append(self.network.tool("check_inbox", {"wait_secs": 30}, "cancelled"))
finally:
clear_current_thread_interrupt()
finished.set()
worker = threading.Thread(target=wait)
worker.start()
self.assertTrue(entered.wait(5))
set_interrupt(True, worker.ident)
self.assertTrue(finished.wait(5))
worker.join(timeout=5)
self.assertIn("cancelled", result[0])
self.send(sender, target, "read after cancellation")
self.assertIn("read after cancellation", self.network.inbox(target))
def test_preturn_hints_never_acknowledge_mail(self):
self.context.wake = False
sender, target = self.start(), self.start("hint")
self.send(sender, target, "must remain unread")
self.network.before_turn(session_id="hint", platform="desktop")
self.assertEqual(target["bridge"].request("unread", key=target["key"])["count"], 1)
def test_malformed_arguments_and_foreign_acknowledgements_fail_immediately(self):
self.context.wake = False
sender, target = self.start(), self.start("recipient")
bridge = sender["bridge"]
with self.assertRaises(RuntimeError):
bridge.request("inbox", key=sender["key"], wait_secs=True, timeout=3)
self.send(sender, target, "do not consume", wake=False)
offered = target["bridge"].request("inbox", key=target["key"], peek=True)
ids = [m["id"] for m in offered["messages"]]
for op in ("delivered", "push_failed"):
with self.assertRaises(RuntimeError):
bridge.request(op, key=sender["key"], ids=ids)
self.assertIn("do not consume", self.network.inbox(target))
@unittest.skipIf(os.name == "nt", "the stand-in engine is a script with a shebang")
def test_a_slow_answer_for_one_conversation_does_not_stall_another(self):
# A stand-in engine that takes 8 s to register one conversation, as a busy daemon might.
marker = self.directory / "slow-register-received"
engine = self.directory / "stand-in-engine"
engine.write_text(f"#!{sys.executable}\n" + STAND_IN_ENGINE.replace("MARKER", repr(str(marker))),
encoding="utf-8")
engine.chmod(0o755)
self.context.executable, self.context.route = str(engine), ""
slow_done = threading.Event()
def slow_turn():
self.network.before_turn(session_id="slow", platform="desktop")
slow_done.set()
threading.Thread(target=slow_turn, daemon=True).start()
deadline = time.monotonic() + 5
while not marker.exists():
self.assertLess(time.monotonic(), deadline, "the slow registration never reached the engine")
time.sleep(0.01)
started = time.monotonic()
self.assertIsNotNone(self.network.before_turn(session_id="fast", platform="desktop"))
self.assertLess(time.monotonic() - started, 2, "an unrelated conversation waited on the slow one")
self.assertFalse(slow_done.is_set())
self.assertTrue(slow_done.wait(15))
def test_an_oversized_frame_ends_only_that_adapter(self):
first, other = self.start(), self.start("other")
# One line over the 1 MiB cap: the adapter stops rather than buffering it.
first["bridge"].process.stdin.write('{"id":1,"op":"unread","key":"' + "x" * (1024 * 1024) + '"}\n')
first["bridge"].process.stdin.flush()
self.assertIsNotNone(first["bridge"].process.wait(timeout=10))
with self.assertRaises(RuntimeError):
first["bridge"].request("unread", key=first["key"], timeout=5)
# The daemon and the other conversation's adapter are unaffected.
self.assertEqual(other["bridge"].request("unread", key=other["key"])["count"], 0)
def test_an_older_hermes_without_the_plugin_apis_loads_nothing(self):
registered = []
older = SimpleNamespace( # What released Hermes gives a plugin today: no routing key or cancellation.
register_hook=lambda *a, **k: registered.append(a), register_tool=lambda **k: registered.append(k),
on_unload=registered.append, session_cwd=lambda: "", session_surface=lambda: "cli",
inject_message=lambda *a, **k: False,
)
with self.assertLogs(plugin.log, "WARNING") as logs:
plugin.register(older)
self.assertEqual(registered, [])
self.assertIn("session_key", logs.output[0])
self.assertIn("is_interrupted", logs.output[0])
def test_the_engine_is_found_where_the_installers_put_it(self):
home, previous = self.directory / "home", dict(os.environ)
name = "reason-network.exe" if os.name == "nt" else "reason-network"
local, app = home / ".local" / "bin" / name, home / ".reason" / "bin" / name
self.context.executable = ""
os.environ.update(HOME=str(home), USERPROFILE=str(home), PATH="")
try:
app.parent.mkdir(parents=True)
app.write_text("")
self.assertEqual(self.network.executable(), str(app))
local.parent.mkdir(parents=True)
local.write_text("")
self.assertEqual(self.network.executable(), str(local))
finally:
os.environ.clear()
os.environ.update(previous)
def test_real_hermes_loader_routes_through_its_permission_checked_queue(self):
from agent.runtime_cwd import reset_session_cwd, set_session_cwd
from gateway.session_context import clear_session_vars, set_session_vars
from hermes_cli.plugins import PluginManager
profile = self.directory / "profile"
profile.mkdir()
shutil.copytree(ROOT / "integrations/hermes", profile / "plugins/reason-network",
ignore=shutil.ignore_patterns("__pycache__"))
(profile / "config.yaml").write_text(json.dumps({"plugins": {
"enabled": ["reason-network"], "entries": {"reason-network": {
"allow_gateway_injection": True, "settings": {"wake": True, "executable": str(BIN)},
}},
}}), encoding="utf-8")
previous = os.environ.get("HERMES_HOME")
os.environ["HERMES_HOME"] = str(profile)
manager = PluginManager()
accepted = []
queued = threading.Event()
def inject(**kwargs):
accepted.append(kwargs)
queued.set()
return True
manager.set_tui_message_injector(object(), inject)
token = set_session_cwd(str(self.directory))
try:
manager.discover_and_load()
self.assertIn("reason-network", manager._plugins)
for session_id, route in (("host-first", "real-host-first"), ("host-second", "real-host-second")):
tokens = set_session_vars(platform="desktop", session_key=route, session_id=session_id,
cwd=str(self.directory))
try:
self.assertTrue(manager.invoke_hook("pre_llm_call", session_id=session_id, platform="desktop"))
finally:
clear_session_vars(tokens)
# The callback is registered by the real loader, with a real PluginContext.
network = next(callback.__self__ for callback in manager._hooks["pre_llm_call"]
if callback.__self__.__class__.__name__ == "Network")
self.send(network.session("host-first"), network.session("host-second"), "host queue check")
self.assertTrue(queued.wait(5))
self.assertEqual(accepted[0]["session_key"], "real-host-second")
self.assertIn("host queue check", accepted[0]["content"])
self.assert_acknowledged(network.session("host-second"), network)
manager.unload("reason-network")
self.assertFalse(network._sessions)
finally:
manager.unload("reason-network")
reset_session_cwd(token)
if previous is None:
os.environ.pop("HERMES_HOME", None)
else:
os.environ["HERMES_HOME"] = previous
if __name__ == "__main__":
unittest.main(verbosity=2)