use std::sync::Arc;
use std::time::{Duration, Instant};
use durable::{SubmissionStatus, TaskId, TaskQuery, TaskRecord, TaskStatus};
use kernel::{HostHandler, Signal};
use serde_json::{Map, Value, json};
use super::children::{CHILD_KIND, ChildCheckpoint, ChildInput, child_done, child_report, spawn_child};
use super::{CellCall, ChatHarness, ModelRef, SubmissionDraft, WhenBusy};
use crate::scheduler::{Cancel, Ctx, HarnessError};
const POLL: Duration = Duration::from_millis(20);
pub(crate) const ASK_TIMEOUT: Duration = Duration::from_secs(20 * 60);
type OpResult = Result<Value, String>;
fn error(error: HarnessError) -> String {
error.message()
}
#[derive(Clone)]
pub struct HostOps {
chat: ChatHarness,
}
pub fn child_id(task: TaskId) -> String {
task.0.to_string()
}
fn parse_child(selector: &Value) -> Result<TaskId, String> {
let text = match selector {
Value::String(text) => text.clone(),
Value::Number(number) => number.to_string(),
other => return Err(format!("Unknown subagent selector {other}")),
};
text.parse::<u64>()
.map(TaskId)
.map_err(|_| format!("Unknown subagent {text}"))
}
fn parse_model(value: Option<&Value>) -> Result<Option<ModelRef>, String> {
match value {
None | Some(Value::Null) => Ok(None),
Some(Value::String(text)) => match text.split_once('/') {
Some((provider, model)) if model_scope::is_model_ref(text) => Ok(Some(ModelRef::new(provider, model))),
_ => Err(format!("rlm.spawn model must be provider/model, got {text}")),
},
Some(other) => Err(format!("rlm.spawn model must be a string, got {other}")),
}
}
pub const SWARM_KINDS: [&str; 12] = [
"swarm.register",
"swarm.agents",
"swarm.route",
"swarm.send",
"swarm.inbox",
"board.add",
"board.claim",
"board.update",
"board.list",
"notes.read",
"notes.append",
"notes.write",
];
#[derive(Clone, Copy)]
enum Op {
Spawn,
Collect,
Results,
List,
Cancel,
Ask,
Swarm,
}
impl Op {
fn of(kind: &str) -> Option<Op> {
Some(match kind {
"rlm.spawn" => Op::Spawn,
"rlm.collect" => Op::Collect,
"rlm.results" => Op::Results,
"rlm.list_subagents" => Op::List,
"rlm.cancel" | "rlm.delete_subagent" => Op::Cancel,
"rlm.ask" => Op::Ask,
kind if SWARM_KINDS.contains(&kind) => Op::Swarm,
_ => return None,
})
}
}
impl HostOps {
pub fn new(chat: ChatHarness) -> HostOps {
HostOps { chat }
}
pub fn handle(
&self,
kind: &str,
payload: &Map<String, Value>,
call: &CellCall,
signal: &Cancel,
) -> Option<OpResult> {
Some(match Op::of(kind)? {
Op::Spawn => self.spawn(payload, call),
Op::Collect => self.collect(payload, call, signal),
Op::Results => self.results(payload, call),
Op::List => self.list(call),
Op::Cancel => self.cancel(payload, signal),
Op::Ask => self.ask(payload, signal),
Op::Swarm => self.swarm(kind, payload, call),
})
}
pub fn handler(&self, call: CellCall, fallback: Option<Arc<dyn HostHandler>>) -> Arc<dyn HostHandler> {
Arc::new(CellOps {
ops: self.clone(),
call,
fallback,
})
}
fn spawn(&self, payload: &Map<String, Value>, call: &CellCall) -> OpResult {
let prompt = payload
.get("prompt")
.and_then(Value::as_str)
.filter(|prompt| !prompt.trim().is_empty())
.ok_or("rlm.spawn prompt must be a non-empty string")?;
let empty = Map::new();
let options = payload.get("kwargs").and_then(Value::as_object).unwrap_or(&empty);
let name = options
.get("name")
.and_then(Value::as_str)
.filter(|name| !name.trim().is_empty())
.ok_or("rlm.spawn name must be a non-empty string")?;
for (key, unset) in [
("worktree", &[Value::Null, Value::Bool(false)][..]),
("worktree_setup", &[Value::Null][..]),
("depth", &[Value::Null, json!(0)][..]),
("fork", &[Value::Null, Value::Bool(false)][..]),
] {
if let Some(value) = options.get(key)
&& !unset.contains(value)
{
return Err(format!(
"rlm.spawn(keep=True) does not support {key}=: a persistent child works in the session's directory without a worktree, nested subagents or a forked conversation; drop {key}= or spawn without keep=True"
));
}
}
let input = ChildInput {
name: name.to_owned(),
prompt: prompt.to_owned(),
model: parse_model(options.get("model"))?,
timeout_ms: options
.get("timeout_ms")
.and_then(Value::as_f64)
.map(|ms| ms.ceil() as u64),
keep: options.get("keep").and_then(Value::as_bool).unwrap_or(false)
|| payload.get("keep").and_then(Value::as_bool).unwrap_or(false),
thinking: options.get("thinking").and_then(Value::as_str).map(str::to_owned),
..ChildInput::default()
};
let conversation = call.conversation_id;
let cell = call.task_id;
let task = self
.chat
.commit(|tx| spawn_child(tx, conversation, Some(cell), &input))
.map_err(error)?;
let _ = self.chat.resume();
Ok(json!({
"rlm_child_id": child_id(task),
"name": input.name,
"session_dir": "",
"model": input.model.map(|model| format!("{}/{}", model.provider, model.model_id)).unwrap_or_default(),
"timeout_ms": input.timeout_ms.unwrap_or(0),
"parent_branch_anchor": "",
"worktree": Value::Null,
}))
}
fn children_of(&self, call: &CellCall) -> Result<Vec<TaskRecord>, String> {
let conversation = call.conversation_id;
self.chat
.commit(|tx| {
let query = TaskQuery {
conversation_id: Some(conversation),
kind: Some(CHILD_KIND.into()),
..TaskQuery::default()
};
let mut records = Vec::new();
let mut cursor = None;
loop {
let page = tx.committed(|storage| storage.scan_tasks(&query, 256, cursor.as_ref()))?;
records.extend(page.items);
match page.next {
Some(next) => cursor = Some(next),
None => break,
}
}
records.sort_by_key(|record| record.id);
Ok(records)
})
.map_err(error)
}
fn selected(&self, payload: &Map<String, Value>, call: &CellCall) -> Result<Vec<TaskId>, String> {
let selectors = payload
.get("selectors")
.and_then(Value::as_array)
.cloned()
.unwrap_or_default();
if selectors.is_empty() {
return Ok(self.children_of(call)?.iter().map(|record| record.id).collect());
}
selectors.iter().map(parse_child).collect()
}
fn record(&self, id: TaskId) -> Result<TaskRecord, String> {
match self.chat.get_task(id).map_err(error)? {
Some(record) if record.kind == CHILD_KIND => Ok(record),
_ => Err(format!("Unknown subagent {}", child_id(id))),
}
}
fn collect(&self, payload: &Map<String, Value>, call: &CellCall, signal: &Cancel) -> OpResult {
let ids = self.selected(payload, call)?;
let timeout = payload
.get("timeout_ms")
.and_then(Value::as_f64)
.filter(|ms| *ms > 0.0)
.map(|ms| Instant::now() + Duration::from_millis(ms as u64));
let mut results = Vec::new();
for id in ids {
loop {
let record = self.record(id)?;
if child_done(&record) {
results.extend(child_report(&record));
break;
}
if record.state.status() != TaskStatus::Terminal && !is_keep(&record) {
let (done, expired) = (Cancel::new(), Cancel::new());
let limit = timeout.map(|deadline| deadline.saturating_duration_since(Instant::now()));
let timer = limit.map(|limit| {
let (done, expired) = (done.clone(), expired.clone());
std::thread::spawn(move || {
if done.wait_timeout(limit).is_none() {
expired.cancel(HarnessError::msg("timeout"));
}
})
});
let linked = Cancel::any(&[signal, &expired]);
let waited = self.chat.wait_for_task(id, &Ctx::with_signal(linked.signal()));
done.abort();
if let Some(timer) = timer {
let _ = timer.join();
}
if waited.is_ok() {
continue;
}
}
if let Some(reason) = signal.reason() {
return Err(reason.message());
}
if timeout.is_some_and(|deadline| Instant::now() >= deadline) {
return Err(format!("Timed out waiting for subagent {}", child_id(id)));
}
signal.wait_timeout(POLL);
}
}
Ok(json!({ "results": results }))
}
fn results(&self, payload: &Map<String, Value>, call: &CellCall) -> OpResult {
let mut results = Vec::new();
let mut running = Vec::new();
for id in self.selected(payload, call)? {
let record = self.record(id)?;
match child_report(&record) {
Some(report) => results.push(report),
None => running.push(json!(child_id(id))),
}
}
Ok(json!({ "results": results, "running": running }))
}
fn list(&self, call: &CellCall) -> OpResult {
let children: Vec<Value> = self
.children_of(call)?
.iter()
.map(|record| {
let status = match record.state.status() {
TaskStatus::Terminal => "ended",
_ if is_keep(record) => "kept",
_ => "running",
};
json!({
"id": child_id(record.id),
"name": record.input["name"],
"keep": is_keep(record),
"status": status,
})
})
.collect();
Ok(json!({ "subagents": children }))
}
fn cancel(&self, payload: &Map<String, Value>, signal: &Cancel) -> OpResult {
let selector = payload
.get("selector")
.or_else(|| payload.get("id"))
.ok_or("rlm.cancel needs a subagent id")?;
let id = parse_child(selector)?;
self.record(id)?;
let result = self.chat.abort_task(id, &Ctx::with_signal(signal)).map_err(error)?;
Ok(json!({ "cancelled": result == crate::scheduler::AbortResult::Marked }))
}
fn ask(&self, payload: &Map<String, Value>, signal: &Cancel) -> OpResult {
let id = parse_child(payload.get("child").ok_or("rlm.ask needs a child")?)?;
let question = payload
.get("question")
.and_then(Value::as_str)
.filter(|question| !question.trim().is_empty())
.ok_or("rlm.ask question must be a non-empty string")?;
let record = self.record(id)?;
if !is_keep(&record) {
return Err(format!(
"Subagent {} is not persistent; spawn it with keep=True to ask it follow-ups",
child_id(id)
));
}
let conversation = loop {
let record = self.record(id)?;
if record.state.status() == TaskStatus::Terminal {
return Err(format!("Subagent {} has ended", child_id(id)));
}
if let Some(conversation) = child_conversation(&record) {
break conversation;
}
if let Some(reason) = signal.reason() {
return Err(reason.message());
}
signal.wait_timeout(POLL);
};
let request = payload.get("request_id").and_then(Value::as_str);
let mut draft = SubmissionDraft::input(question).when_busy(WhenBusy::FollowUp);
if let Some(request) = request {
draft = draft.request_id(request);
}
let handle = self
.chat
.conversation(conversation)
.map_err(error)?
.ok_or_else(|| format!("Subagent {} has no conversation", child_id(id)))?;
let limit = payload
.get("timeout_ms")
.and_then(Value::as_f64)
.filter(|ms| *ms > 0.0)
.map_or(ASK_TIMEOUT, |ms| Duration::from_millis(ms as u64));
let submission = handle.submit(draft).map_err(error)?;
let (done, expired) = (Cancel::new(), Cancel::new());
let timer = {
let (done, expired) = (done.clone(), expired.clone());
std::thread::spawn(move || {
if done.wait_timeout(limit).is_none() {
expired.cancel(HarnessError::msg("timeout"));
}
})
};
let linked = Cancel::any(&[signal, &expired]);
let waited = submission.wait(&Ctx::with_signal(linked.signal()));
done.abort();
let _ = timer.join();
if waited.is_err() && signal.reason().is_none() && expired.reason().is_some() {
return Ok(json!({
"id": child_id(id),
"status": "timeout",
"error": format!(
"No answer from subagent {} within {} s; it is still working on the question. Carry on and \
rlm.ask it again later (a new question queues behind this one), or stop it with \
`await rlm.delete_subagent(\"{}\")`.",
child_id(id),
limit.as_secs_f64().round(),
child_id(id)
),
}));
}
let settled = waited.map_err(error)?;
match (settled.status, settled.answer) {
(SubmissionStatus::Done, Some(answer)) => {
let text = self
.chat
.commit(|tx| {
let entry = tx.entry(answer)?;
Ok(entry
.and_then(|entry| entry.model)
.and_then(|model| model.into_iter().next()))
})
.map_err(error)?
.map(|message| {
message["content"]
.as_array()
.into_iter()
.flatten()
.filter_map(|block| block["text"].as_str().map(str::to_owned))
.collect::<Vec<_>>()
.join("\n")
})
.unwrap_or_default();
Ok(json!({ "id": child_id(id), "status": "succeeded", "value": text }))
}
_ => Ok(json!({
"id": child_id(id),
"status": "failed",
"error": settled.detail.or(settled.reason.map(Value::String)).unwrap_or(Value::Null),
})),
}
}
}
impl HostOps {
fn agent_name(&self, call: &CellCall) -> Result<String, String> {
let conversation = call.conversation_id;
let named = self
.chat
.commit(|tx| super::swarm::name_of(tx, conversation))
.map_err(error)?;
Ok(named.unwrap_or_else(|| {
if conversation == durable::ROOT_CONVERSATION_ID {
"root".into()
} else {
format!("conversation-{}", conversation.0)
}
}))
}
fn swarm(&self, kind: &str, payload: &Map<String, Value>, call: &CellCall) -> OpResult {
let caller = super::swarm::Caller {
name: self.agent_name(call)?,
conversation: Some(call.conversation_id),
root_inbox: None,
};
super::swarm::serve(&self.chat, kind, payload, &caller)
}
}
fn is_keep(record: &TaskRecord) -> bool {
record.input["keep"] == true
}
fn child_conversation(record: &TaskRecord) -> Option<durable::ConversationId> {
let checkpoint = match &record.state {
durable::TaskState::Pending { checkpoint }
| durable::TaskState::Running { checkpoint }
| durable::TaskState::Waiting { checkpoint, .. } => checkpoint.clone(),
_ => return None,
};
match serde_json::from_value::<ChildCheckpoint>(checkpoint).ok()? {
ChildCheckpoint::Wait { conversation, .. } | ChildCheckpoint::Idle { conversation, .. } => Some(conversation),
ChildCheckpoint::Start => None,
}
}
struct CellOps {
ops: HostOps,
call: CellCall,
fallback: Option<Arc<dyn HostHandler>>,
}
impl HostHandler for CellOps {
fn handle(&self, kind: &str, payload: Map<String, Value>, signal: &Signal) -> Result<Value, String> {
if Op::of(kind).is_none() {
return match &self.fallback {
Some(fallback) => fallback.handle(kind, payload, signal),
None => Err(format!("Unknown host request {kind}")),
};
}
let cancel = Cancel::new();
let watcher = {
let (cancel, signal) = (cancel.clone(), signal.clone());
std::thread::spawn(move || {
while !signal.wait(Duration::from_millis(50)) {
if cancel.is_cancelled() {
return;
}
}
cancel.cancel(HarnessError::msg(
signal.reason().unwrap_or_else(|| "cell ended".into()),
));
})
};
let result = match self.ops.handle(kind, &payload, &self.call, &cancel) {
Some(result) => result,
None => match &self.fallback {
Some(fallback) => fallback.handle(kind, payload, signal),
None => Err(format!("Unknown host request {kind}")),
},
};
cancel.abort();
drop(watcher);
result
}
}