Something went wrong. Try again.
Personal fork of prime agent. Mirror of: https://mnemosyne.sigilzero.dev/sigilzero/prime-agent
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490//! Client-command dispatch during a live turn (the 2026-09-22 dogfood: `/system-prompt`//! timing out at the 10s client cap): a client command must answer fast while a turn//! streams (TS bar: a synchronous read on the event loop); the mock holds the turn//! open, so every measurement runs provably mid-flight.#![allow(clippy::large_futures)]// 64-bit-only targets; the narrowing casts sit at bounded OS boundaries.#![allow( clippy::cast_possible_truncation, clippy::cast_possible_wrap, clippy::cast_sign_loss, clippy::cast_precision_loss)]// Fn length is a style gate, not correctness.#![allow(clippy::too_many_lines)]// API-shape opinions, not defects; the surfaces are deliberate.#![allow( clippy::unnecessary_wraps, clippy::zero_sized_map_values, clippy::struct_excessive_bools, clippy::struct_field_names)]#![cfg(unix)]
use std::fmt::Write as _;use std::io::{BufRead, BufReader, Read, Write};use std::net::{TcpListener, TcpStream};use std::path::{Path, PathBuf};use std::process::{Child, Command, Stdio};use std::sync::{Arc, Mutex};use std::time::{Duration, Instant};
use serde_json::{json, Value};
/// How long the mock holds the turn between its first chunk and the finish chunk:/// must exceed the TUI's 10s `UI_REQUEST_TIMEOUT_MS` so a serialized dispatch/// reproduces the dogfood failure.const TURN_HOLD_MS: u64 = 12_000;/// The bar for "fast mid-turn" (the TS reference answers in single-digit ms; generous CI margin).const FAST_RESPONSE_MS: u64 = 2_000;
struct Supervisor { child: Child, #[allow(dead_code)] socket: PathBuf,}
impl Drop for Supervisor { fn drop(&mut self) { let _ = self.child.kill(); let _ = self.child.wait(); }}
/// A mock that streams one chunk, sleeps `TURN_HOLD_MS`, then finishes: the/// session is provably mid-turn for the whole sleep window.struct SlowMock { requests: Arc<Mutex<usize>>, port: u16,}
impl SlowMock { fn start() -> SlowMock { let requests = Arc::new(Mutex::new(0usize)); let listener = TcpListener::bind("127.0.0.1:0").expect("bind mock"); let port = listener.local_addr().expect("mock addr").port(); let requests_for_thread = Arc::clone(&requests); std::thread::spawn(move || { for stream in listener.incoming() { let Ok(stream) = stream else { continue }; let requests = Arc::clone(&requests_for_thread); std::thread::spawn(move || { let _ = serve(stream, &requests); }); } }); SlowMock { requests, port } }
fn url(&self) -> String { format!("http://127.0.0.1:{}/v1", self.port) }
fn count(&self) -> usize { *self.requests.lock().expect("mock lock") }}
fn chunk(delta: &Value, finish_reason: Option<&str>) -> String { json!({ "id": "chatcmpl-test", "object": "chat.completion.chunk", "created": 1_750_000_000, "model": "mock-1", "choices": [{"index": 0, "delta": delta, "finish_reason": finish_reason}], }) .to_string()}
fn serve(mut stream: TcpStream, requests: &Arc<Mutex<usize>>) -> std::io::Result<()> { let mut reader = BufReader::new(stream.try_clone()?); let mut head = String::new(); loop { let mut line = String::new(); if reader.read_line(&mut line)? == 0 { return Ok(()); } head.push_str(&line); if line == "\r\n" { break; } } let mut content_length = 0usize; for line in head.lines() { let lower = line.to_ascii_lowercase(); if let Some(value) = lower.strip_prefix("content-length:") { content_length = value.trim().parse().unwrap_or_default(); } } let mut body_bytes = vec![0u8; content_length]; if content_length > 0 { reader.read_exact(&mut body_bytes)?; } let mut request = head.lines().next().unwrap_or_default().split_whitespace(); let method = request.next().unwrap_or_default(); let path = request.next().unwrap_or_default(); if method == "GET" && path == "/v1/models" { let body = r#"{"data":[]}"#; return stream.write_all( format!( "HTTP/1.1 200 OK\r\nContent-Type: application/json\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}", body.len() ) .as_bytes(), ); } if method != "POST" || path != "/v1/chat/completions" { return stream.write_all( b"HTTP/1.1 404 Not Found\r\nContent-Length: 0\r\nConnection: close\r\n\r\n", ); } { let mut requests = requests.lock().expect("mock lock"); *requests += 1; } // The first chunk goes out immediately so the `message_start` streams; the sleep // holds the turn open mid-stream. let mut payload = String::new(); write!( payload, "data: {}\n\n", chunk(&json!({"role": "assistant", "content": "streaming"}), None) ) .expect("write to String"); stream.write_all( format!( "HTTP/1.1 200 OK\r\nContent-Type: text/event-stream\r\nConnection: close\r\n\r\n{payload}" ) .as_bytes(), )?; std::thread::sleep(Duration::from_millis(TURN_HOLD_MS)); let mut tail = String::new(); write!(tail, "data: {}\n\n", chunk(&json!({}), Some("stop"))).expect("write to String"); tail.push_str("data: [DONE]\n\n"); stream.write_all(tail.as_bytes())}
#[allow(clippy::zombie_processes)]fn spawn_supervisor(socket: &Path, agent_dir: &Path) -> Supervisor { std::fs::create_dir_all(agent_dir).expect("agent dir"); let child = Command::new(env!("CARGO_BIN_EXE_pa-daemon")) .arg("supervisor") .arg("--socket") .arg(socket) .arg("--agent-dir") .arg(agent_dir) .stdin(Stdio::null()) .stdout(Stdio::null()) .stderr(Stdio::null()) .env_remove("PRIME_API_KEY") .env_remove("PRIME_AGENT_CODING_AGENT_DIR") .env( pa_daemon::worker::WORKER_SUPERVISOR_LOST_EXIT_MS_ENV, "15000", ) .spawn() .expect("spawn pa-daemon supervisor"); let deadline = Instant::now() + Duration::from_secs(10); while Instant::now() < deadline { if socket.exists() { return Supervisor { child, socket: socket.to_path_buf(), }; } std::thread::sleep(Duration::from_millis(20)); } panic!("supervisor socket never appeared");}
/// One client connection: request/response plus the session events that stream while a response is/// outstanding.struct Client { reader: BufReader<std::os::unix::net::UnixStream>, writer: std::os::unix::net::UnixStream, events: Vec<Value>,}
impl Client { fn connect(socket: &Path) -> Client { let stream = std::os::unix::net::UnixStream::connect(socket).expect("connect"); let writer = stream.try_clone().expect("clone"); let mut client = Client { reader: BufReader::new(stream), writer, events: Vec::new(), }; let hello = client.read_line(); assert_eq!(hello["type"], "daemon_hello"); client }
fn read_line(&mut self) -> Value { let mut line = String::new(); let deadline = Instant::now() + Duration::from_mins(2); self.reader .get_mut() .set_read_timeout(Some(Duration::from_millis(100))) .expect("timeout"); loop { match self.reader.read_line(&mut line) { Ok(0) => panic!("supervisor closed the connection"), Ok(_) if line.trim().is_empty() => line.clear(), Ok(_) => return serde_json::from_str(line.trim()).expect("parse line"), Err(_) => { assert!( Instant::now() < deadline, "timed out waiting for supervisor line" ); } } } }
fn send_command(&mut self, id: &str, command: &Value) { let envelope = json!({ "type": "command", "id": id, "protocol": { "name": "prime-agent.daemon", "version": 7 }, "command": command, }); let mut line = serde_json::to_string(&envelope).expect("serialize"); line.push('\n'); self.writer .write_all(line.as_bytes()) .unwrap_or_else(|error| panic!("write command {id}: {error}")); }
/// Send a command and measure the time until its response; session events /// observed on the way are collected like [`Self::request`]. fn timed_request(&mut self, id: &str, command: &Value) -> (Value, Duration) { let started = Instant::now(); self.send_command(id, command); let response = self.request(id); (response, started.elapsed()) }
fn request(&mut self, id: &str) -> Value { let deadline = Instant::now() + Duration::from_mins(2); loop { assert!(Instant::now() < deadline, "no response for id {id}"); let line = self.read_line(); if line.get("id").and_then(Value::as_str) == Some(id) { return line; } self.collect_event(&line); } }
fn collect_event(&mut self, line: &Value) { if line.get("type").and_then(Value::as_str) == Some("session_event") { self.events.push(line["event"].clone()); } }
/// Block until the run settles (`agent_end`), long after the mid-turn measurements: /// the mock's hold window outlasts them, so a quiet-drain would stop while the /// turn still streams. fn wait_for_settled(&mut self) { let deadline = Instant::now() + Duration::from_mins(1); loop { assert!(Instant::now() < deadline, "the turn never settled"); let line = self.read_line(); let settled = line.get("type").and_then(Value::as_str) == Some("session_event") && line["event"]["type"].as_str() == Some("agent_end"); self.collect_event(&line); if settled { return; } } }
/// Block until the stream shows the given event shape (a session event whose /// `message.role` matches), collecting everything on the way. fn wait_for_event(&mut self, role: &str) { let deadline = Instant::now() + Duration::from_secs(30); loop { assert!(Instant::now() < deadline, "no assistant start streamed"); let line = self.read_line(); let is_match = line.get("type").and_then(Value::as_str) == Some("session_event") && line["event"]["message"]["role"].as_str() == Some(role) && line["event"]["type"].as_str() == Some("message_start"); self.collect_event(&line); if is_match { return; } } }}
struct Measurement { command: String, elapsed: Duration, success: bool,}
fn info_command(name: &str, session_id: &str) -> Value { json!({ "type": name, "activeSessionId": session_id, })}
/// The client command family the TUI serves through its 10s/// `UI_REQUEST_TIMEOUT_MS` bound, plus the same-route getters it refreshes.const MATRIX: &[(&str, &str)] = &[ ("get_session_stats", "/session"), ("get_context_tree", "/context, /usage"), ("get_session_context", "wire: get_session_context"), ("get_system_prompt", "/system-prompt"), ("get_tool_definition", "wire: get_tool_definition"), ("get_resource_snapshot", "wire: get_resource_snapshot"),];
fn run_matrix(client: &mut Client, session_id: &str, phase: &str) -> Vec<Measurement> { let mut measurements = Vec::new(); for (index, (command, surface)) in MATRIX.iter().enumerate() { let id = format!("matrix-{phase}-{index}"); let mut command_value = info_command(command, session_id); if *command == "get_tool_definition" { command_value["name"] = json!("bash"); } let (response, elapsed) = client.timed_request(&id, &command_value); measurements.push(Measurement { command: format!("{command} ({surface})"), elapsed, success: response["success"] == json!(true), }); } measurements}
fn print_table(phase: &str, measurements: &[Measurement]) { println!("== response-time table ({phase}) =="); for measurement in measurements { println!( "{:<40} {:>8.0} ms {}", measurement.command, measurement.elapsed.as_millis(), if measurement.success { "ok" } else { "FAILED" } ); }}
#[test]fn client_commands_answer_fast_while_a_turn_streams() { let dir = tempfile::TempDir::new().expect("temp dir"); let agent_dir = dir.path().join("agent"); let session_dir = agent_dir.join("sessions"); std::fs::create_dir_all(&session_dir).expect("session dir"); let mock = SlowMock::start(); std::fs::write( agent_dir.join("models.json"), json!({ "providers": { "prime-inference": { "api": "openai-completions", "baseUrl": mock.url(), "apiKey": "sk-battery", "models": [ { "id": "mock-1", "name": "Mock 1", "api": "openai-completions", "contextWindow": 128_000, "maxTokens": 4096 } ] } } }) .to_string(), ) .expect("write models.json"); std::fs::write( agent_dir.join("settings.json"), json!({ "onboardingCompleted": true }).to_string(), ) .expect("write settings.json"); let socket = dir.path().join("cmd-dispatch.sock"); let _supervisor = spawn_supervisor(&socket, &agent_dir); let mut client = Client::connect(&socket); client.send_command( "c1", &json!({ "type": "create", "config": { "cwd": dir.path().to_string_lossy(), "sessionDir": session_dir.to_string_lossy(), "provider": "prime-inference", "model": "mock-1", }, }), ); let created = client.request("c1"); assert_eq!(created["success"], true, "create failed: {created}"); let session_id = created["data"]["id"] .as_str() .or_else(|| created["data"]["sessionId"].as_str()) .expect("session id") .to_string(); client.send_command( "a1", &json!({ "type": "attach", "activeSessionId": session_id }), ); let attached = client.request("a1"); assert_eq!(attached["success"], true, "attach failed: {attached}");
let idle = run_matrix(&mut client, &session_id, "idle"); print_table("idle", &idle); for measurement in &idle { assert!(measurement.success, "idle {} failed", measurement.command); assert!( measurement.elapsed < Duration::from_millis(FAST_RESPONSE_MS), "idle {} took {:?}", measurement.command, measurement.elapsed ); }
// Phase 2: a turn holds open mid-stream, then the same matrix runs while the // assistant message is streaming (the dogfood window). client.send_command( "p1", &json!({ "type": "prompt", "activeSessionId": session_id, "message": "hello" }), ); let queued = client.request("p1"); assert_eq!(queued["success"], true, "prompt rejected: {queued}"); client.wait_for_event("assistant"); assert_eq!(mock.count(), 1, "one provider request mid-turn");
let mid_turn = run_matrix(&mut client, &session_id, "mid-turn"); print_table("mid-turn", &mid_turn); for measurement in &mid_turn { assert!( measurement.success, "mid-turn {} failed", measurement.command ); assert!( measurement.elapsed < Duration::from_millis(FAST_RESPONSE_MS), "mid-turn {} took {:?} — serialized behind the streaming turn (the TS bar: commands interleave with the turn loop)", measurement.command, measurement.elapsed ); }
client.wait_for_settled(); let types = client .events .iter() .filter_map(|event| event.get("type").and_then(Value::as_str)) .map(str::to_string) .collect::<Vec<_>>(); assert!( types.iter().any(|t| t == "agent_end"), "the turn never settled: {types:?}" ); assert_eq!(mock.count(), 1, "still one provider request");}