use super::*;
use crate::turns::{Answer, Bridge, GenerationStart, Request, StartError, TurnCells, TurnModels};
use agent::AgentToolResult;
use durable::{ROOT_CONVERSATION_ID, SubmissionId, SubmissionStatus};
use harness::chat::{
AgentChange, ChatHarness, ChatOptions, CompactionPolicy, ModelRef, QueueMode, Settings, SubmissionAbort,
SubmissionDraft, ToolExecution, WhenBusy,
};
use harness::scheduler::{Cancel, Ctx, Registry};
use session_journal::ns::{OP_META, OP_STATE};
use std::sync::atomic::{AtomicBool, Ordering};
type HeldRound = (Vec<(String, String)>, Vec<(String, AgentToolResult, bool)>);
const NO_PARTIALS_MS: u64 = 365 * 24 * 3600 * 1000;
pub(super) struct Durable {
pub chat: ChatHarness,
pub root: harness::chat::Conversation,
pub bridge: Arc<Bridge>,
pub auto_retry: Arc<AtomicBool>,
pub stop: Cancel,
pub children: Arc<crate::subagents::DurableChildren>,
}
fn harness_error(error: harness::scheduler::HarnessError) -> String {
error.to_string()
}
#[allow(clippy::too_many_arguments)]
pub(super) fn open_durable(
session: &SharedSession,
tx: &Sender<Input>,
lane: &Lane,
provider: Arc<Provider>,
env: &RunEnv,
keys: &crate::request_keys::Keys,
queues: Arc<Mutex<Queues>>,
children: Arc<crate::subagents::DurableChildren>,
child_context: Arc<super::context_children::ChildContext>,
image_budget: usize,
) -> Result<Durable, String> {
let to_actor = tx.clone();
let to_actor = Mutex::new(to_actor);
let bridge = Bridge::new(Arc::new(move |request| {
let _ = sync::lock(&to_actor).send(Input::Turn(request));
}));
let observed = child_context.clone();
let committed: crate::turns::Committed = Arc::new(move |entry| observed.committed(entry));
let storage = crate::durable_store::open(session.clone(), Some(crate::turns::observer(bridge.clone(), committed)))
.map_err(|e| e.message().to_string())?;
let auto_retry = Arc::new(AtomicBool::new(true));
let retry = auto_retry.clone();
let retry_settings = config::settings::SettingsManager::for_worker(&env.cwd, &env.agent_dir(), &env.home)
.settings()
.get("retry")
.cloned()
.unwrap_or(Value::Null);
let settings_queues = queues;
let live: LiveSettings = Arc::new(move |settings: &mut Settings| {
let (steering, follow_up) = {
let queues = sync::lock(&settings_queues);
(queues.steering_all, queues.follow_up_all)
};
let mode = |all: bool| if all { QueueMode::All } else { QueueMode::OneAtATime };
settings.retry = ai::retry::RetryPolicy::from_settings(&retry_settings, retry.load(Ordering::SeqCst));
settings.steering_mode = mode(steering);
settings.follow_up_mode = mode(follow_up);
});
let root_session = Arc::new(std::sync::OnceLock::new());
let child_costs: ChildCosts = Arc::default();
let (ended_costs, ended_stack) = (child_costs.clone(), Arc::downgrade(&lane.stack));
lane.stack.delegation.on_task_end(Arc::new(move |task: &Value| {
let cost = task["id"].as_str().and_then(|id| sync::lock(&ended_costs).remove(id));
if let Some(stack) = ended_stack.upgrade()
&& let Some(context) = stack.context.get()
{
context.task_ended(task, cost);
}
}));
let context = child_context.clone();
let clock = lane::clock_enabled(env).then(|| lane::clock_zone(env));
let started = lock_session(session).metadata().created_at;
let footers = (lane.stack.config().result_footer && started > 0).then_some(started);
let subagents = children.clone();
let transform: crate::turns::TransformChild = Arc::new(move |conversation, messages: &mut Vec<ai::Message>| {
context.transform_request(conversation, messages);
let subagent = subagents.lane_of(conversation).is_some_and(|lane| {
matches!(
lanes::lane_names::parse_lane(&lane),
Some(lanes::lane_names::LaneOwner::Child(_))
)
});
if !subagent {
return;
}
if let Some(zone) = &clock {
add_clock_lines(messages, zone);
}
if let Some(started) = footers {
lane::add_result_footers(messages, started);
}
});
let mut options = child_chat_options(
session,
lane,
&children,
env,
ChildTurns {
bridge: bridge.clone(),
provider,
keys: keys.clone(),
root_session: root_session.clone(),
live,
charged: Some(child_cost(children.clone(), child_costs)),
transform: Some(transform),
image_budget,
fallback_system: crate::compose::Stack::system,
},
);
let (limit_children, limit_stack) = (children.clone(), Arc::downgrade(&lane.stack));
lane.stack.delegation.set_limit_reason(Arc::new(move |task: &str| {
let stack = limit_stack.upgrade()?;
let root = limit_children.usage_root_of_lane(&lanes::lane_names::child_lane(task), &stack.agents);
stack.usage.turn_budget_exhausted(root.as_deref()).ok().flatten()
}));
let trims = child_context.clone();
options.hooks.before_compaction = Some(Arc::new(move |conversation, tokens, threshold| {
trims.before_compaction(conversation, tokens, threshold)
}));
let chat = ChatHarness::open(storage, options).map_err(harness_error)?;
let root = chat.root(None).map_err(harness_error)?;
let provider_session = chat
.snapshot(
&harness::chat::docs::PROVIDER,
durable::Owner::Conversation(ROOT_CONVERSATION_ID),
)
.map_err(harness_error)?
.and_then(|state| state["sessionId"].as_str().map(str::to_string))
.unwrap_or_default();
let _ = root_session.set(provider_session);
Ok(Durable {
chat,
root,
bridge,
auto_retry,
stop: Cancel::new(),
children,
})
}
fn add_clock_lines(messages: &mut Vec<ai::Message>, zone: &jsrt::localtime::Zone) {
let values: Vec<Value> = messages
.iter()
.map(|message| match message {
ai::Message::System(_) => Value::Null,
message => serde_json::to_value(message).unwrap_or(Value::Null),
})
.collect();
for (index, line) in lane::clock_lines_in(&values, zone).into_iter().rev() {
messages.insert(index, line);
}
}
type ChildCosts = Arc<Mutex<std::collections::HashMap<String, f64>>>;
fn child_cost(children: Arc<crate::subagents::DurableChildren>, costs: ChildCosts) -> crate::turns::ChargeTurn {
Arc::new(move |conversation, message| {
if conversation != ROOT_CONVERSATION_ID
&& let Some(lane) = children.lane_of(conversation)
&& let Some(lanes::lane_names::LaneOwner::Child(task)) = lanes::lane_names::parse_lane(&lane)
{
*sync::lock(&costs).entry(task.to_string()).or_insert(0.0) += message.usage.cost.total;
}
})
}
pub type LiveSettings = Arc<dyn Fn(&mut Settings) + Send + Sync>;
pub struct ChildTurns {
pub bridge: Arc<Bridge>,
pub provider: Arc<Provider>,
pub keys: crate::request_keys::Keys,
pub root_session: Arc<std::sync::OnceLock<String>>,
pub live: LiveSettings,
pub charged: Option<crate::turns::ChargeTurn>,
pub transform: Option<crate::turns::TransformChild>,
pub image_budget: usize,
pub fallback_system: fn(&crate::compose::Stack) -> String,
}
pub fn child_chat_options(
session: &SharedSession,
lane: &Lane,
children: &Arc<crate::subagents::DurableChildren>,
env: &RunEnv,
turns: ChildTurns,
) -> ChatOptions {
let ChildTurns {
bridge,
provider,
keys,
root_session,
live,
charged,
transform,
image_budget,
fallback_system,
} = turns;
let stream_provider = provider.clone();
let settings: harness::chat::SettingsSource = Arc::new(move || {
let mut settings = Settings {
stream: stream_provider
.stream_options()
.and_then(|options| options.as_object().cloned())
.unwrap_or_default(),
compaction: CompactionPolicy {
enabled: false,
..CompactionPolicy::default()
},
partial_interval_ms: NO_PARTIALS_MS,
tool_execution: ToolExecution::Parallel,
follow_up_after_steer: true,
..Settings::default()
};
live(&mut settings);
settings
});
let catalog_env = env.clone();
let root_of = usage_root_of(children.clone(), lane.stack.clone());
let (charge_root, charge_stack) = (root_of.clone(), lane.stack.clone());
let models = TurnModels {
bridge: bridge.clone(),
provider: provider as Arc<dyn agent::StreamFn>,
resolve: Arc::new(move |provider, id| lane::catalog_model(provider, id, &catalog_env).ok()),
api_key: keys.request_keys(),
root_session,
charge: Some(Arc::new(move |conversation, message| {
let root = charge_root(conversation);
let _ = charge_stack.usage.record_turn(
root.as_deref(),
Some(message.usage.total_tokens as f64),
Some(message.usage.cost.total),
);
if let Some(charged) = &charged {
charged(conversation, message);
}
})),
transform_child: Some(Arc::new(move |conversation, messages: &mut Vec<ai::Message>| {
if let Some(transform) = &transform {
transform(conversation, messages);
}
crate::view_images::apply_image_budget(messages, image_budget);
})),
trace: crate::request_trace::RequestTrace::from_env(&*env.var)
.map(|trace| (trace, lock_session(session).id().to_string())),
};
let cells = TurnCells {
bridge,
tool: lane.tool.clone(),
progress: lane.stack.cell_progress.clone(),
stack: lane.stack.clone(),
children: children.clone(),
};
let (section_children, section_stack) = (children.clone(), lane.stack.clone());
let sections: harness::chat::SectionSource = Arc::new(move |conversation, _| {
let mut sections = indexmap::IndexMap::new();
if conversation != ROOT_CONVERSATION_ID {
let system = section_children
.lane_of(conversation)
.and_then(|lane| section_children.system_of(&lane))
.unwrap_or_else(|| fallback_system(§ion_stack));
sections.insert("system".to_string(), system);
}
Ok(sections)
});
let mut options = ChatOptions::new(Registry::new(), Arc::new(models), Arc::new(cells));
options.settings = Some(settings);
options.sections = Some(sections);
let gate = super::budget_gate::BudgetGate::new(lane.stack.usage.clone(), lane.stack.stats.clone(), root_of);
let request_gate = gate.clone();
options.hooks.gate_request = Some(Arc::new(move |run| request_gate.before_request(run)));
options.hooks.gate_tool = Some(Arc::new(move |run, call| gate.before_tool(run, call)));
options.hooks.compaction = Some(Arc::new(|conversation| {
Some(CompactionPolicy {
enabled: conversation != ROOT_CONVERSATION_ID,
background_tokens: 0,
..CompactionPolicy::default()
})
}));
options
}
fn usage_root_of(
children: Arc<crate::subagents::DurableChildren>,
stack: Arc<crate::compose::Stack>,
) -> super::budget_gate::RootOf {
Arc::new(move |conversation| {
if conversation == ROOT_CONVERSATION_ID {
children.current_root()
} else {
children.usage_root(conversation, &stack.agents)
}
})
}
fn text_of(message: &Message) -> String {
message_text(&serde_json::to_value(message).unwrap_or(Value::Null))
}
impl Core {
pub(super) fn operation_id(&self) -> Option<String> {
self.run
.as_ref()
.and_then(|run| run.journal.run())
.map(|run| run.operation_id().to_string())
}
fn queued_submission(&self, entry_id: &str) -> (Option<durable::SubmissionRecord>, u64) {
let mut found = None;
let mut attempt = 0;
loop {
let request = format!("{entry_id}#{attempt}");
let record = self
.durable
.chat
.commit(|tx| Ok(tx.submission_by_request(ROOT_CONVERSATION_ID, &request)?))
.ok()
.flatten();
match record {
Some(record) => {
found = Some(record);
attempt += 1;
}
None => return (found, attempt),
}
}
}
pub(super) fn submit_queued(&mut self) -> Result<(), String> {
let pending: Vec<Queued> = sync::lock(&self.queues)
.items
.iter()
.filter(|q| q.submission.is_none() && q.kind != QueueKind::NextRun)
.cloned()
.collect();
for queued in pending {
let id = match self.queued_draft(&queued) {
Ok(id) => id,
Err(draft) => self.durable.root.submit(draft).map_err(harness_error)?.id,
};
self.mark_submitted(&queued.entry_id, id);
}
Ok(())
}
fn queued_draft(&self, queued: &Queued) -> Result<SubmissionId, SubmissionDraft> {
let (existing, attempt) = self.queued_submission(&queued.entry_id);
match existing {
Some(record) if matches!(record.status, SubmissionStatus::Queued | SubmissionStatus::Placed) => {
Ok(record.id)
}
_ => {
let when = match queued.kind {
QueueKind::Steer => WhenBusy::Steer,
QueueKind::FollowUp | QueueKind::NextRun => WhenBusy::FollowUp,
};
Err(SubmissionDraft::Input {
content: queued.message["content"].clone(),
when_busy: when,
request_id: Some(format!("{}#{attempt}", queued.entry_id)),
})
}
}
}
fn mark_submitted(&self, entry_id: &str, id: SubmissionId) {
if let Some(item) = sync::lock(&self.queues)
.items
.iter_mut()
.find(|q| q.entry_id == entry_id)
{
item.submission = Some(id);
}
}
fn take_placed(&self, turn: u64) -> Vec<String> {
let waiting: Vec<(String, SubmissionId)> = sync::lock(&self.queues)
.items
.iter()
.filter_map(|q| Some((q.entry_id.clone(), q.submission?)))
.collect();
let mut placed: Vec<(Option<durable::EntryId>, String)> = waiting
.into_iter()
.filter_map(|(entry_id, submission)| {
let record = self
.durable
.chat
.commit(|tx| Ok(tx.submission(submission)?))
.ok()
.flatten()?;
matches!(record.status, SubmissionStatus::Placed | SubmissionStatus::Done)
.then_some((record.entry, entry_id))
})
.collect();
placed.sort();
let mut queues = sync::lock(&self.queues);
placed
.into_iter()
.filter_map(|(_, entry_id)| {
let index = queues.items.iter().position(|q| q.entry_id == entry_id)?;
let mut queued = queues.items.remove(index);
queued.turn = turn;
queues.delivered.push(queued);
Some(entry_id)
})
.collect()
}
pub(super) fn withdraw_queued(&mut self, ids: &[String]) {
let withdrawn: Vec<SubmissionId> = {
let mut queues = sync::lock(&self.queues);
queues
.items
.iter_mut()
.filter(|q| ids.is_empty() || ids.contains(&q.entry_id))
.filter_map(|q| q.submission.take())
.collect()
};
for id in withdrawn {
if let Ok(SubmissionAbort::NotFound) = self.durable.chat.abort_submission(id, Some(ROOT_CONVERSATION_ID)) {
continue;
}
}
}
pub(super) fn start_turn(&mut self, prompt: &Value, prompt_entry: &str) -> Result<SubmissionId, String> {
self.durable.bridge.clear();
self.durable.bridge.set_user_abort(false);
let change = AgentChange {
model: Some(Some(ModelRef::new(&self.model.provider, &self.model.id))),
thinking_level: Some(Some(self.thinking.clone())),
};
self.durable.root.configure(&change).map_err(harness_error)?;
self.durable.root.reset(None).map_err(harness_error)?;
let draft = SubmissionDraft::Input {
content: prompt["content"].clone(),
when_busy: WhenBusy::FollowUp,
request_id: Some(prompt_entry.to_string()),
};
let steering: Vec<(String, SubmissionDraft)> = {
let queues = sync::lock(&self.queues);
let steers = queues
.items
.iter()
.filter(|q| q.submission.is_none() && q.kind == QueueKind::Steer)
.take(if queues.steering_all { usize::MAX } else { 1 })
.cloned()
.collect::<Vec<_>>();
drop(queues);
steers
.iter()
.filter_map(|q| self.queued_draft(q).err().map(|draft| (q.entry_id.clone(), draft)))
.collect()
};
let (entries, drafts): (Vec<String>, Vec<SubmissionDraft>) = steering.into_iter().unzip();
let submissions = self.durable.root.submit_run(draft, drafts).map_err(harness_error)?;
let (first, steered) = submissions.split_first().ok_or("The runtime admitted no submission")?;
for (entry_id, submission) in entries.iter().zip(steered) {
self.mark_submitted(entry_id, submission.id);
}
self.submit_queued()?;
Ok(first.id)
}
pub(super) fn spawn_waiter(&self) {
let (root, stop, tx) = (self.durable.root.clone(), self.durable.stop.clone(), self.tx.clone());
std::thread::spawn(move || {
if root.wait_for_idle(&Ctx::with_signal(&stop)).is_ok() {
let _ = tx.send(Input::HarnessIdle);
}
});
}
pub(super) fn harness_idle(&mut self) {
if self.run.is_none() {
return;
}
let live = self.durable.chat.live(ROOT_CONVERSATION_ID).unwrap_or(Value::Null);
let queued = self
.durable
.chat
.inbox(ROOT_CONVERSATION_ID)
.map(|items| !items.is_empty())
.unwrap_or(false);
if !live["run"].is_null() || queued {
self.spawn_waiter();
return;
}
if self.may_finish() {
let _ = self.checkpoint_compaction();
}
self.run_end();
}
fn may_finish(&self) -> bool {
let Some(run) = self.run.as_ref() else {
return false;
};
if run.cancelled || run.error.is_some() {
return false;
}
let Some(operation) = run.journal.run().map(|r| r.operation_id().to_string()) else {
return false;
};
lock_session(&self.session)
.value(session_journal::ns::OP_STATE, &operation)
.is_some_and(|state| {
use session_journal::run::OpAt;
let continuation = match OpAt::of(state) {
Some(OpAt::Checkpoint) => &state["continuation"],
Some(at) if at.is_summary() => &state["task"]["boundary"]["resumeAfter"]["continuation"],
_ => return false,
};
continuation["kind"] == "may_finish"
})
}
pub(super) fn unanswered(&self, submission: Option<SubmissionId>) -> Option<String> {
let submission = submission?;
let record = self
.durable
.chat
.commit(|tx| Ok(tx.submission(submission)?))
.ok()
.flatten()?;
if record.status != SubmissionStatus::Unanswered {
return None;
}
let reason = record.reason.clone().unwrap_or_default();
if matches!(reason.as_str(), "aborted" | "model_error") {
return None;
}
Some(
record
.detail
.as_ref()
.and_then(Value::as_str)
.map_or(reason, str::to_string),
)
}
pub(super) fn abort_turn(&mut self) {
self.durable.bridge.set_user_abort(true);
self.withdraw_queued(&[]);
let chat = self.durable.chat.clone();
std::thread::spawn(move || {
let live = chat.live(ROOT_CONVERSATION_ID).unwrap_or(Value::Null);
if let Some(task) = live["run"]["taskId"].as_u64() {
let _ = chat.abort_task(durable::TaskId(task), &Ctx::background());
}
});
}
fn context_entries(&self, source_tip: Option<&str>) -> Result<(Vec<Value>, usize), String> {
let session = lock_session(&self.session);
let before: std::collections::HashSet<&str> = session
.state()
.branch_path_refs(source_tip)?
.into_iter()
.filter_map(|entry| entry["id"].as_str())
.collect();
let entries = session_journal::context::build_context_entries(&session.branch_entry_refs(MAIN_LANE)?);
let mut split = entries
.iter()
.take_while(|entry| entry["id"].as_str().is_some_and(|id| before.contains(id)))
.count();
if split == 0 && entries.first().is_some_and(|entry| entry["type"] == "compaction") {
split = 1;
}
Ok((entries, split))
}
fn run_messages(&self, source_tip: Option<&str>) -> Result<Vec<Value>, String> {
let (entries, split) = self.context_entries(source_tip)?;
Ok(entries[split..]
.iter()
.flat_map(|entry| {
let message = &entry["message"];
if entry["type"] == "message" && message["role"] == "assistant" && message["stopReason"] == "error" {
return vec![message.clone()];
}
session_journal::context::entry_context_messages(entry)
})
.collect())
}
fn context_messages(&self, source_tip: Option<&str>) -> Result<Vec<Value>, String> {
let (entries, _) = self.context_entries(source_tip)?;
Ok(entries
.iter()
.flat_map(session_journal::context::entry_context_messages)
.collect())
}
fn request_messages(&self, source_tip: Option<&str>) -> Result<Vec<Message>, String> {
let (entries, split) = self.context_entries(source_tip)?;
let applied = session_journal::context::apply_context_edits(&entries);
let project =
|entries: &[Value]| session_journal::context::project_context_entries(entries, context_lane::PROJECTORS);
let mut history = project(&applied[..split]);
let run = project(&applied[split..]);
if let Ok(Some(kept)) = self.context.transform_context(MAIN_LANE, &history) {
history = kept;
}
let first = run.first().cloned();
history.extend(first.clone());
if lane::clock_enabled(&self.env)
&& let Some(lined) = lane::with_clock_lines_in(&history, &lane::clock_zone(&self.env))
{
history = lined;
}
if first.is_some() {
history.pop();
}
let mut messages: Vec<Message> = self
.lane
.system_message(&self.runtime.system.current())
.into_iter()
.collect();
messages.extend(lane::to_llm(&history));
messages.extend(lane::to_llm(&run));
let started = lock_session(&self.session).metadata().created_at;
if self.runtime.config.result_footer && started > 0 {
lane::add_result_footers(&mut messages, started);
}
crate::view_images::apply_image_budget(&mut messages, self.runtime.config.context_images);
Ok(messages)
}
fn prompt_budget(&self) -> Result<(), String> {
let Some(system) = self.lane.system_message(&self.runtime.system.current()) else {
return Ok(());
};
let system = serde_json::to_value(&system).map_err(|error| error.to_string())?;
crate::prompt_budget::check_prompt_budget(
crate::prompt_budget::PromptSize::of(&system),
self.model.context_window,
&self.compaction_settings(),
&format!("{}/{}", self.model.provider, self.model.id),
)
}
pub(super) fn generation(&mut self, users: Vec<Message>, answer: Answer<Result<GenerationStart, StartError>>) {
let Some(run) = self.run.as_ref() else {
return answer.give(Err(StartError::Request("No run is in progress".into())));
};
if run.prompt_pending {
let (captured, run_id) = (run.captured.clone(), run.id.clone());
for message in captured {
self.emit(WatchEvent::MessageStart {
run_id: Some(run_id.clone()),
lane: MAIN_LANE.into(),
message: message.clone(),
});
self.emit(WatchEvent::MessageEnd {
run_id: Some(run_id.clone()),
lane: MAIN_LANE.into(),
message,
});
}
let prompt = self.run.as_ref().map(|r| r.prompt.clone()).unwrap_or(Value::Null);
if let Ok(message) = serde_json::from_value::<Message>(prompt) {
self.on_agent_event(AgentEvent::MessageStart {
message: message.clone(),
});
self.on_agent_event(AgentEvent::MessageEnd { message });
}
}
if let Err(error) = self.checkpoint_compaction() {
return answer.give(Err(StartError::Checkpoint(error)));
}
if let Err(error) = self.prompt_budget() {
return answer.give(Err(StartError::Checkpoint(error)));
}
let Some(run) = self.run.as_ref() else {
return answer.give(Err(StartError::Request("No run is in progress".into())));
};
let source_tip = run.journal.run().and_then(|r| r.source_tip().map(str::to_string));
let mut committed: Vec<String> = match self.context_messages(source_tip.as_deref()) {
Ok(messages) => {
let start = messages
.iter()
.rposition(|m| m["role"] == "assistant" || m["role"] == "toolResult")
.map_or(0, |i| i + 1);
messages[start..]
.iter()
.filter(|m| m["role"] == "user")
.map(message_text)
.collect()
}
Err(_) => Vec::new(),
};
let mut fresh = Vec::new();
for user in users {
let text = text_of(&user);
match committed.iter().position(|t| *t == text) {
Some(index) => {
committed.remove(index);
}
None => fresh.push(user),
}
}
let turn = self.run.as_ref().map_or(0, |r| r.turns) + 1;
let placed = self.take_placed(turn);
let queued_from = fresh.len().saturating_sub(placed.len());
let skip = placed.len().saturating_sub(fresh.len());
let mut placed = placed.into_iter().skip(skip);
self.on_agent_event(AgentEvent::TurnStart);
for (index, message) in fresh.into_iter().enumerate() {
let queued = if index >= queued_from { placed.next() } else { None };
let value = super::stored(&message);
self.on_agent_event(AgentEvent::MessageStart { message });
self.user_message_end(value, queued);
}
let settings = self.compaction_settings();
self.lane.stack.context_reminders.set_limit(
MAIN_LANE,
crate::context_reminder::lane_limit(&self.model, settings.enabled, settings.reserve_tokens),
);
let start = self
.request_messages(source_tip.as_deref())
.map(|messages| GenerationStart { messages })
.map_err(StartError::Request);
if let Ok(start) = &start {
self.observer_generation(&start.messages);
}
answer.give(start);
}
pub(super) fn on_turn(&mut self, request: Request) {
match request {
Request::Generation { users, answer } => self.generation(users, answer),
Request::Event(event) => self.on_agent_event(*event),
Request::Overflow { message, answer } => self.overflow(*message, answer),
Request::RoundEnded { calls, failed, answer } => {
self.turn_ended(calls, failed);
answer.give(());
}
}
}
pub(super) fn reopen_run(&mut self, operation_id: &str) -> Result<String, String> {
let model = (self.model.max_tokens, self.model.context_window);
let (mut journal, meta, state) = {
let session = lock_session(&self.session);
(
RunJournal::reopen(&session, operation_id, model)?,
session.value(OP_META, operation_id).cloned().unwrap_or(Value::Null),
session.value(OP_STATE, operation_id).cloned().unwrap_or(Value::Null),
)
};
let prompt_entry = meta["intent"]["promptEntryIds"][0]
.as_str()
.unwrap_or_default()
.to_string();
let prompt = lock_session(&self.session)
.state()
.entry(&prompt_entry)
.map(|entry| entry["message"].clone())
.unwrap_or(Value::Null);
let cancelled = state["control"]["status"] == "cancel_requested";
let resume_overflow = session_journal::run::Run::open_compaction(&lock_session(&self.session), operation_id)
.filter(|open| open.reason == "overflow")
.map(|open| open.resume_after);
journal.ledger_counts_turns();
let id = jsrt::random::uuid_v7(now_ms());
let source_tip = meta["sourceTipId"].as_str().map(str::to_string);
let unreported = journal.run().map(|r| r.unreported_calls()).unwrap_or_default();
let submission = self
.durable
.chat
.commit(|tx| Ok(tx.submission_by_request(ROOT_CONVERSATION_ID, &prompt_entry)?))
.map_err(harness_error)?;
self.lane.stack.agents.begin_root_turn(operation_id);
self.durable
.children
.set_root(self.lane.stack.agents.usage_root_for_lane(MAIN_LANE, operation_id));
self.branches.run_started();
self.lane.stack.host.begin_turn();
self.run = Some(Running {
id: id.clone(),
signal: AbortSignal::new(),
journal,
prompt_pending: false,
turns: 0,
started_tip: source_tip.clone().map_or(Value::Null, Value::from),
error: None,
waiter: None,
cancelled,
prompt: prompt.clone(),
captured: Vec::new(),
submission: submission.as_ref().map(|s| s.id),
compaction_failed: false,
resume_overflow,
hiding: false,
ending: false,
});
self.lane.stack.begin_turn();
self.lane.stack.stats.touch();
self.emit(WatchEvent::RunStart {
run_id: id.clone(),
started_at: now_ms(),
lane: MAIN_LANE.into(),
});
if submission.is_none() && !cancelled {
self.durable.bridge.clear();
let draft = SubmissionDraft::Input {
content: prompt["content"].clone(),
when_busy: WhenBusy::FollowUp,
request_id: Some(prompt_entry.clone()),
};
let submitted = self.durable.root.submit(draft).map_err(harness_error)?;
if let Some(run) = self.run.as_mut() {
run.submission = Some(submitted.id);
}
} else {
self.catch_up(source_tip.as_deref(), &unreported)?;
}
if !cancelled {
self.submit_queued()?;
}
self.durable.chat.resume().map_err(harness_error)?;
if cancelled {
self.abort_turn();
}
self.spawn_waiter();
Ok(id)
}
fn catch_up(&mut self, source_tip: Option<&str>, unreported: &[String]) -> Result<(), String> {
let entries = self.durable.root.entries().map_err(harness_error)?;
let start = entries
.iter()
.rposition(|e| e.kind == harness::chat::entries::RESET)
.map_or(0, |i| i + 1);
let harness_messages: Vec<(String, Value)> = entries[start..]
.iter()
.filter_map(|e| Some((e.kind.clone(), e.model.as_ref()?.first()?.clone())))
.collect();
let transcript = self.run_messages(source_tip)?;
let bridge = self.durable.bridge.clone();
let mut position = 0;
let mut pending_users: Vec<Message> = Vec::new();
let mut round: Option<HeldRound> = None;
for (kind, message) in harness_messages {
let role = message["role"].as_str().unwrap_or_default().to_string();
let held = transcript.get(position).is_some_and(|t| t["role"] == role.as_str());
match kind.as_str() {
harness::chat::entries::USER => {
if held {
position += 1;
} else if let Ok(user) = serde_json::from_value::<Message>(message) {
pending_users.push(user);
}
}
harness::chat::entries::ASSISTANT => {
let Ok(answer) = serde_json::from_value::<ai::AssistantMessage>(message) else {
continue;
};
if held {
position += 1;
let calls = answer
.content
.iter()
.filter_map(|c| match c {
ai::AssistantContent::ToolCall(call) => Some((call.id.clone(), call.name.clone())),
_ => None,
})
.collect();
round = Some((calls, Vec::new()));
continue;
}
round = None;
bridge.request(Request::Generation {
users: std::mem::take(&mut pending_users),
answer: Answer::default(),
});
bridge.answer_committed(answer);
}
harness::chat::entries::TOOL_RESULT => {
if held {
position += 1;
continue;
}
let call_id = message["toolCallId"].as_str().unwrap_or_default().to_string();
if let Some((calls, mut done)) = round.take() {
if !unreported.contains(&call_id) {
done.push((
call_id,
AgentToolResult {
content: serde_json::from_value(message["content"].clone()).unwrap_or_default(),
details: message.get("details").cloned().unwrap_or_else(|| json!({})),
usage: None,
terminate: None,
},
message["isError"] == true,
));
round = Some((calls, done));
continue;
}
bridge.resume_round(calls, done);
}
bridge.result_committed(&message);
}
_ => {}
}
}
if let Some((calls, done)) = round.take() {
bridge.resume_round(calls, done);
}
Ok(())
}
pub(super) fn start_conversation(&mut self, message: &str) -> Result<Value, String> {
let change = AgentChange {
model: Some(Some(ModelRef::new(&self.model.provider, &self.model.id))),
thinking_level: Some(Some(self.thinking.clone())),
};
let conversation = self
.durable
.chat
.create_conversation(durable::ConversationOwnership::Ownerless, Some(&change))
.map_err(harness_error)?;
conversation
.submit(SubmissionDraft::input(json!([{"type": "text", "text": message}])))
.map_err(harness_error)?;
Ok(json!({"conversationId": conversation.id.0}))
}
fn other_conversation(&self, id: u64) -> Result<harness::chat::Conversation, String> {
let id = durable::ConversationId(id);
if id == ROOT_CONVERSATION_ID {
return Err("The session's own conversation takes prompts, not conversation inputs".into());
}
self.durable
.chat
.conversation(id)
.map_err(harness_error)?
.ok_or_else(|| format!("Unknown conversation {}", id.0))
}
pub(super) fn conversation_input(&mut self, id: u64, message: &str) -> Result<(), String> {
self.other_conversation(id)?
.submit(SubmissionDraft::input(json!([{"type": "text", "text": message}])))
.map(drop)
.map_err(harness_error)
}
fn conversation_view(&self, conversation: &harness::chat::Conversation) -> Result<Value, String> {
let messages: Vec<Value> = conversation
.entries()
.map_err(harness_error)?
.iter()
.filter_map(|entry| entry.model.as_ref()?.first().cloned())
.filter(|message| matches!(message["role"].as_str(), Some("user" | "assistant" | "toolResult")))
.map(|message| json!({"role": message["role"], "text": message_text(&message)}))
.collect();
let live = self.durable.chat.live(conversation.id).map_err(harness_error)?;
let queued = !self
.durable
.chat
.inbox(conversation.id)
.map_err(harness_error)?
.is_empty();
Ok(json!({"id": conversation.id.0, "busy": !live["run"].is_null() || queued, "messages": messages}))
}
pub(super) fn conversations(&self, id: Option<u64>) -> Result<Value, String> {
if let Some(id) = id {
return self.conversation_view(&self.other_conversation(id)?);
}
let ids = self
.durable
.chat
.commit(|tx| {
let mut ids = Vec::new();
let mut cursor: Option<durable::Cursor> = None;
loop {
let page = tx.committed(|storage| {
storage.scan_conversations(&durable::ConversationQuery::default(), 256, cursor.as_ref())
})?;
ids.extend(
page.items
.into_iter()
.filter(|c| c.owner.is_none() && c.parent.is_none() && c.id != ROOT_CONVERSATION_ID)
.map(|c| c.id),
);
match page.next {
Some(next) => cursor = Some(next),
None => return Ok(ids),
}
}
})
.map_err(harness_error)?;
let mut views = Vec::new();
for id in ids {
if let Some(conversation) = self.durable.chat.conversation(id).map_err(harness_error)? {
views.push(self.conversation_view(&conversation)?);
}
}
Ok(json!({"conversations": views}))
}
}