A self-improving RLM agent for coding workflows and long-running autonomous tasks.
Rust
#!/usr/bin/env python3
"""Lightweight check tests; these never start a product binary."""
import copy
import http.client
import json
from pathlib import Path
import socket
import tempfile
import threading
import unittest
import check_live_mcp as check
class VerifierTests(unittest.TestCase):
def observation(self):
return {'before': {'pid': 10, 'configs': {'fixture-before': check.BEFORE, 'fixture-after': {}}},
'after': {'pid': 10, 'configs': {'fixture-before': {}, 'fixture-after': check.AFTER}}}
def test_rejects_stale_and_rebuilt_handler(self):
good = self.observation()
check.validate_observation(good)
stale = self.observation()
stale['after']['configs'] = copy.deepcopy(stale['before']['configs'])
with self.assertRaises(AssertionError):
check.validate_observation(stale)
rebuilt = self.observation()
rebuilt['after']['pid'] = 11
with self.assertRaises(AssertionError):
check.validate_observation(rebuilt)
def test_provider_selects_offered_tool_and_requires_actual_result(self):
server = check.Server()
thread = threading.Thread(target=server.serve_forever, daemon=True)
thread.start()
try:
connection = http.client.HTTPConnection(*server.server_address, timeout=3)
first = {'tools': [{'type': 'function', 'function': {'name': 'python_repl'}}], 'messages': []}
connection.request('POST', '/v1/chat/completions', json.dumps(first), {'Content-Type': 'application/json'})
response = connection.getresponse()
wire = response.read().decode()
self.assertEqual(response.status, 200)
event = json.loads(wire.splitlines()[0].removeprefix('data: '))
function = event['choices'][0]['delta']['tool_calls'][0]['function']
self.assertEqual(function, {'name': 'python_repl', 'arguments': json.dumps({'code': check.CELL})})
with self.assertRaises(AssertionError):
check.latest_probe(server.requests['before'])
actual = self.observation()['before']
second = {'messages': [{'role': 'tool', 'content': check.MARKER + json.dumps(actual)}]}
connection.request('POST', '/v1/chat/completions', json.dumps(second), {'Content-Type': 'application/json'})
connection.getresponse().read()
self.assertEqual(check.latest_probe(server.requests['before']), actual)
connection.close()
finally:
server.shutdown()
server.server_close()
thread.join(timeout=2)
def test_after_probe_selects_latest_result_in_history(self):
before, after = self.observation()['before'], self.observation()['after']
old = {'role': 'tool', 'content': check.MARKER + json.dumps(before)}
new = {'role': 'tool', 'content': [{'type': 'text', 'text': check.MARKER + json.dumps(after)}]}
requests = [{'messages': [old]}, {'messages': [old, new]}]
self.assertEqual(check.latest_probe(requests), after)
def test_jsonl_client_preserves_fragmented_frames_and_protocol(self):
errors = []
with tempfile.TemporaryDirectory() as directory:
path = Path(directory) / 'test.sock'
listener = socket.socket(socket.AF_UNIX)
listener.bind(str(path))
listener.listen(1)
protocol = {'name': 'prime-agent.daemon', 'version': 7}
def serve():
try:
with listener.accept()[0] as connection:
greeting = json.dumps({'type': 'daemon_hello', 'protocol': protocol}).encode() + b'\n'
connection.sendall(greeting[:5])
connection.sendall(greeting[5:])
envelope = json.loads(connection.makefile('rb').readline())
assert envelope['protocol'] == protocol
assert envelope['command'] == {'type': 'reload'}
response = {'type': 'response', 'id': envelope['id'], 'success': True, 'data': {'ok': 1}}
connection.sendall(b'{"type":"session_event"}\n' + json.dumps(response).encode() + b'\n')
except Exception as error:
errors.append(error)
thread = threading.Thread(target=serve)
thread.start()
process = type('Process', (), {'poll': lambda self: None})()
client = check.Client(path, process)
try:
self.assertEqual(client.request({'type': 'reload'}), {'ok': 1})
self.assertEqual(len(client.frames), 3)
finally:
client.socket.close()
thread.join(timeout=3)
listener.close()
self.assertFalse(thread.is_alive())
self.assertEqual(errors, [])
if __name__ == '__main__':
unittest.main()