A self-improving RLM agent for coding workflows and long-running autonomous tasks.
Rust
serve live integrations from the kernel mcp.config host request (#3570)
Sebastian Müller6e2ff2559b4c
diff --git a/.changes/mcp-config-live-integrations.md b/.changes/mcp-config-live-integrations.mdnew file mode 100644index 0000000000..502e24efa9--- /dev/null+++ b/.changes/mcp-config-live-integrations.md@@ -0,0 +1 @@+- `mcp.config` host requests now resolve integrations live: an MCP server connected or configured mid-session (e.g. through `/mcp`) is dispatchable from the kernel without restarting the session.diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.ymlindex 3e6943f64b..738050247a 100644--- a/.github/workflows/ci.yml+++ b/.github/workflows/ci.yml@@ -371,12 +371,15 @@ jobs:test -x "${PRIME_AGENT_KERNEL_PYTHON}"mkdir -p "${RUNNER_TEMP}/lifecycle-parity-receipts"comparison_status=0- for scenario in graceful_shutdown goal_backoff draft_disconnect restore_notice; do+ for scenario in graceful_shutdown goal_backoff draft_disconnect restore_notice live_mcp; doverifier="scripts/review_${scenario}_parity.py"if [ -f "${verifier}" ]; thenif [ "${scenario}" = "draft_disconnect" ]; thenpython3 scripts/test_review_draft_disconnect_parity.py || comparison_status=1fi+ if [ "${scenario}" = "live_mcp" ]; then+ python3 scripts/test_review_live_mcp_parity.py || comparison_status=1+ fipython3 "${verifier}" --receipt "${RUNNER_TEMP}/lifecycle-parity-receipts/${scenario}.json" || comparison_status=1fidonediff --git a/crates/pa-cli/src/print_runtime.rs b/crates/pa-cli/src/print_runtime.rsindex 55a7a98249..6aa8877b4d 100644--- a/crates/pa-cli/src/print_runtime.rs+++ b/crates/pa-cli/src/print_runtime.rs@@ -1937,24 +1937,24 @@ mod tests {);}let result = config(pa_core::kernel::shared::HostRequestPayload {- data: serde_json::json!({ "server": "fixture-echo" }),+ data: serde_json::json!({ "server": "second-echo" }),cell_source_code: None,}).await.unwrap();assert_eq!(- result["command"], "python3",- "the registered handler serves its registration-time integrations"+ result["command"], "node",+ "the already-registered handler serves the live integrations");- let missing = config(pa_core::kernel::shared::HostRequestPayload {- data: serde_json::json!({ "server": "second-echo" }),+ let withdrawn = config(pa_core::kernel::shared::HostRequestPayload {+ data: serde_json::json!({ "server": "fixture-echo" }),cell_source_code: None,}).await.unwrap();assert!(- missing.as_object().unwrap().is_empty(),- "the pre-refresh handler does not know the new server"+ withdrawn.as_object().unwrap().is_empty(),+ "the rewrite withdrew the old server from the live integrations");}diff --git a/crates/pa-core/src/mcp/mod.rs b/crates/pa-core/src/mcp/mod.rsindex 18529b006f..395724de32 100644--- a/crates/pa-core/src/mcp/mod.rs+++ b/crates/pa-core/src/mcp/mod.rs@@ -567,8 +567,8 @@ impl McpManager {/// Register the `mcp.*` host-request handlers: `refresh`/`config`/`begin_login` dispatch/// plumbing plus the inventory surface the kernel's generic `mcp` module reaches for.///- /// The inventory handlers capture this manager so each request serves LIVE views; view- /// computation reads the blocking auth-store snapshot.+ /// The `config` and inventory handlers capture this manager so each request serves+ /// live views; inventory view computation reads the blocking auth-store snapshot.////// # Panics///@@ -606,22 +606,13 @@ impl McpManager {Ok(number.min(max_limit as u64) as usize)}- let (- auth,- acp_servers,- usage_refresh,- acp_servers_for_config,- integrations,- usage_config,- begin_login,- ) = {+ let (auth, acp_servers, usage_refresh, acp_servers_for_config, usage_config, begin_login) = {let manager = manager.lock().unwrap();(manager.auth_storage.clone(),manager.acp_servers.clone(),manager.usage_report.clone(),manager.acp_servers.clone(),- manager.integrations.clone(),manager.usage_report.clone(),manager.begin_login.clone(),)@@ -666,10 +657,11 @@ impl McpManager {})}),);+ let manager_for_config = std::sync::Arc::clone(manager);handlers.register("mcp.config",host_handler(move |payload| {- let integrations = integrations.clone();+ let manager = std::sync::Arc::clone(&manager_for_config);let acp_servers = acp_servers_for_config.clone();let usage_config = usage_config.clone();Box::pin(async move {@@ -693,7 +685,11 @@ impl McpManager {}return Ok(config);}- let Some(integration) = integrations.get(&server) else {+ let integration = {+ let manager = manager.lock().unwrap();+ manager.integrations.get(&server).cloned()+ };+ let Some(integration) = integration else {return Ok(json!({}));};if !integration.user_declared {diff --git a/scripts/review_live_mcp_parity.py b/scripts/review_live_mcp_parity.pynew file mode 100644index 0000000000..a090cf9a40--- /dev/null+++ b/scripts/review_live_mcp_parity.py@@ -0,0 +1,292 @@+#!/usr/bin/env python3+"""Compare real TS/Rust kernel mcp.config before and after a live settings reload.++Both owned daemon binaries execute identical cells through an offline provider.+The shared public reload command refreshes settings between probes. Rust must+keep its kernel (and already registered host handler) alive; TS's reload rebuild+is recorded explicitly. Exact config objects are compared without filtering.+"""+import argparse+import http.server+import json+import os+from pathlib import Path+import signal+import socket+import subprocess+import sys+import tempfile+import threading+import time++from review_goal_backoff_parity import TS_ARCHIVE_SHA256, sha256+from review_restore_notice_parity import texts++MARKER = 'LIVE_MCP_PARITY_RESULT='+CELL = """import os, json+from rlm import host_request+live_mcp_result = {'pid': os.getpid(), 'configs': {}}+for live_mcp_name in ['fixture-before', 'fixture-after']:+ live_mcp_result['configs'][live_mcp_name] = await host_request('mcp.config', {'server': live_mcp_name})+print('LIVE_MCP_PARITY_RESULT=' + json.dumps(live_mcp_result))"""+BEFORE = {'type': 'stdio', 'command': 'python3', 'args': ['-c', 'print("before")']}+AFTER = {'type': 'stdio', 'command': 'python3', 'args': ['-c', 'print("after")']}+++def latest_probe(requests):+ # Later turns carry earlier tool results in history. The final request+ # must contain this phase's newly executed cell, not the old marker.+ assert requests, 'missing provider requests'+ for message in reversed(requests[-1].get('messages', [])):+ if message.get('role') != 'tool':+ continue+ for text in reversed(list(texts(message.get('content')))):+ for line in reversed(text.splitlines()):+ if line.startswith(MARKER):+ return json.loads(line[len(MARKER):])+ raise AssertionError('missing actual tool result ' + MARKER)+++class Server(http.server.ThreadingHTTPServer):+ daemon_threads = True++ def __init__(self):+ super().__init__(('127.0.0.1', 0), Handler)+ self.phase = 'before'+ self.requests = {'before': [], 'after': []}+ self.tools = {}+ self.errors = []+++class Handler(http.server.BaseHTTPRequestHandler):+ def log_message(self, *_args):+ pass++ def do_POST(self):+ if self.path != '/v1/chat/completions':+ self.send_error(404)+ return+ body = json.loads(self.rfile.read(int(self.headers['Content-Length'])))+ requests = self.server.requests[self.server.phase]+ requests.append(body)+ if len(requests) == 1:+ offered = {tool.get('function', {}).get('name') for tool in body.get('tools', [])}+ name = next((name for name in ('python_repl', 'ipython') if name in offered), None)+ if name is None:+ self.server.errors.append('No supported REPL tool offered')+ self.send_error(422)+ return+ self.server.tools[self.server.phase] = name+ delta = {'tool_calls': [{'index': 0, 'id': 'call_live_mcp_' + self.server.phase,+ 'type': 'function', 'function': {'name': name,+ 'arguments': json.dumps({'code': CELL})}}]}+ finish = 'tool_calls'+ elif len(requests) == 2:+ delta, finish = {'content': 'Live MCP probe complete.'}, 'stop'+ else:+ self.server.errors.append('Unexpected extra provider request')+ self.send_error(422)+ return+ def chunk(value, reason=None):+ return {'id': 'live-mcp-parity', 'object': 'chat.completion.chunk', 'created': 1,+ 'model': 'mcp-fixture', 'choices': [{'index': 0, 'delta': value,+ 'finish_reason': reason}]}+ wire = ''.join('data: ' + json.dumps(item) + '\n\n' for item in (+ chunk({'role': 'assistant', **delta}), chunk({}, finish))) + 'data: [DONE]\n\n'+ self.send_response(200)+ self.send_header('Content-Type', 'text/event-stream')+ self.send_header('Content-Length', str(len(wire.encode())))+ self.end_headers()+ self.wfile.write(wire.encode())+++class Client:+ """Bounded JSONL client using each real daemon's advertised protocol."""+ def __init__(self, path, process):+ self.frames = []+ self.buffer = b''+ deadline = time.monotonic() + 45+ while time.monotonic() < deadline:+ if process.poll() is not None:+ raise RuntimeError('daemon exited before socket readiness')+ connection = socket.socket(socket.AF_UNIX)+ try:+ connection.connect(str(path))+ self.socket = connection+ break+ except (FileNotFoundError, ConnectionRefusedError):+ connection.close()+ threading.Event().wait(0.025)+ else:+ raise TimeoutError('daemon socket readiness')+ self.hello = self.read(deadline)+ assert self.hello.get('type') == 'daemon_hello', self.hello+ self.protocol = self.hello['protocol']+ self.sequence = 0++ def read(self, deadline):+ while b'\n' not in self.buffer:+ remaining = deadline - time.monotonic()+ if remaining <= 0:+ raise TimeoutError('daemon response deadline')+ self.socket.settimeout(remaining)+ data = self.socket.recv(65536)+ if not data:+ raise RuntimeError('daemon closed socket')+ self.buffer += data+ line, self.buffer = self.buffer.split(b'\n', 1)+ frame = json.loads(line)+ self.frames.append(frame)+ return frame++ def request(self, command):+ self.sequence += 1+ request_id = 'live-mcp-' + str(self.sequence)+ envelope = {'type': 'command', 'id': request_id,+ 'protocol': self.protocol, 'command': command}+ self.socket.sendall((json.dumps(envelope) + '\n').encode())+ deadline = time.monotonic() + 90+ while True:+ frame = self.read(deadline)+ if frame.get('type') == 'response' and frame.get('id') == request_id:+ assert frame.get('success') is True, frame+ return frame.get('data') or {}+++def stop(process):+ # Signal only the owned process group; the fixture never touches live services.+ try:+ os.killpg(process.pid, signal.SIGTERM)+ except ProcessLookupError:+ return+ try:+ process.wait(timeout=5)+ except subprocess.TimeoutExpired:+ os.killpg(process.pid, signal.SIGKILL)+ process.wait(timeout=5)+++def validate_observation(observation, label):+ assert observation['before']['configs'] == {'fixture-before': BEFORE, 'fixture-after': {}}, observation['before']+ assert observation['after']['configs'] == {'fixture-before': {}, 'fixture-after': AFTER}, observation['after']+ observation['kernel_pid_equal'] = observation['before']['pid'] == observation['after']['pid']+ if label == 'rust':+ assert observation['kernel_pid_equal'], 'Rust replaced the kernel; stale-handler regression was not exercised'+++def run_case(binary, label, root, observation):+ for name in ('home', 'agent', 'sessions', 'work', 'tmp'):+ (root / name).mkdir(parents=True)+ agent, cwd = root / 'agent', root / 'work'+ env = {key: os.environ[key] for key in ('PATH', 'LANG', 'LC_ALL', 'TZ',+ 'PRIME_AGENT_KERNEL_PYTHON', 'PA_E2E_KERNEL_PYTHON') if key in os.environ}+ if label == 'ts':+ env['PI_PACKAGE_DIR'] = os.environ['PI_PACKAGE_DIR']+ library = Path(os.environ['PI_PACKAGE_DIR']) / 'skills'+ env['PYTHONPATH'] = os.pathsep.join(sorted(str(p) for p in library.glob('*/src') if p.is_dir()))+ env.update(HOME=str(root / 'home'), TMPDIR=str(root / 'tmp'), DO_NOT_TRACK='1',+ PI_OFFLINE='1', PI_CODING_AGENT_DIR=str(agent),+ PRIME_AGENT_CODING_AGENT_DIR=str(agent), PI_SESSION_DIR=str(root / 'sessions'),+ PRIME_AGENT_SESSION_DIR=str(root / 'sessions'), XDG_CONFIG_HOME=str(root / 'config'),+ XDG_CACHE_HOME=str(root / 'cache'), XDG_DATA_HOME=str(root / 'data'))+ settings = {'defaultProvider': 'fixture', 'defaultModel': 'mcp-fixture',+ 'prewarmPythonKernel': False, 'mcpServers': {'fixture-before': BEFORE}}+ settings_path = agent / 'settings.json'+ settings_path.write_text(json.dumps(settings))+ server = Server()+ thread = threading.Thread(target=server.serve_forever, daemon=True)+ thread.start()+ (agent / 'models.json').write_text(json.dumps({'providers': {'fixture': {+ 'api': 'openai-completions', 'apiKey': 'fixture-only',+ 'baseUrl': 'http://127.0.0.1:%s/v1' % server.server_address[1],+ 'models': [{'id': 'mcp-fixture', 'name': 'MCP fixture', 'reasoning': False,+ 'contextWindow': 128000, 'maxTokens': 4096}]}}}))+ path = root / 'daemon.sock'+ client = None+ active = None+ with (root / 'daemon.log').open('w') as log:+ process = subprocess.Popen([str(binary), '--mode', 'daemon', '--daemon-socket', str(path)],+ cwd=cwd, env=env, stdout=log, stderr=subprocess.STDOUT,+ start_new_session=True)+ try:+ client = Client(path, process)+ created = client.request({'type': 'create', 'config': {'cwd': str(cwd),+ 'sessionDir': str(root / 'sessions'), 'provider': 'fixture', 'model': 'mcp-fixture'}})+ active = created.get('activeSessionId') or created.get('sessionId') or created.get('id')+ assert active, created+ client.request({'type': 'attach', 'activeSessionId': active})+ for phase in ('before', 'after'):+ server.phase = phase+ if phase == 'after':+ settings['mcpServers'] = {'fixture-after': AFTER}+ settings_path.write_text(json.dumps(settings))+ # Identical public command to both runtimes. Rust does not+ # rebuild the core: the same registered handler must read live.+ client.request({'type': 'reload', 'activeSessionId': active})+ client.request({'type': 'prompt', 'activeSessionId': active,+ 'message': 'Probe live MCP configuration: ' + phase})+ client.request({'type': 'wait_for_idle', 'activeSessionId': active})+ observation[phase] = latest_probe(server.requests[phase])+ assert not server.errors, server.errors+ assert {k: len(v) for k, v in server.requests.items()} == {'before': 2, 'after': 2}+ validate_observation(observation, label)+ finally:+ if client is not None:+ if active is not None:+ try:+ client.request({'type': 'kill', 'activeSessionId': active})+ except Exception as error:+ observation['cleanup_error'] = str(error)+ observation['daemon_frames'] = client.frames+ client.socket.close()+ stop(process)+ server.shutdown()+ server.server_close()+ thread.join(timeout=2)+ observation['provider_requests'] = server.requests+ observation['offered_repl_tools'] = server.tools+ observation['daemon_log'] = (root / 'daemon.log').read_text()+++def main():+ parser = argparse.ArgumentParser(description=__doc__)+ parser.add_argument('--receipt', type=Path, required=True)+ args = parser.parse_args()+ result = {'verified': False, 'runs': {}, 'comparison': 'Exact mcp.config objects before/after public reload',+ 'kernel_lifecycle_scope': 'TS reload may rebuild; Rust must keep the existing kernel/host handler.',+ 'tool_name_selection': 'Offered python_repl or legacy ipython; identical cell code.'}+ try:+ assert sys.platform == 'linux', 'requires hosted Linux CI'+ archive_hash = sha256(os.environ['PA_TS_ARCHIVE'])+ result['ts_release_archive_sha256'] = archive_hash+ assert archive_hash == TS_ARCHIVE_SHA256, 'TS release archive hash mismatch'+ binaries = {label: Path(os.environ['PA_' + label.upper() + '_BINARY']).resolve()+ for label in ('ts', 'rust')}+ result['binaries'] = {label: {'path': str(path), 'sha256': sha256(path)}+ for label, path in binaries.items()}+ with tempfile.TemporaryDirectory(prefix='live-mcp-parity-') as temp:+ for label, binary in binaries.items():+ observation = {}+ result['runs'][label] = observation+ try:+ run_case(binary, label, Path(temp) / label, observation)+ except Exception as error:+ observation['error'] = str(error)+ errors = {label: value['error'] for label, value in result['runs'].items() if 'error' in value}+ assert not errors, errors+ cleanup_errors = {label: value['cleanup_error'] for label, value in result['runs'].items()+ if 'cleanup_error' in value}+ assert not cleanup_errors, cleanup_errors+ for phase in ('before', 'after'):+ assert result['runs']['ts'][phase]['configs'] == result['runs']['rust'][phase]['configs']+ result['verified'] = True+ except Exception as error:+ result['error'] = str(error)+ args.receipt.parent.mkdir(parents=True, exist_ok=True)+ args.receipt.write_text(json.dumps(result, indent=2) + '\n')+ print(json.dumps({'receipt': str(args.receipt), 'verified': result['verified'], 'error': result.get('error')}))+ return 0 if result['verified'] else 1+++if __name__ == '__main__':+ sys.exit(main())diff --git a/scripts/test_review_live_mcp_parity.py b/scripts/test_review_live_mcp_parity.pynew file mode 100644index 0000000000..1ee6f580d8--- /dev/null+++ b/scripts/test_review_live_mcp_parity.py@@ -0,0 +1,105 @@+#!/usr/bin/env python3+"""Lightweight verifier tests; these do not claim binary parity."""+import copy+import http.client+import json+from pathlib import Path+import socket+import tempfile+import threading+import unittest++import review_live_mcp_parity as parity+++class VerifierTests(unittest.TestCase):+ def observation(self):+ return {'before': {'pid': 10, 'configs': {'fixture-before': parity.BEFORE, 'fixture-after': {}}},+ 'after': {'pid': 10, 'configs': {'fixture-before': {}, 'fixture-after': parity.AFTER}}}++ def test_rejects_stale_and_rebuilt_rust_handler(self):+ good = self.observation()+ parity.validate_observation(good, 'rust')+ stale = self.observation()+ stale['after']['configs'] = copy.deepcopy(stale['before']['configs'])+ with self.assertRaises(AssertionError):+ parity.validate_observation(stale, 'rust')+ rebuilt = self.observation()+ rebuilt['after']['pid'] = 11+ with self.assertRaises(AssertionError):+ parity.validate_observation(rebuilt, 'rust')+ parity.validate_observation(rebuilt, 'ts')+ self.assertFalse(rebuilt['kernel_pid_equal'])++ def test_provider_selects_offered_tool_and_requires_actual_result(self):+ server = parity.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': parity.CELL})})+ with self.assertRaises(AssertionError):+ parity.latest_probe(server.requests['before'])+ actual = self.observation()['before']+ second = {'messages': [{'role': 'tool', 'content': parity.MARKER + json.dumps(actual)}]}+ connection.request('POST', '/v1/chat/completions', json.dumps(second), {'Content-Type': 'application/json'})+ connection.getresponse().read()+ self.assertEqual(parity.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': parity.MARKER + json.dumps(before)}+ new = {'role': 'tool', 'content': [{'type': 'text', 'text': parity.MARKER + json.dumps(after)}]}+ requests = [{'messages': [old]}, {'messages': [old, new]}]+ self.assertEqual(parity.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 = parity.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()