use super::*;
use crate::async_events::{
Accepted, Cancelled, Dispatcher, DispatcherOptions, EventLanes, Execution, RuntimeEvent, max_event_runs_from_env,
};
use crate::subagents::DurableChildren;
use harness::chat::{ChatHarness, SubmissionDraft, WhenBusy};
use std::sync::mpsc::channel;
pub const ASYNC_EVENTS_MAX_RUNS_ENV: &str = "ULTRON_ASYNC_EVENTS_MAX_RUNS";
pub enum LaneCall {
Execution,
Accept { message: Value, root: String },
Steer(Value),
NextRun(Value),
CancelQueued(String),
}
pub enum LaneAnswer {
Execution(Execution),
Accepted(Accepted),
Queued(Result<String, String>),
Cancelled(Result<Cancelled, String>),
}
struct SessionLanes {
actor: Mutex<Sender<Input>>,
chat: ChatHarness,
children: Arc<DurableChildren>,
waiting: Mutex<Vec<(String, Value)>>,
}
impl SessionLanes {
fn ask(&self, call: LaneCall) -> Option<LaneAnswer> {
let (reply, answer) = channel();
sync::lock(&self.actor).send(Input::EventLane(call, reply)).ok()?;
answer.recv().ok()
}
}
fn content(message: &Value) -> String {
message["content"].as_str().unwrap_or_default().to_string()
}
impl EventLanes for SessionLanes {
fn execution(&self, lane: &str) -> Execution {
if lane == MAIN_LANE {
return match self.ask(LaneCall::Execution) {
Some(LaneAnswer::Execution(execution)) => execution,
_ => Execution::Other,
};
}
let running = self
.children
.conversation_of_lane(lane)
.and_then(|conversation| self.chat.live(conversation).ok())
.is_some_and(|live| !live["run"].is_null());
if running { Execution::Run } else { Execution::Idle }
}
fn accept(&self, lane: &str, message: &Value, root: &str) -> Accepted {
if lane != MAIN_LANE {
return Accepted::Refused("child lanes are never re-invoked".into());
}
match self.ask(LaneCall::Accept {
message: message.clone(),
root: root.to_string(),
}) {
Some(LaneAnswer::Accepted(accepted)) => accepted,
_ => Accepted::Refused("the session is closing".into()),
}
}
fn steer(&self, lane: &str, message: &Value) -> Result<String, String> {
if lane == MAIN_LANE {
return match self.ask(LaneCall::Steer(message.clone())) {
Some(LaneAnswer::Queued(queued)) => queued,
_ => Err("the session is closing".into()),
};
}
let conversation = self
.children
.conversation_of_lane(lane)
.ok_or_else(|| format!("No conversation runs lane {lane}"))?;
let handle = self
.chat
.conversation(conversation)
.map_err(|e| e.to_string())?
.ok_or("The lane's conversation is gone")?;
let submission = handle
.submit(SubmissionDraft::Input {
content: json!(content(message)),
when_busy: WhenBusy::Steer,
request_id: None,
})
.map_err(|e| e.to_string())?;
Ok(format!("{lane}#{}", submission.id.0))
}
fn next_run(&self, lane: &str, message: &Value) -> Result<String, String> {
if lane == MAIN_LANE {
return match self.ask(LaneCall::NextRun(message.clone())) {
Some(LaneAnswer::Queued(queued)) => queued,
_ => Err("the session is closing".into()),
};
}
let mut waiting = sync::lock(&self.waiting);
waiting.push((lane.to_string(), message.clone()));
Ok(format!("{lane}#waiting-{}", waiting.len()))
}
fn cancel_queued(&self, lane: &str, entry: &str) -> Result<Cancelled, String> {
if lane == MAIN_LANE {
return match self.ask(LaneCall::CancelQueued(entry.to_string())) {
Some(LaneAnswer::Cancelled(cancelled)) => cancelled,
_ => Err("the session is closing".into()),
};
}
Ok(Cancelled::AlreadyConsumed)
}
}
pub(super) fn tick_activity(actor: Sender<Input>, stop: harness::scheduler::Cancel) {
std::thread::spawn(move || {
while !stop.is_cancelled() {
std::thread::sleep(std::time::Duration::from_millis(250));
if actor.send(Input::ActivityTick).is_err() {
return;
}
}
});
}
pub(super) fn install(
lane: &Lane,
env: &RunEnv,
actor: Sender<Input>,
chat: ChatHarness,
children: Arc<DurableChildren>,
stop: harness::scheduler::Cancel,
session: SharedSession,
) -> Arc<Dispatcher> {
let stack = lane.stack.clone();
let agents = stack.agents.clone();
let mut options = DispatcherOptions::new(Arc::new(move |run: &str| {
agents
.usage_root_for_lane(MAIN_LANE, run)
.unwrap_or_else(|| format!("turn:{run}"))
}));
options.enabled = stack.events.enabled();
options.max_runs = max_event_runs_from_env((env.var)(ASYNC_EVENTS_MAX_RUNS_ENV).as_deref());
stack.wake.set(options.enabled);
let usage = stack.usage.clone();
options.refuse = Some(Arc::new(move |root: &str| usage.reinvoke_refusal(root).ok().flatten()));
let host = stack.host.clone();
let tools = stack.tool_calls().clone();
options.on_root_aborted = Some(Arc::new(move |root: &str| {
host.cancel_root(root);
tools.cancel_root(root);
}));
options.chains = crate::async_events::Chains::from_value(
lock_session(&session).value(session_journal::ns::MODULE, crate::async_events::CHAINS_MODULE),
);
options.save_chains = Some(Arc::new(move |chains: &crate::async_events::Chains| {
let _ = lock_session(&session).commit(&[Write::set(
session_journal::ns::MODULE,
crate::async_events::CHAINS_MODULE,
chains.to_value(),
)]);
}));
options.mask = Some(stack.mask());
let reminders = stack.context_reminders.clone();
options.note = Some(Arc::new(move |lane: &str, text: &str| {
reminders.reminder(lane, text, 0)
}));
let lanes = Arc::new(SessionLanes {
actor: Mutex::new(actor),
chat,
children: children.clone(),
waiting: Mutex::new(Vec::new()),
});
let dispatcher = Dispatcher::new(options, lanes);
let (roots_children, roots_agents) = (children.clone(), stack.agents.clone());
stack.host.set_roots(Arc::new(move |lane: &str| {
if lane == MAIN_LANE {
roots_children.current_root()
} else {
roots_children.usage_root_of_lane(lane, &roots_agents)
}
}));
let jobs = Arc::downgrade(&dispatcher);
stack.host.on_job_end(Arc::new(move |end: host::JobEnd| {
let (Some(dispatcher), Some(event)) = (jobs.upgrade(), end.event()) else {
return;
};
dispatcher.publish(RuntimeEvent {
kind: event["kind"].as_str().unwrap_or("job_done").into(),
id: end.record.id.clone(),
status: end.record.status.as_str().into(),
summary: event["summary"].as_str().unwrap_or_default().into(),
fetch: event["fetch"].as_str().unwrap_or_default().into(),
lane: end.record.lane.clone(),
root_id: end.record.root_id.clone(),
});
}));
let (tool_roots_children, tool_roots_agents) = (children.clone(), stack.agents.clone());
stack.tool_calls().set_roots(Arc::new(move |lane: &str| {
if lane == MAIN_LANE {
tool_roots_children.current_root()
} else {
tool_roots_children.usage_root_of_lane(lane, &tool_roots_agents)
}
}));
let tool_ends = Arc::downgrade(&dispatcher);
stack
.tool_calls()
.on_end(Arc::new(move |end: kernel_apis::ToolCallEnd| {
let (Some(dispatcher), Some((id, status, summary, fetch))) =
(tool_ends.upgrade(), kernel_apis::tool_calls::tool_event(&end))
else {
return;
};
dispatcher.publish(RuntimeEvent {
kind: "tool_done".into(),
id,
status,
summary,
fetch,
lane: end.call["lane"].as_str().unwrap_or(MAIN_LANE).into(),
root_id: end.call["rootId"].as_str().map(str::to_string),
});
}));
let (forward, events, agents) = (Arc::downgrade(&dispatcher), stack.events.clone(), stack.agents.clone());
std::thread::spawn(move || {
while !stop.is_cancelled() {
let ends = events.recv(std::time::Duration::from_secs(1));
let Some(dispatcher) = forward.upgrade() else { return };
publish_ends(ends, &children, &agents, &dispatcher);
}
});
dispatcher
}
fn forward_ends(
events: &crate::compose::RuntimeEvents,
children: &DurableChildren,
agents: &delegation::agents::Agents,
dispatcher: &Dispatcher,
) {
publish_ends(events.recv(std::time::Duration::ZERO), children, agents, dispatcher);
}
fn publish_ends(
ends: Vec<RuntimeEvent>,
children: &DurableChildren,
agents: &delegation::agents::Agents,
dispatcher: &Dispatcher,
) {
for mut event in ends {
if event.root_id.is_none() {
event.root_id = if event.kind == "child_done" {
children.usage_root_of_lane(&lanes::lane_names::child_lane(&event.id), agents)
} else {
None
}
.or_else(|| children.current_root());
}
dispatcher.publish(event);
}
}
impl Core {
pub(super) fn event_lane(&mut self, call: LaneCall, reply: Sender<LaneAnswer>) {
let answer = match call {
LaneCall::Execution => LaneAnswer::Execution(if self.run.is_some() {
Execution::Run
} else {
Execution::Idle
}),
LaneCall::Accept { message, root } => LaneAnswer::Accepted(self.accept_event(message, &root)),
LaneCall::Steer(message) => LaneAnswer::Queued(if self.run.is_none() {
Err("no run is in progress".into())
} else {
self.enqueue(QueueKind::Steer, content(&message), Vec::new(), None)
}),
LaneCall::NextRun(message) => LaneAnswer::Queued(self.keep_for_next_run(message)),
LaneCall::CancelQueued(entry) => LaneAnswer::Cancelled({
let queued = sync::lock(&self.queues).items.iter().any(|q| q.entry_id == entry);
if queued {
self.remove_queued(&[entry]).map(|_| Cancelled::Cancelled)
} else {
Ok(Cancelled::AlreadyConsumed)
}
}),
};
let _ = reply.send(answer);
}
fn accept_event(&mut self, message: Value, root: &str) -> Accepted {
if self.run.is_some() {
return Accepted::Busy;
}
if let Err((error, _)) = self.prompt_with(message, None, true) {
return Accepted::Refused(error);
}
let Some(operation) = self.operation_id() else {
return Accepted::Refused("the run did not start".into());
};
let agents = &self.lane.stack.agents;
agents.continue_root_turn(&operation, root);
agents.begin_root_turn(&operation);
self.durable.children.set_root(Some(root.to_string()));
Accepted::Run(operation)
}
fn keep_for_next_run(&mut self, message: Value) -> Result<String, String> {
self.announce_message(&message);
self.append(message)?;
Ok(self.tip().unwrap_or_default())
}
pub(super) fn report_activity(&mut self) {
let running = self.run.is_some()
|| self.compacting.is_some()
|| self.turn_guard_checking()
|| self.lane.stack.host.running_jobs() > 0
|| self.lane.stack.tool_calls().running(MAIN_LANE, &|_| false) > 0
|| !self.lane.stack.delegation.running(MAIN_LANE).is_empty()
|| self.lane.stack.agents.running_announced(MAIN_LANE) > 0
|| self.lane.stack.lanes.detached_running(MAIN_LANE) > 0;
let stack = self.lane.stack.clone();
forward_ends(&stack.events, &self.durable.children, &stack.agents, &self.events);
let active = running || self.events.pending_for(MAIN_LANE) > 0;
self.emit(WatchEvent::Activity {
lane: MAIN_LANE.into(),
active,
});
if self.auto_memory.idle_due(active, std::time::Instant::now()) {
self.retain_tail(true);
}
}
pub(super) fn async_pending(&mut self) -> Value {
let stack = self.lane.stack.clone();
forward_ends(&stack.events, &self.durable.children, &stack.agents, &self.events);
let checking = usize::from(self.turn_guard_checking());
let events = &self.events;
if !events.enabled() {
return json!({"pending": checking > 0, "jobs": 0, "tools": 0, "tasks": 0, "events": 0, "running": checking});
}
let aborted = |root: Option<&str>| events.root_aborted(root);
let jobs = self.lane.stack.host.running(MAIN_LANE, &aborted);
let tools = self.lane.stack.tool_calls().running(MAIN_LANE, &aborted);
let tasks = self.lane.stack.delegation.running(MAIN_LANE).len()
+ self.lane.stack.agents.running_announced(MAIN_LANE)
+ self.lane.stack.lanes.detached_running(MAIN_LANE);
let pending = events.pending_for(MAIN_LANE);
let running = usize::from(self.run.is_some()) + checking;
json!({
"pending": jobs + tools + tasks + pending + running > 0,
"jobs": jobs,
"tools": tools,
"tasks": tasks,
"events": pending,
"running": running,
})
}
}