Skip to content

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.md
new file mode 100644
index 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.yml
index 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; do
verifier="scripts/review_${scenario}_parity.py"
if [ -f "${verifier}" ]; then
if [ "${scenario}" = "draft_disconnect" ]; then
python3 scripts/test_review_draft_disconnect_parity.py || comparison_status=1
fi
+ if [ "${scenario}" = "live_mcp" ]; then
+ python3 scripts/test_review_live_mcp_parity.py || comparison_status=1
+ fi
python3 "${verifier}" --receipt "${RUNNER_TEMP}/lifecycle-parity-receipts/${scenario}.json" || comparison_status=1
fi
done
diff --git a/crates/pa-cli/src/print_runtime.rs b/crates/pa-cli/src/print_runtime.rs
index 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.rs
index 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.py
new file mode 100644
index 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.py
new file mode 100644
index 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()