use crate::compaction_op::CompactionOp;
use jsrt::sync;
pub const AUTO_NAME_ENV: &str = "ULTRON_AUTO_NAME";
pub const AUTO_REFINE_ENV: &str = "ULTRON_AUTO_REFINE";
pub const RECOVERY_RESUME_ENV: &str = "ULTRON_RECOVERY_RESUME";
#[path = "navigate.rs"]
mod navigate;
use crate::compose::{Runtime, Services};
use crate::durable_store::{SharedSession, lock as lock_session};
use crate::journal::RunJournal;
use crate::lane::{self, Lane, Provider, api_supported};
use crate::view;
use crate::{ModelFlags, RunEnv, naming, pi_view};
use agent::{AgentEvent, StreamFn};
use ai::{AbortSignal, AssistantMessage, Message, Model, SimpleStreamOptions, StreamOptions};
use jsrt::date::now_ms;
use protocol::pi_message::text as message_text;
use serde_json::{Map, Value, json};
use session_file::SessionManager;
use session_journal::ns::PENDING_ENTRY;
use session_journal::ns::{BRANCH_TIP, LANE_CONFIG, LANE_STATE};
use session_journal::repo::Metadata;
use session_journal::run::{self, MAIN_LANE};
use session_journal::{Session, SessionRepo, SystemClock, Write, names};
use std::path::{Path, PathBuf};
use std::sync::mpsc::Sender;
use std::sync::{Arc, Mutex};
use std::thread::JoinHandle;
pub const EMPTY_QUEUED: &str = "Queued input must contain text or an image";
pub const SESSION_CLOSED: &str = "Session is closed";
use protocol::watch::{Ended, Failure, QueueItem, QueueKind, WatchEvent};
pub type OpResult = Result<Option<Value>, String>;
pub type Reply = Box<dyn FnOnce(OpResult) + Send>;
#[derive(Clone, Debug, PartialEq)]
pub enum Op {
Prompt {
message: String,
images: Vec<Value>,
queue: Option<QueueKind>,
},
PromptAndWait {
message: String,
images: Vec<Value>,
},
Enqueue {
kind: QueueKind,
message: String,
images: Vec<Value>,
entry_id: Option<String>,
},
CancelQueued {
entry_id: String,
},
ClearQueue,
Abort,
State,
AvailableModels,
SetModel {
provider: String,
model_id: String,
},
CycleModel,
ThinkingLevels,
SetThinking {
level: String,
},
CycleThinking,
SetQueueMode {
kind: QueueKind,
mode: String,
},
Compact {
instructions: Option<String>,
},
SetAutoCompaction(bool),
SetAutoRetry(bool),
SetTerminalTheme {
theme: String,
},
AbortRetry,
Bash {
command: String,
exclude: bool,
id: Option<String>,
},
AbortBash,
BugSummary {
hint: Option<String>,
},
AbortBugSummary,
ShareContext,
AppendCustom {
custom_type: String,
data: Value,
},
Stats,
ForkMessages,
Entries {
since: Option<String>,
},
Tree,
LastAssistantText,
SetName {
name: String,
},
Messages,
ForkSource {
entry_id: String,
},
CloneSource,
Forked {
target: String,
},
Describe,
LaneSnapshot,
ListSessions,
Recover,
Agents,
Navigate {
target_id: Option<String>,
summarize: bool,
instructions: Option<String>,
label: Option<String>,
},
SetLabel {
entry_id: String,
label: Option<String>,
},
KillAgent {
id: String,
},
SteerAgent {
id: String,
message: String,
},
ReviveAgent {
id: String,
},
AgentTranscript {
id: String,
},
Goal {
args: String,
},
Observer {
args: String,
},
StartConversation {
message: String,
},
ConversationInput {
id: u64,
message: String,
},
Conversations {
id: Option<u64>,
},
AsyncPending,
Inspect {
request: String,
payload: Value,
},
Commands,
Checkpoints,
RestoreFiles {
entry_id: Option<String>,
checkpoint: Option<String>,
},
ScheduleFire {
id: String,
due: i64,
},
ScheduleCancel {
id: String,
},
Persona {
args: String,
},
KeepGoing {
args: String,
},
ContinueFrom {
session: String,
},
}
impl From<&Op> for Value {
fn from(op: &Op) -> Value {
op.to_json()
}
}
impl Op {
pub fn from_json(value: &Value) -> Result<Op, String> {
let text = |key: &str| value.get(key).and_then(Value::as_str).map(str::to_string);
let need = |key: &str| text(key).ok_or_else(|| format!("{key} must be a string"));
let images = || value["images"].as_array().cloned().unwrap_or_default();
let kind = |key: &str| text(key).as_deref().and_then(QueueKind::parse);
let op = value["op"].as_str().ok_or("op must be a string")?;
Ok(match op {
"prompt" => Op::Prompt {
message: need("message")?,
images: images(),
queue: kind("queue"),
},
"promptAndWait" => Op::PromptAndWait {
message: need("message")?,
images: images(),
},
"enqueue" => Op::Enqueue {
kind: kind("kind").ok_or("kind must be steer, followUp or nextRun")?,
message: need("message")?,
images: images(),
entry_id: text("entryId"),
},
"cancelQueued" => Op::CancelQueued {
entry_id: need("entryId")?,
},
"clearQueue" => Op::ClearQueue,
"abort" => Op::Abort,
"state" => Op::State,
"availableModels" => Op::AvailableModels,
"setModel" => Op::SetModel {
provider: need("provider")?,
model_id: need("modelId")?,
},
"cycleModel" => Op::CycleModel,
"thinkingLevels" => Op::ThinkingLevels,
"setThinking" => Op::SetThinking { level: need("level")? },
"cycleThinking" => Op::CycleThinking,
"setQueueMode" => Op::SetQueueMode {
kind: kind("kind")
.filter(|kind| *kind != QueueKind::NextRun)
.ok_or("kind must be steer or followUp")?,
mode: need("mode")?,
},
"compact" => Op::Compact {
instructions: text("instructions"),
},
"setAutoCompaction" => Op::SetAutoCompaction(value["enabled"] == true),
"setAutoRetry" => Op::SetAutoRetry(value["enabled"] == true),
"setTerminalTheme" => Op::SetTerminalTheme { theme: need("theme")? },
"abortRetry" => Op::AbortRetry,
"bash" => Op::Bash {
command: need("command")?,
exclude: value["exclude"] == true,
id: value["id"].as_str().map(str::to_string),
},
"abortBash" => Op::AbortBash,
"checkpoints" => Op::Checkpoints,
"restoreFiles" => Op::RestoreFiles {
entry_id: text("entryId"),
checkpoint: text("checkpoint"),
},
"bugSummary" => Op::BugSummary {
hint: value["hint"].as_str().map(str::to_string),
},
"abortBugSummary" => Op::AbortBugSummary,
"shareContext" => Op::ShareContext,
"appendCustom" => Op::AppendCustom {
custom_type: need("customType")?,
data: value["data"].clone(),
},
"stats" => Op::Stats,
"forkMessages" => Op::ForkMessages,
"entries" => Op::Entries { since: text("since") },
"tree" => Op::Tree,
"lastAssistantText" => Op::LastAssistantText,
"setName" => Op::SetName { name: need("name")? },
"messages" => Op::Messages,
"forkSource" => Op::ForkSource {
entry_id: need("entryId")?,
},
"cloneSource" => Op::CloneSource,
"forked" => Op::Forked {
target: need("target")?,
},
"describe" => Op::Describe,
"laneSnapshot" => Op::LaneSnapshot,
"listSessions" => Op::ListSessions,
"recover" => Op::Recover,
"agents" => Op::Agents,
"setLabel" => Op::SetLabel {
entry_id: need("entryId")?,
label: text("label"),
},
"navigate" => Op::Navigate {
target_id: text("targetId"),
summarize: value["summarize"] == true,
instructions: text("customInstructions"),
label: text("label"),
},
"killAgent" => Op::KillAgent { id: need("id")? },
"steerAgent" => Op::SteerAgent {
id: need("id")?,
message: need("message")?,
},
"reviveAgent" => Op::ReviveAgent { id: need("id")? },
"agentTranscript" => Op::AgentTranscript { id: need("id")? },
"observer" => Op::Observer {
args: text("args").unwrap_or_default(),
},
"goal" => Op::Goal {
args: text("args").unwrap_or_default(),
},
"startConversation" => Op::StartConversation {
message: need("message")?,
},
"conversationInput" => Op::ConversationInput {
id: value["id"].as_u64().ok_or("id must be a conversation id")?,
message: need("message")?,
},
"conversations" => Op::Conversations {
id: value["id"].as_u64(),
},
"asyncPending" => Op::AsyncPending,
"commands" => Op::Commands,
"inspect" => Op::Inspect {
request: need("request")?,
payload: value.get("payload").cloned().unwrap_or(Value::Null),
},
"scheduleFire" => Op::ScheduleFire {
id: need("id")?,
due: value["due"].as_i64().ok_or("due must be a time in ms")?,
},
"scheduleCancel" => Op::ScheduleCancel { id: need("id")? },
"persona" => Op::Persona {
args: text("args").unwrap_or_default(),
},
"keepGoing" => Op::KeepGoing {
args: text("args").unwrap_or_default(),
},
"continueFrom" => Op::ContinueFrom {
session: need("session")?,
},
other => return Err(format!("Unknown session operation: {other}")),
})
}
pub fn to_json(&self) -> Value {
match self {
Op::Prompt { message, images, queue } => {
json!({"op": "prompt", "message": message, "images": images, "queue": queue.map(QueueKind::name)})
}
Op::PromptAndWait { message, images } => {
json!({"op": "promptAndWait", "message": message, "images": images})
}
Op::Enqueue {
kind,
message,
images,
entry_id,
} => {
json!({"op": "enqueue", "kind": kind.name(), "message": message, "images": images, "entryId": entry_id})
}
Op::CancelQueued { entry_id } => json!({"op": "cancelQueued", "entryId": entry_id}),
Op::ClearQueue => json!({"op": "clearQueue"}),
Op::Abort => json!({"op": "abort"}),
Op::State => json!({"op": "state"}),
Op::AvailableModels => json!({"op": "availableModels"}),
Op::SetModel { provider, model_id } => json!({"op": "setModel", "provider": provider, "modelId": model_id}),
Op::CycleModel => json!({"op": "cycleModel"}),
Op::ThinkingLevels => json!({"op": "thinkingLevels"}),
Op::SetThinking { level } => json!({"op": "setThinking", "level": level}),
Op::CycleThinking => json!({"op": "cycleThinking"}),
Op::SetQueueMode { kind, mode } => json!({"op": "setQueueMode", "kind": kind.name(), "mode": mode}),
Op::Compact { instructions } => json!({"op": "compact", "instructions": instructions}),
Op::SetAutoCompaction(enabled) => json!({"op": "setAutoCompaction", "enabled": enabled}),
Op::SetAutoRetry(enabled) => json!({"op": "setAutoRetry", "enabled": enabled}),
Op::SetTerminalTheme { theme } => json!({"op": "setTerminalTheme", "theme": theme}),
Op::AbortRetry => json!({"op": "abortRetry"}),
Op::Bash { command, exclude, id } => {
let mut op = json!({"op": "bash", "command": command, "exclude": exclude});
if let Some(id) = id {
op["id"] = json!(id);
}
op
}
Op::AbortBash => json!({"op": "abortBash"}),
Op::BugSummary { hint } => json!({"op": "bugSummary", "hint": hint}),
Op::AbortBugSummary => json!({"op": "abortBugSummary"}),
Op::ShareContext => json!({"op": "shareContext"}),
Op::AppendCustom { custom_type, data } => {
json!({"op": "appendCustom", "customType": custom_type, "data": data})
}
Op::Stats => json!({"op": "stats"}),
Op::ForkMessages => json!({"op": "forkMessages"}),
Op::Entries { since } => json!({"op": "entries", "since": since}),
Op::Tree => json!({"op": "tree"}),
Op::LastAssistantText => json!({"op": "lastAssistantText"}),
Op::SetName { name } => json!({"op": "setName", "name": name}),
Op::Messages => json!({"op": "messages"}),
Op::ForkSource { entry_id } => json!({"op": "forkSource", "entryId": entry_id}),
Op::CloneSource => json!({"op": "cloneSource"}),
Op::Forked { target } => json!({"op": "forked", "target": target}),
Op::Describe => json!({"op": "describe"}),
Op::LaneSnapshot => json!({"op": "laneSnapshot"}),
Op::ListSessions => json!({"op": "listSessions"}),
Op::Recover => json!({"op": "recover"}),
Op::Agents => json!({"op": "agents"}),
Op::SetLabel { entry_id, label } => json!({"op": "setLabel", "entryId": entry_id, "label": label}),
Op::Navigate {
target_id,
summarize,
instructions,
label,
} => {
json!({"op": "navigate", "targetId": target_id, "summarize": summarize, "customInstructions": instructions, "label": label})
}
Op::KillAgent { id } => json!({"op": "killAgent", "id": id}),
Op::SteerAgent { id, message } => json!({"op": "steerAgent", "id": id, "message": message}),
Op::ReviveAgent { id } => json!({"op": "reviveAgent", "id": id}),
Op::AgentTranscript { id } => json!({"op": "agentTranscript", "id": id}),
Op::Goal { args } => json!({"op": "goal", "args": args}),
Op::Observer { args } => json!({"op": "observer", "args": args}),
Op::StartConversation { message } => json!({"op": "startConversation", "message": message}),
Op::ConversationInput { id, message } => json!({"op": "conversationInput", "id": id, "message": message}),
Op::Conversations { id } => json!({"op": "conversations", "id": id}),
Op::AsyncPending => json!({"op": "asyncPending"}),
Op::Inspect { request, payload } => json!({"op": "inspect", "request": request, "payload": payload}),
Op::Commands => json!({"op": "commands"}),
Op::Checkpoints => json!({"op": "checkpoints"}),
Op::RestoreFiles { entry_id, checkpoint } => {
json!({"op": "restoreFiles", "entryId": entry_id, "checkpoint": checkpoint})
}
Op::ScheduleFire { id, due } => json!({"op": "scheduleFire", "id": id, "due": due}),
Op::ScheduleCancel { id } => json!({"op": "scheduleCancel", "id": id}),
Op::Persona { args } => json!({"op": "persona", "args": args}),
Op::KeepGoing { args } => json!({"op": "keepGoing", "args": args}),
Op::ContinueFrom { session } => json!({"op": "continueFrom", "session": session}),
}
}
}
pub enum Input {
Op(Op, Reply),
ObserverCompleted(observer::Completion),
Agent(Box<AgentEvent>),
Title(Box<AssistantMessage>),
BugSummaryEnded(u64),
MemoryKept(crate::auto_memory::Outcome),
BashDone {
command: String,
exclude: bool,
result: Result<Value, String>,
reply: Reply,
},
BashOutput {
id: Option<String>,
delta: String,
},
Close(std::sync::mpsc::Sender<()>),
HandOver(std::sync::mpsc::Sender<()>),
EventLane(event_lanes::LaneCall, std::sync::mpsc::Sender<event_lanes::LaneAnswer>),
ActivityTick,
Turn(crate::turns::Request),
HarnessIdle,
Woken,
Scheduled(Value),
TurnChecked {
id: u64,
failed: Vec<String>,
},
}
pub type EventSink = Box<dyn FnMut(Value) + Send>;
#[derive(Clone)]
struct Queued {
kind: QueueKind,
message: Value,
entry_id: String,
turn: u64,
submission: Option<durable::SubmissionId>,
}
struct Queues {
items: Vec<Queued>,
delivered: Vec<Queued>,
steering_all: bool,
follow_up_all: bool,
}
impl Queues {
fn visible(&self) -> Vec<&Queued> {
self.delivered.iter().chain(&self.items).collect()
}
}
fn select_accepted(queues: &Queues, take_queued: bool) -> Vec<(String, Value)> {
let (mut steer_taken, mut follow_up_taken) = (false, false);
let mut selected = Vec::new();
for item in queues.items.iter().filter(|q| q.submission.is_none()) {
let eligible = match item.kind {
QueueKind::NextRun => true,
QueueKind::Steer => take_queued && (queues.steering_all || !steer_taken),
QueueKind::FollowUp => take_queued && (queues.follow_up_all || !follow_up_taken),
};
if eligible {
steer_taken |= item.kind == QueueKind::Steer;
follow_up_taken |= item.kind == QueueKind::FollowUp;
selected.push((item.entry_id.clone(), item.message.clone()));
}
}
selected
}
struct Running {
id: String,
signal: AbortSignal,
journal: RunJournal,
prompt: Value,
captured: Vec<Value>,
submission: Option<durable::SubmissionId>,
prompt_pending: bool,
turns: u64,
started_tip: Value,
error: Option<String>,
waiter: Option<Reply>,
cancelled: bool,
compaction_failed: bool,
resume_overflow: Option<Value>,
hiding: bool,
ending: bool,
}
pub struct OpenOptions {
pub env: RunEnv,
pub flags: ModelFlags,
pub session_root: PathBuf,
pub metadata: Metadata,
pub mode: String,
pub services: Services,
pub auto_name: bool,
}
const IDLE_WAIT: std::time::Duration = std::time::Duration::from_secs(60);
pub struct Core {
model_unavailable: bool,
env: RunEnv,
keys: crate::request_keys::Keys,
repo: SessionRepo,
runtime: Runtime,
provider: Arc<Provider>,
model: Model,
models: Vec<Model>,
thinking: String,
session: SharedSession,
lane: Lane,
tx: Sender<Input>,
sink: EventSink,
run: Option<Running>,
loki_notice: crate::loki_notice::LokiNotice,
auto_memory: crate::auto_memory::AutoMemory,
memory_notice: Option<String>,
auto_refine: crate::auto_refine::AutoRefine,
queues: Arc<Mutex<Queues>>,
auto_compaction: bool,
auto_retry: bool,
bash: Option<kernel::Signal>,
bug_summary: Option<(u64, AbortSignal)>,
announced: usize,
announced_usage: usize,
taken: Vec<String>,
auto_name: bool,
recovered: Option<crate::recovery::Recovered>,
durable: durable_turns::Durable,
resumed: Option<String>,
events: Arc<crate::async_events::Dispatcher>,
context: Arc<kernel_apis::ContextControl>,
branches: Arc<context_lane::RootBranches>,
inputs: Option<std::sync::mpsc::Receiver<Input>>,
deferred: std::collections::VecDeque<Input>,
compacting: Option<AbortSignal>,
navigating: bool,
after_run: Vec<Input>,
nudger: crate::nudge::ToolRoundNudger,
skill_nudger: crate::nudge::SkillExtractionNudger,
persona: resources::persona::Chain,
persona_session: resources::keep_going::SessionPersona,
observer: observer::Observer,
turn_guard: turn_guard::TurnGuard,
}
mod auto_compact;
mod checkpoints;
pub use checkpoints::{RESTORE_IN_SANDBOX, RESTORE_WHILE_STREAMING};
mod agent_ops;
pub(crate) mod budget_gate;
mod compacting;
mod context_children;
mod context_lane;
mod continue_from;
pub mod durable_turns;
pub mod event_lanes;
mod observer;
mod persona_nudge;
mod schedule_ops;
pub mod turn_guard;
mod user_bash;
const SESSION_START: (&str, &str) = ("ultron.session.start", "fork");
pub fn user_message(text: String, images: Vec<Value>) -> Value {
let mut content = vec![json!({"type": "text", "text": text})];
content.extend(images);
json!({"role": "user", "content": content, "timestamp": now_ms()})
}
fn stored(message: &Message) -> Value {
let mut value = serde_json::to_value(message).unwrap_or(Value::Null);
if value["role"] == "toolResult" && value["isError"] == true && value["details"] == json!({}) {
value.as_object_mut().map(|m| m.remove("details"));
}
value
}
const MODEL_UNAVAILABLE: &str = "The configured model is unavailable in this process";
pub const ROOT_ENV: &str = "ULTRON_ROOT";
pub fn claude_root_requested(var: &dyn Fn(&str) -> Option<String>) -> bool {
var(ROOT_ENV).is_some_and(|v| jsrt::string::trim(&v).to_lowercase() == "claude")
}
fn unavailable_model(provider: &str, id: &str) -> Model {
Model {
id: id.to_string(),
name: id.to_string(),
api: String::new(),
provider: provider.to_string(),
base_url: String::new(),
reasoning: false,
thinking_level_map: None,
input: vec!["text".to_string()],
input_limits: None,
cost: Default::default(),
prompt_cache: None,
context_window: 0,
max_tokens: 0,
sampling_params: None,
headers: None,
compat: None,
request: None,
extra: Default::default(),
}
}
pub fn lane_config(flags: &ModelFlags, env: &RunEnv, session: Option<&mut Session>) -> Result<(Value, Model), String> {
lane_config_resolving(flags, env, session).map(|(config, model, _)| (config, model))
}
fn lane_config_resolving(
flags: &ModelFlags,
env: &RunEnv,
session: Option<&mut Session>,
) -> Result<(Value, Model, bool), String> {
let stored = session
.as_ref()
.and_then(|s| s.value(session_journal::ns::LANE_CONFIG, "main").cloned());
let choice = match (&flags.model, &stored) {
(None, Some(_)) => Err("No model selected: pass --model <provider>/<id>".to_string()),
_ => lane::resolve_choice(flags, env, stored.is_some()),
};
let thinking = match (&flags.thinking, &choice) {
(Some(level), _) => level.clone(),
(None, Ok(choice)) => choice
.thinking
.clone()
.unwrap_or_else(|| lane::initial_thinking(&choice.model, env)),
(None, Err(_)) => "medium".into(),
};
let flag_model = choice.map(|choice| choice.model);
let wanted = match (&flag_model, stored) {
(Ok(m), _) => run::lane_config(&m.provider, &m.id, &thinking, &["rlm"]),
(Err(_), Some(mut stored)) => {
stored["activeToolNames"] = json!(["rlm"]);
stored
}
(Err(e), None) => return Err(e.clone()),
};
let config = match session {
Some(session) => {
let mut config = run::ensure_lane(session, &wanted)?;
if let Some(level) = flags.thinking.as_ref().filter(|_| flags.model.is_none())
&& config["thinkingLevel"] != json!(level)
{
config["thinkingLevel"] = json!(level);
session.commit(&[Write::set(LANE_CONFIG, session_journal::run::MAIN_LANE, config.clone())])?;
}
if claude_root_requested(&*env.var)
&& let Ok(m) = &flag_model
&& config["model"]["provider"] != json!(m.provider)
{
config["model"] = json!({"provider": m.provider, "modelId": m.id});
session.commit(&[Write::set(LANE_CONFIG, session_journal::run::MAIN_LANE, config.clone())])?;
}
config
}
None => wanted,
};
let model = match (
config["model"]["provider"].as_str(),
config["model"]["modelId"].as_str(),
flag_model,
) {
(Some(provider), Some(id), Ok(m)) if (provider, id) == (m.provider.as_str(), m.id.as_str()) => m,
(Some(provider), Some(id), _) => match lane::catalog_model(provider, id, env) {
Ok(model) => model,
Err(_) => return Ok((config.clone(), unavailable_model(provider, id), true)),
},
(_, _, m) => m?,
};
Ok((config, model, false))
}
pub fn record_usage_row(session: &mut Session, usage: Value, details: Value) -> Result<(), String> {
let id = session_journal::lock_clock(&session.clock()).next_id();
let mut row = Write::usage(&id, usage, None);
if let Write::Usage(fields) = &mut row {
fields.insert("details".into(), details);
}
session.commit(&[row]).map(|_| ())
}
pub fn record_naming(session: &mut Session, response: &AssistantMessage) -> Result<(), String> {
let usage = serde_json::to_value(&response.usage).map_err(|e| e.to_string())?;
record_usage_row(
session,
usage,
json!({"source": "session-naming", "model": format!("{}/{}", response.provider, response.model)}),
)?;
if let Some(title) = naming::title_of(response) {
names::replace_auto_name(session, &title)?;
}
Ok(())
}
impl Core {
pub fn open(options: OpenOptions, tx: Sender<Input>, sink: EventSink) -> Result<Core, String> {
let OpenOptions {
env,
flags,
session_root,
metadata,
mode,
services,
auto_name,
} = options;
let repo = SessionRepo::new(&session_root, SystemClock::shared());
let mut session = repo.open(&metadata)?;
crate::format_version::assert_session_formats_readable(&session)?;
let open_operation = session
.value(LANE_STATE, MAIN_LANE)
.and_then(|state| state["currentOperationId"].as_str().map(str::to_string));
let durable_records = crate::durable_store::has_records(&session)
&& open_operation.as_ref().is_none_or(|operation| {
session
.value(session_journal::ns::OP_META, operation)
.is_none_or(|meta| meta["intent"]["kind"].as_str().is_none_or(|kind| kind == "run"))
});
let recovered = match &open_operation {
Some(_) if !durable_records => crate::recovery::settle(&mut session)?,
_ => crate::recovery::Recovered {
queued: crate::recovery::inbox(&session),
..Default::default()
},
};
let resume = open_operation.filter(|_| durable_records);
let sessions_dir = session_root.join(session_journal::catalog::session_directory_name(&metadata.cwd));
let trace = |label: &str| {
crate::startup_trace::trace_startup((env.var)(crate::startup_trace::TRACE_ENV).as_deref(), label)
};
trace("worker.harness");
let mut runtime = Runtime::new(&env, &mode, sessions_dir, services)?;
trace("worker.resources-loaded");
let loki_notice = crate::loki_notice::LokiNotice::start(&runtime.config);
let (config, model, model_unavailable) = lane_config_resolving(&flags, &env, Some(&mut session))?;
let keys = crate::request_keys::Keys::session(flags.api_key.clone(), &model.provider, &env);
let announced = session.state().entries().len();
let announced_usage = session.state().usage_rows().len();
let session_id = session.id().to_string();
let session: SharedSession = Arc::new(Mutex::new(session));
let values = crate::session_modules::session_values(&session);
runtime.services.values = Some(values.clone());
let children = crate::subagents::DurableChildren::new();
let unfinished = crate::subagents::unfinished(&session);
trace("worker.harness-create");
let lane = Lane::open_with(
&runtime,
&model,
flags.api_key.clone(),
&session_id,
Some(children.host(values)),
)?;
trace("worker.host");
lane.stack
.stats
.attach(Arc::new(crate::session_stats::SessionStore(session.clone())));
let branches = Arc::new(context_lane::RootBranches::new(session.clone()));
let child_context = Arc::new(context_children::ChildContext::new(children.clone(), session.clone()));
let context = Arc::new(
kernel_apis::ContextControl::new(Arc::new(context_children::LaneBranches {
root: branches.clone(),
children: child_context.clone(),
}))
.with_trim(!env.flag_off(kernel_apis::context_control::COMPACTION_TRIM_ENV)),
);
child_context.observe(&context);
let _ = lane.stack.context.set(context.clone());
let provider = Arc::new(Provider::new().with_live_settings(runtime.config.settings_reader()));
let queues = Arc::new(Mutex::new(Queues {
items: recovered
.queued
.iter()
.filter_map(|q| {
Some(Queued {
kind: QueueKind::parse(&q.kind)?,
message: q.message.clone(),
entry_id: q.entry_id.clone(),
turn: 0,
submission: None,
})
})
.collect(),
delivered: Vec::new(),
steering_all: config::keys::QUEUE_DEFAULT == config::keys::QUEUE_ALL,
follow_up_all: config::keys::QUEUE_DEFAULT == config::keys::QUEUE_ALL,
}));
let durable = durable_turns::open_durable(
&session,
&tx,
&lane,
provider.clone(),
&env,
&keys,
queues.clone(),
children.clone(),
child_context,
runtime.config.context_images,
)?;
children.attach(durable.chat.clone());
let steer_children = children.clone();
let _ = lane
.stack
.lane_steer
.set(Arc::new(move |child_lane: &str, message: &str| {
let (Some(chat), Some(conversation)) =
(steer_children.chat(), steer_children.conversation_of_lane(child_lane))
else {
return false;
};
if chat.live(conversation).map_or(true, |live| live["run"].is_null()) {
return false;
}
chat.conversation(conversation).ok().flatten().is_some_and(|handle| {
handle
.submit(harness::chat::SubmissionDraft::Input {
content: json!(message),
when_busy: harness::chat::WhenBusy::Steer,
request_id: None,
})
.is_ok()
})
}));
let _ = lane.stack.budget_note.set(crate::budget_note::budget_note(
children.clone(),
lane.stack.agents.clone(),
lane.stack.usage.clone(),
));
let meter_children = children.clone();
lane.stack.context_reminders.set_meter(Arc::new(move |lane_name: &str| {
let chat = meter_children.chat()?;
let conversation = if lane_name == session_journal::run::MAIN_LANE {
durable::ROOT_CONVERSATION_ID
} else {
meter_children.conversation_of_lane(lane_name)?
};
let view = chat.conversation(conversation).ok().flatten()?.context(None).ok()?;
Some(crate::context_reminder::Measure {
tokens: harness::chat::compaction::estimate_context(&view, &[]),
epoch: view.head.as_ref().map(|head| head.id.0),
})
}));
let _ = lane.stack.swarm.set(Arc::new(
crate::swarm_ops::SwarmOps::new(children.clone()).with_contracts(Arc::downgrade(&lane.stack)),
));
lane.stack.delegation.set_fork_point(children.fork_point_hook());
let transcripts = durable.chat.clone();
lane.stack.delegation.set_transcripts(Arc::new(move |lane: &str| {
crate::agent_hub::child_transcript(&transcripts, lane).map(|(messages, _)| messages)
}));
children.restore(&lane.stack, &unfinished)?;
let events = event_lanes::install(
&lane,
&env,
tx.clone(),
durable.chat.clone(),
children.clone(),
durable.stop.clone(),
session.clone(),
);
event_lanes::tick_activity(tx.clone(), durable.stop.clone());
let sweep_stop = durable.stop.clone();
lane.stack
.lanes
.sweep_every(lanes::IDLE_SWEEP_INTERVAL, move |interval| {
sweep_stop.wait_timeout(interval).is_some()
});
let auto_compaction = runtime.config.settings["compaction"]["enabled"] != false;
let nudger = crate::nudge::ToolRoundNudger::new(runtime.config.tool_rounds_nudge, runtime.config.async_events);
let skill_nudger = crate::nudge::SkillExtractionNudger::new(runtime.config.skill_nudge);
let auto_memory = crate::auto_memory::AutoMemory::new(&runtime.config.settings, runtime.memory_explicit);
let auto_refine =
crate::auto_refine::AutoRefine::new(&runtime.config.settings, (env.var)(AUTO_REFINE_ENV).as_deref());
let observer =
observer::Observer::new(runtime.config.settings["observer"]["enabled"].as_bool().unwrap_or(true));
let mut core = Core {
model_unavailable,
loki_notice,
memory_notice: runtime.memory_notice.clone(),
auto_memory,
auto_refine,
thinking: config["thinkingLevel"].as_str().unwrap_or("medium").to_string(),
models: lane::available_models(&env),
provider,
env,
keys,
repo,
runtime,
model,
session,
lane,
tx,
sink,
run: None,
queues,
auto_compaction,
auto_retry: true,
bash: None,
bug_summary: None,
announced_usage,
announced,
taken: Vec::new(),
auto_name,
recovered: Some(recovered),
durable,
resumed: None,
events,
context,
branches,
inputs: None,
deferred: std::collections::VecDeque::new(),
compacting: None,
navigating: false,
after_run: Vec::new(),
nudger,
skill_nudger,
persona: Default::default(),
persona_session: Default::default(),
observer,
turn_guard: Default::default(),
};
core.persona_load();
if let Some(operation) = resume {
core.resumed = Some(core.reopen_run(&operation)?);
} else {
core.branches.place(true)?;
}
core.durable.chat.resume().map_err(|e| e.to_string())?;
let forked = lock_session(&core.session)
.value(SESSION_START.0, SESSION_START.1)
.is_some();
if forked {
lock_session(&core.session).commit(&[Write::delete(SESSION_START.0, SESSION_START.1)])?;
}
Ok(core)
}
pub fn model(&self) -> &Model {
&self.model
}
pub fn thinking_level(&self) -> &str {
&self.thinking
}
pub fn session(&self) -> SharedSession {
self.session.clone()
}
pub fn runtime(&self) -> &Runtime {
&self.runtime
}
pub fn snapshot(&self) -> Value {
let entries = lock_session(&self.session)
.branch_entries(MAIN_LANE)
.unwrap_or_default();
let mut usage = session_journal::usage::empty_usage();
for row in lock_session(&self.session).state().usage_rows() {
usage = session_journal::usage::add_usage(&usage, &row["usage"]);
}
json!({
"lane": MAIN_LANE,
"transcript": entries,
"tipId": lock_session(&self.session).branch_tip(MAIN_LANE).flatten(),
"configuration": {"model": {"provider": self.model.provider, "modelId": self.model.id}, "thinkingLevel": self.thinking, "activeToolNames": ["rlm"]},
"stats": {"messageCount": entries.iter().filter(|e| e["type"] == "message").count(), "usage": usage},
"operation": null,
"queues": [],
"faulted": false,
})
}
pub fn run_loop(mut self, inputs: std::sync::mpsc::Receiver<Input>) {
self.inputs = Some(inputs);
while let Some(input) = self.next_input() {
match input {
Input::Op(op, reply) => self.op(op, reply),
Input::ObserverCompleted(completion) => self.observer_completed(completion),
Input::Agent(event) => self.on_agent_event(*event),
Input::Title(response) => {
if record_naming(&mut lock_session(&self.session), &response).is_ok() {
self.name_changed();
}
}
Input::Turn(request) => self.on_turn(request),
Input::HarnessIdle => self.harness_idle(),
Input::BugSummaryEnded(number) => {
if self.bug_summary.as_ref().is_some_and(|(current, _)| *current == number) {
self.bug_summary = None;
}
}
Input::MemoryKept(outcome) => self.memory_kept(outcome),
Input::BashDone {
command,
exclude,
result,
reply,
} => self.bash_done(command, exclude, result, reply),
Input::BashOutput { id, delta } => self.emit_bash_output(id, delta),
Input::Close(done) => {
self.close();
let _ = done.send(());
return;
}
Input::HandOver(done) => {
self.close_for_successor();
let _ = done.send(());
return;
}
Input::EventLane(call, reply) => self.event_lane(call, reply),
Input::ActivityTick => {
if self.run.as_ref().is_some_and(|run| run.ending) {
self.run_end();
}
self.report_activity();
}
Input::Woken => {}
Input::Scheduled(message) => {
let _ = self.schedule_start(message);
}
Input::TurnChecked { id, failed } => self.turn_checked(id, failed),
}
}
self.close();
}
fn next_input(&mut self) -> Option<Input> {
if let Some(input) = self.deferred.pop_front() {
return Some(input);
}
loop {
let due = self.run.as_ref().and_then(|run| run.journal.held_until());
let inputs = self.inputs.as_ref()?;
let Some(due) = due else {
return inputs.recv().ok();
};
match inputs.recv_timeout(due.saturating_duration_since(std::time::Instant::now())) {
Ok(input) => return Some(input),
Err(std::sync::mpsc::RecvTimeoutError::Disconnected) => return None,
Err(std::sync::mpsc::RecvTimeoutError::Timeout) => {
if let Some(run) = self.run.as_mut() {
run.journal.flush_held(&mut lock_session(&self.session));
}
}
}
}
}
fn emit(&mut self, event: WatchEvent) {
(self.sink)(event.to_value());
}
fn name_changed(&mut self) {
let name = lock_session(&self.session).name();
self.emit(WatchEvent::SessionName {
lane: MAIN_LANE.into(),
name,
});
}
fn session_info_changed(&mut self) {
let name = lock_session(&self.session).name();
self.emit(WatchEvent::SessionInfoChanged {
lane: MAIN_LANE.into(),
name,
});
}
fn api_key(&self) -> Option<String> {
self.keys.key(&self.model.provider)
}
fn run_id(&self) -> Option<String> {
self.run.as_ref().map(|r| r.id.clone())
}
fn announce(&mut self) {
let entries: Vec<Value> = lock_session(&self.session).state().entries()[self.announced..].to_vec();
self.announced += entries.len();
for entry in entries {
let _ = self.context.entry_added(MAIN_LANE, &entry);
self.emit(WatchEvent::EntryAdded {
lane: MAIN_LANE.into(),
entry,
});
}
let rows: Vec<Value> = lock_session(&self.session)
.state()
.usage_rows()
.into_iter()
.cloned()
.collect();
for index in self.announced_usage..rows.len() {
let totals = rows[..=index]
.iter()
.fold(session_journal::usage::empty_usage(), |total, row| {
session_journal::usage::add_usage(&total, &row["usage"])
});
self.emit(WatchEvent::Usage {
lane: MAIN_LANE.into(),
row: rows[index].clone(),
totals,
});
}
self.announced_usage = rows.len();
}
fn tip(&self) -> Option<String> {
lock_session(&self.session).branch_tip(MAIN_LANE).flatten()
}
fn lane_state(&self) -> Value {
lock_session(&self.session)
.value(LANE_STATE, MAIN_LANE)
.cloned()
.unwrap_or_else(|| json!({"currentOperationId": null, "lastOperationId": null, "inbox": []}))
}
fn append(&mut self, message: Value) -> Result<(), String> {
let id = session_journal::lock_clock(&lock_session(&self.session).clock()).next_id();
let entry = Write::message_entry(&id, self.tip().as_deref(), message);
let lane_state = self.lane_state();
lock_session(&self.session).commit(&[
entry,
Write::set(BRANCH_TIP, MAIN_LANE, id.into()),
Write::set(LANE_STATE, MAIN_LANE, lane_state),
])?;
self.announce();
Ok(())
}
pub(super) fn user_message_end(&mut self, value: Value, queued: Option<String>) {
let shown = self.persona_shown(value.clone());
self.emit(WatchEvent::MessageEnd {
run_id: self.run_id(),
lane: MAIN_LANE.into(),
message: shown,
});
let delivered = queued.and_then(|entry_id| {
let mut queues = sync::lock(&self.queues);
let found = queues.delivered.iter().position(|q| q.entry_id == entry_id);
found.map(|i| queues.delivered.remove(i))
});
let first = self
.run
.as_mut()
.is_some_and(|run| std::mem::take(&mut run.prompt_pending));
let committed = match &delivered {
Some(queued) if self.taken.contains(&queued.entry_id) => {
self.taken.retain(|id| *id != queued.entry_id);
Ok(())
}
Some(queued) => self.commit_queued(queued, value),
None if !first => lock_session(&self.session).append_message(MAIN_LANE, value).map(drop),
None => Ok(()),
};
if let Err(error) = committed {
self.fail_run(error);
}
self.announce();
if delivered.is_some() {
self.queue_update();
}
}
fn commit_queued(&mut self, queued: &Queued, message: Value) -> Result<(), String> {
let entry = Write::message_entry(&queued.entry_id, self.tip().as_deref(), message);
lock_session(&self.session).commit(&[
entry,
Write::delete(PENDING_ENTRY, &queued.entry_id),
Write::set(BRANCH_TIP, MAIN_LANE, queued.entry_id.clone().into()),
])?;
Ok(())
}
fn queue_update(&mut self) {
let queues = sync::lock(&self.queues)
.visible()
.into_iter()
.map(|q| QueueItem {
item: "message".into(),
kind: q.kind,
entry_id: q.entry_id.clone(),
message: Some(q.message.clone()),
custom_type: None,
})
.collect();
self.emit(WatchEvent::QueueUpdate {
lane: MAIN_LANE.into(),
queues,
});
}
fn store_lane_config(&mut self) -> Result<(), String> {
let mut config = lock_session(&self.session)
.value(LANE_CONFIG, MAIN_LANE)
.cloned()
.unwrap_or_else(|| run::lane_config("", "", "", &["rlm"]));
config["model"] = json!({"provider": self.model.provider, "modelId": self.model.id});
config["thinkingLevel"] = json!(self.thinking);
if lock_session(&self.session).value(LANE_CONFIG, MAIN_LANE) != Some(&config) {
lock_session(&self.session).commit(&[Write::set(LANE_CONFIG, MAIN_LANE, config)])?;
}
Ok(())
}
fn idle(&self) -> Result<(), String> {
if self.run.is_some() {
return Err("Agent is already processing".into());
}
Ok(())
}
fn journal(&mut self, event: &AgentEvent) {
if let Some(run) = self.run.as_mut() {
run.journal.event(&mut lock_session(&self.session), event);
}
}
fn on_agent_event(&mut self, agent_event: AgentEvent) {
let run = self.run_id();
match &agent_event {
AgentEvent::MessageStart { message } => {
let value = stored(message);
let aborted = self.run.as_ref().is_some_and(|r| r.signal.aborted());
if aborted
&& value["role"] == "assistant"
&& value["stopReason"] == "aborted"
&& value["content"].as_array().is_none_or(Vec::is_empty)
{
if let Some(run) = self.run.as_mut() {
run.hiding = true;
}
return;
}
self.journal(&agent_event);
let shown = self.persona_shown(value);
self.emit(WatchEvent::MessageStart {
run_id: run,
lane: MAIN_LANE.into(),
message: shown,
});
}
AgentEvent::MessageUpdate {
message,
assistant_message_event,
} => {
if self.run.as_ref().is_some_and(|run| run.hiding) {
return;
}
self.journal(&agent_event);
let (frame, usage) = crate::journal::update_fields(message, assistant_message_event);
self.emit(WatchEvent::MessageUpdate {
run_id: run,
lane: MAIN_LANE.into(),
frame,
usage,
message: None,
});
}
AgentEvent::MessageEnd { message } => {
if self.run.as_mut().is_some_and(|run| std::mem::take(&mut run.hiding)) {
return;
}
let value = stored(message);
if value["role"] == "user" {
return self.user_message_end(value, None);
}
if value["role"] == "assistant"
&& let Some(running) = self.run.as_mut()
{
running.error = value["errorMessage"].as_str().map(str::to_string);
}
let shown = self.persona_shown(value.clone());
self.emit(WatchEvent::MessageEnd {
run_id: run,
lane: MAIN_LANE.into(),
message: shown,
});
let answered = value["role"] == "assistant";
let round_message = Some(value.clone());
let mut retry = None;
if let Message::Assistant(answer) = message {
retry = self.retry_decision(answer);
}
if value["role"] == "assistant" {
self.persona_assistant(&value);
self.turn_guard_assistant(&value);
}
self.journal(&agent_event);
self.announce();
let retried = matches!(retry, Some(WatchEvent::RetryScheduled { .. }));
if let Some(note) = retry {
self.emit(note);
}
if let Some(message) = round_message.filter(|_| !retried) {
self.count_round(&message);
}
if answered {
let _ = self.context.message_end(MAIN_LANE, "assistant");
}
}
AgentEvent::ToolExecutionStart {
tool_call_id,
tool_name,
args,
} => {
self.journal(&agent_event);
self.emit(WatchEvent::ToolStart {
run_id: run,
lane: MAIN_LANE.into(),
tool_call_id: tool_call_id.clone(),
tool_name: tool_name.clone(),
args: args.clone(),
});
}
AgentEvent::ToolExecutionUpdate {
tool_call_id,
tool_name,
args,
partial_result,
} => self.emit(WatchEvent::ToolUpdate {
run_id: run,
lane: MAIN_LANE.into(),
tool_call_id: tool_call_id.clone(),
tool_name: tool_name.clone(),
args: args.clone(),
partial_result: serde_json::to_value(partial_result).unwrap_or(Value::Null),
}),
AgentEvent::ToolExecutionEnd {
tool_call_id,
tool_name,
result,
is_error,
} => {
let mut result = serde_json::to_value(result).unwrap_or(Value::Null);
if *is_error && result["details"] == json!({}) {
result.as_object_mut().map(|m| m.remove("details"));
}
self.emit(WatchEvent::ToolEnd {
run_id: run,
lane: MAIN_LANE.into(),
tool_call_id: tool_call_id.clone(),
tool_name: tool_name.clone(),
result,
is_error: *is_error,
});
}
AgentEvent::TurnStart => self.begin_generation(),
AgentEvent::AgentStart | AgentEvent::AgentEnd { .. } | AgentEvent::TurnEnd { .. } => {}
}
}
fn begin_generation(&mut self) {
let Some(run) = self.run.as_mut() else { return };
run.turns += 1;
let turn = run.turns;
if run.signal.aborted() {
return;
}
let taken: Vec<Queued> = sync::lock(&self.queues)
.delivered
.iter()
.filter(|q| q.turn <= turn && !self.taken.contains(&q.entry_id))
.cloned()
.collect();
let tip = self.tip();
let (mut writes, mut parent) = context_lane::placement(&lock_session(&self.session), tip.clone());
for queued in &taken {
writes.push(Write::message_entry(
&queued.entry_id,
parent.as_deref(),
queued.message.clone(),
));
writes.push(Write::delete(PENDING_ENTRY, &queued.entry_id));
parent = Some(queued.entry_id.clone());
}
let trigger = taken.last().map(|q| q.entry_id.clone());
let retry_start = self
.run
.as_ref()
.and_then(|run| run.journal.run())
.and_then(|journal| Some((journal.retry_waiting()?, journal.step_id().to_string())));
if let Some((attempt, step)) = retry_start {
let run_id = self.run_id();
self.emit(WatchEvent::RetryStart {
lane: MAIN_LANE.into(),
run_id,
step,
attempt,
});
}
if let Some(placed) = parent.filter(|placed| Some(placed) != tip.as_ref()) {
writes.push(Write::set(BRANCH_TIP, MAIN_LANE, placed.into()));
}
let mut inbox = self.lane_state()["inbox"].clone();
if let Some(items) = inbox.as_array_mut() {
items.retain(|item| !taken.iter().any(|q| item["entryId"] == q.entry_id.as_str()));
}
self.taken.extend(taken.iter().map(|q| q.entry_id.clone()));
if let Some(run) = self.run.as_mut() {
run.journal.set_inbox(inbox);
run.journal
.begin_with(&mut lock_session(&self.session), writes, trigger);
}
}
fn fail_run(&mut self, error: String) {
if let Some(run) = self.run.as_mut() {
run.signal.abort();
run.error.get_or_insert(error);
}
}
fn run_end(&mut self) {
self.observer.cancel();
let operation = self.operation_id();
let Some(ending) = self.run.as_ref().map(|run| run.ending) else {
return;
};
if !ending {
if let Some(operation) = &operation {
self.lane.stack.agents.end_root_turn(operation);
}
let unanswered = self
.run
.as_ref()
.filter(|run| !run.cancelled && run.error.is_none())
.and_then(|run| self.unanswered(run.submission));
let _ = self.context.run_end(MAIN_LANE);
let waiting = context_lane::pending_count(&lock_session(&self.session));
let placed = self.branches.place(true);
if let Some(run) = self.run.as_mut() {
run.ending = true;
if let Some(unanswered) = unanswered {
run.error = Some(unanswered);
}
if let Err(error) = placed {
run.error.get_or_insert(error);
}
if let Some(write) = run.journal.error() {
run.error.get_or_insert(write.to_string());
}
}
self.announce();
if waiting > 0 {
self.queue_update();
}
self.durable.bridge.set_user_abort(false);
}
let Some(run) = self.run.as_ref() else { return };
let aborted = run.cancelled;
let finished = if aborted {
run.journal.finish_aborted(&mut lock_session(&self.session))
} else {
let code = if run.compaction_failed {
"summarization_failed"
} else {
"assistant_error"
};
let failure = run.error.as_deref().map(|m| (code, m));
run.journal.finish(Some(&mut lock_session(&self.session)), failure)
};
if finished.is_err() {
return;
}
let Some(run) = self.run.take() else { return };
let error = if aborted { None } else { run.error.clone() };
self.announce();
self.taken.clear();
sync::lock(&self.queues).delivered.clear();
let status = if aborted {
Ended::Aborted
} else if error.is_some() {
Ended::Failed
} else {
Ended::Completed
};
self.report_activity();
self.emit(WatchEvent::RunEnd {
lane: MAIN_LANE.into(),
run_id: run.id.clone(),
status,
error: error.as_ref().map(|message| Failure {
code: Some("run_failed".into()),
message: message.clone(),
}),
from_tip_id: run.started_tip.as_str().map(str::to_string),
tip_id: self.tip(),
ended_at: now_ms(),
});
let failed = error.is_some();
if let Some(operation) = &operation {
self.events.run_ended(MAIN_LANE, operation, aborted);
}
self.nudger.run_ended(&run.id);
self.skill_nudger.run_ended(&run.id);
self.lane.stack.stats.flush();
self.lane.stack.cell_hints().run_ended(MAIN_LANE);
if let Some(waiter) = run.waiter {
let error = error.map_or(Value::Null, |m| json!({"code": "run_failed", "message": m}));
waiter(Ok(Some(
json!({"accepted": true, "operationId": run.id, "error": error}),
)));
}
for input in std::mem::take(&mut self.after_run).into_iter().rev() {
self.deferred.push_front(input);
}
self.persona_run_ended(aborted, failed);
self.turn_guard_run_ended(aborted, failed);
}
fn append_custom(&mut self, custom_type: String, data: Value, reply: Reply) {
if self.run.is_some() {
self.after_run
.push(Input::Op(Op::AppendCustom { custom_type, data }, reply));
return;
}
let id = session_journal::lock_clock(&lock_session(&self.session).clock()).next_id();
let entry = Write::custom_entry(
&id,
self.tip().as_deref(),
&custom_type,
Some(data).filter(|d| !d.is_null()),
);
let lane_state = self.lane_state();
let committed = lock_session(&self.session).commit(&[
entry,
Write::set(session_journal::ns::BRANCH_TIP, MAIN_LANE, id.into()),
Write::set(session_journal::ns::LANE_STATE, MAIN_LANE, lane_state),
]);
if committed.is_ok() {
self.announce();
}
reply(committed.map(|_| None));
}
fn bash_done(&mut self, command: String, exclude: bool, result: Result<Value, String>, reply: Reply) {
self.bash = None;
let result = match result {
Ok(result) => result,
Err(e) => return reply(Err(e)),
};
let message = user_bash::bash_message(&command, &result, exclude, now_ms());
self.announce_message(&message);
if let Err(error) = self.append(message) {
return reply(Err(error));
}
reply(Ok(Some(result)));
}
fn announce_message(&mut self, message: &Value) {
self.emit(WatchEvent::MessageStart {
run_id: None,
lane: MAIN_LANE.into(),
message: message.clone(),
});
self.emit(WatchEvent::MessageEnd {
run_id: None,
lane: MAIN_LANE.into(),
message: message.clone(),
});
}
fn emit_bash_output(&mut self, id: Option<String>, delta: String) {
self.emit(WatchEvent::BashExecutionUpdate {
lane: MAIN_LANE.into(),
id,
delta,
});
}
pub fn close(&mut self) {
self.stop(false);
}
pub fn close_for_successor(&mut self) {
self.stop(true);
}
fn stop(&mut self, hand_over: bool) {
self.observer.shutdown();
if !hand_over && self.run.is_none() {
self.retain_tail(false);
}
if let Some(run) = &self.run {
run.signal.abort();
}
self.turn_guard_cancel();
if hand_over && let Some(values) = &self.runtime.services.values {
values.hand_over();
}
self.durable.stop.abort();
for id in self.durable.chat.provider_session_ids().unwrap_or_default() {
ai::openai_codex_responses::close_openai_codex_websocket_sessions(Some(&id));
}
let _ = self.durable.chat.close();
if let Some(signal) = &self.bash {
signal.abort("closing");
}
if hand_over {
self.lane.hand_over();
} else {
self.lane.shutdown();
}
self.events.close();
}
fn pi(&self) -> SessionManager {
pi_view::pi_manager(&lock_session(&self.session))
}
fn session_file(&self) -> String {
lock_session(&self.session).metadata().path.display().to_string()
}
fn op(&mut self, op: Op, reply: Reply) {
match op {
Op::Prompt { message, images, queue } => {
let (message, notice) = self.user_text(&message);
let result = if self.run.is_some() {
match queue {
Some(kind) => self.enqueue(kind, message, images, None).map(drop),
None => Err("Agent is already processing. Specify streamingBehavior ('steer' or 'followUp') to queue the message.".into()),
}
} else {
self.prompt(message, images, None).map_err(|(error, _)| error)
};
reply(result.map(|()| notice.map(|notice| json!({"keepGoing": notice}))));
}
Op::PromptAndWait { message, images } => {
let (message, _) = self.user_text(&message);
if self.run.is_some() {
return reply(Err("Agent is already processing".into()));
}
if let Err((error, reply)) = self.prompt(message, images, Some(reply)) {
reply(Err(error));
}
}
bash @ Op::Bash { .. } => self.bash(bash, reply),
Op::AppendCustom { custom_type, data } => self.append_custom(custom_type, data, reply),
Op::BugSummary { hint } => {
let summarizer = self.summarizer();
let messages = view::messages(&self.pi());
let retry = self.summary_retry();
let signal = AbortSignal::new();
static SUMMARIES: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0);
let number = SUMMARIES.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
self.bug_summary = Some((number, signal.clone()));
let tx = self.tx.clone();
std::thread::spawn(move || {
reply(
summarizer
.bug_report(&messages, hint.as_deref(), retry, &signal)
.map(|text| Some(json!(text))),
);
let _ = tx.send(Input::BugSummaryEnded(number));
});
}
compact @ Op::Compact { .. } if self.run.is_some() => {
self.abort();
self.after_run.push(Input::Op(compact, reply));
}
Op::Recover => {
let result = self.recover();
reply(result);
}
other => {
let result = self.sync_op(other);
reply(result);
}
}
}
fn user_text(&mut self, message: &str) -> (String, Option<String>) {
let message = crate::review_command::expand_review_command(message);
let notice = self.persona_user_input(&message);
self.turn_guard_user_input();
(self.expand_prompt_template(message), notice)
}
fn expand_prompt_template(&self, message: String) -> String {
if !message.starts_with('/') {
return message;
}
resources::prompt_templates::expand_prompt_template(&message, &self.lane.stack.prompt_templates())
}
fn sync_op(&mut self, op: Op) -> OpResult {
if matches!(op, Op::Describe) {
self.lane.stack.stats.flush();
}
match op {
Op::Prompt { .. }
| Op::PromptAndWait { .. }
| Op::Bash { .. }
| Op::BugSummary { .. }
| Op::AppendCustom { .. }
| Op::Recover => {
unreachable!("answered in op")
}
Op::Enqueue {
kind,
message,
images,
entry_id,
} => {
let (message, _) = self.user_text(&message);
self.enqueue(kind, message, images, entry_id).map(|id| Some(json!(id)))
}
Op::CancelQueued { entry_id } => {
let found = sync::lock(&self.queues).items.iter().any(|q| q.entry_id == entry_id);
if found {
self.remove_queued(&[entry_id])?;
}
Ok(Some(json!(found)))
}
Op::ClearQueue => Ok(Some(self.clear_queue())),
Op::Abort => {
self.abort();
Ok(None)
}
Op::State => Ok(Some(self.state())),
Op::AvailableModels => {
self.models = lane::available_models(&self.env);
Ok(Some(Value::Array(
self.models
.iter()
.filter_map(|m| serde_json::to_value(m).ok())
.collect(),
)))
}
Op::SetModel { provider, model_id } => {
let find = |models: &[Model]| {
models
.iter()
.find(|m| m.provider == provider && m.id == model_id)
.cloned()
};
let model = match find(&self.models) {
Some(model) => model,
None => {
self.models = lane::available_models(&self.env);
find(&self.models).ok_or_else(|| format!("Model not found: {provider}/{model_id}"))?
}
};
self.model = model;
self.model_unavailable = false;
self.lane.stack.set_root_model(&self.model);
self.store_lane_config()?;
serde_json::to_value(&self.model).map(Some).map_err(|e| e.to_string())
}
Op::CycleModel => {
if self.models.len() < 2 {
return Ok(Some(Value::Null));
}
let index = self
.models
.iter()
.position(|m| m.provider == self.model.provider && m.id == self.model.id);
self.model = self.models[index.map_or(0, |i| (i + 1) % self.models.len())].clone();
self.model_unavailable = false;
self.lane.stack.set_root_model(&self.model);
self.store_lane_config()?;
Ok(Some(json!({
"model": serde_json::to_value(&self.model).map_err(|e| e.to_string())?,
"thinkingLevel": self.thinking,
"isScoped": false,
})))
}
Op::ThinkingLevels => Ok(Some(json!(self.thinking_levels()))),
Op::SetThinking { level } => self.set_thinking(&level).map(|()| None),
Op::CycleThinking => {
let levels = self.thinking_levels();
if levels.len() < 2 {
return Ok(Some(Value::Null));
}
let index = levels.iter().position(|l| *l == self.thinking);
let next = levels[index.map_or(0, |i| (i + 1) % levels.len())].clone();
self.set_thinking(&next)?;
Ok(Some(json!(next)))
}
Op::SetQueueMode { kind, mode } => {
let mut queues = sync::lock(&self.queues);
let all = mode == config::keys::QUEUE_ALL;
match kind {
QueueKind::Steer => queues.steering_all = all,
QueueKind::FollowUp => queues.follow_up_all = all,
QueueKind::NextRun => return Err("kind must be steer or followUp".into()),
}
Ok(None)
}
Op::Compact { instructions } => self.compact(instructions.as_deref()).map(Some),
Op::SetAutoCompaction(enabled) => {
self.auto_compaction = enabled;
Ok(None)
}
Op::SetAutoRetry(enabled) => {
self.auto_retry = enabled;
self.durable
.auto_retry
.store(enabled, std::sync::atomic::Ordering::SeqCst);
Ok(None)
}
Op::SetTerminalTheme { theme } => {
if theme != "light" && theme != "dark" {
return Err(format!("theme must be light or dark, not {theme:?}"));
}
*self
.runtime
.config
.terminal_theme
.lock()
.unwrap_or_else(|e| e.into_inner()) = Some(theme);
Ok(None)
}
Op::AbortRetry => {
if self
.run
.as_ref()
.and_then(|run| run.journal.run())
.is_some_and(|journal| journal.retry_waiting().is_some())
{
self.abort();
}
Ok(None)
}
Op::AbortBash => {
if let Some(signal) = &self.bash {
signal.abort("abort_bash");
}
Ok(None)
}
Op::AbortBugSummary => {
if let Some((_, signal)) = self.bug_summary.take() {
signal.abort();
}
Ok(None)
}
Op::ShareContext => {
let tool = agent::AgentTool::tool(&*self.lane.tool);
Ok(Some(json!({
"systemPrompt": self.runtime.system.current(),
"tools": [{"name": tool.name, "description": tool.description, "parameters": tool.parameters}],
})))
}
Op::Stats => Ok(Some(view::stats(
&self.pi(),
Some(&self.session_file()),
lock_session(&self.session).id(),
self.model.context_window,
))),
Op::ForkMessages => Ok(Some(Value::Array(view::fork_messages(&self.pi())))),
Op::Entries { since } => {
let pi = self.pi();
let mut entries = view::entries(&pi);
if let Some(since) = since {
let index = entries
.iter()
.position(|e| e["id"] == since.as_str())
.ok_or_else(|| format!("Entry not found: {since}"))?;
entries.drain(..=index);
}
Ok(Some(
json!({"entries": entries, "leafId": pi.leaf_id().cloned().unwrap_or(Value::Null)}),
))
}
Op::Tree => Ok(Some(self.labeled_tree())),
Op::LastAssistantText => Ok(Some(json!(view::last_assistant_text(&self.pi())))),
Op::SetName { name } => {
names::set_user_name(&mut lock_session(&self.session), Some(&name))?;
self.name_changed();
self.session_info_changed();
Ok(None)
}
Op::Messages => Ok(Some(Value::Array(view::messages(&self.pi())))),
Op::LaneSnapshot => Ok(Some(self.snapshot())),
Op::ForkSource { entry_id } => {
self.idle()?;
let pi = self.pi();
let entry = pi
.entry(&entry_id)
.filter(|e| e["type"] == "message" && e["message"]["role"] == "user")
.ok_or_else(|| format!("Entry is not a user message: {entry_id}"))?;
Ok(Some(json!(message_text(&entry["message"]))))
}
Op::CloneSource => {
self.idle()?;
let leaf = self.pi().leaf_id().cloned().filter(|l| !l.is_null());
leaf.map(Some)
.ok_or_else(|| "Cannot clone session: no current entry selected".to_string())
}
Op::Forked { target } => {
let metadata = session_journal::catalog::read_metadata(Path::new(&target))
.ok_or_else(|| format!("Not a session file: {target}"))?;
let mut session = self.repo.open(&metadata)?;
session.commit(&[Write::set(
SESSION_START.0,
SESSION_START.1,
json!({"previousSessionFile": self.session_file()}),
)])?;
Ok(None)
}
Op::Describe => Ok(Some(json!({
"sessionId": lock_session(&self.session).id(),
"sessionFile": self.session_file(),
"name": lock_session(&self.session).name(),
"messages": view::messages(&self.pi()),
"entries": lock_session(&self.session).branch_entries(MAIN_LANE).unwrap_or_default(),
"model": serde_json::to_value(&self.model).unwrap_or(Value::Null),
"thinkingLevel": self.thinking,
}))),
Op::Navigate {
target_id,
summarize,
instructions,
label,
} => self
.navigate(target_id, summarize, instructions.as_deref(), label)
.map(Some),
Op::SetLabel { entry_id, label } => self.set_label(&entry_id, label.as_deref()).map(|()| None),
Op::Checkpoints => Ok(Some(self.list_checkpoints())),
Op::ScheduleFire { id, due } => self.schedule_fire(&id, due),
Op::ScheduleCancel { id } => self.schedule_cancel(&id),
Op::Persona { args } => self.persona_command("persona", &args).map(Some),
Op::KeepGoing { args } => self.persona_command("keepgoing", &args).map(Some),
Op::ContinueFrom { session } => self.continue_from(&session).map(Some),
Op::RestoreFiles { entry_id, checkpoint } => self.restore_files(entry_id, checkpoint).map(Some),
Op::Agents => self.lane.stack.delegation.subagent_views(MAIN_LANE).map(Some),
Op::KillAgent { id } => self
.lane
.stack
.delegation
.cancel(&id, "Killed from the agent hub")
.map(Some),
Op::SteerAgent { id, message } => self.steer_agent(&id, &message).map(Some),
Op::ReviveAgent { id } => self.revive_agent(&id).map(Some),
Op::AgentTranscript { id } => self.agent_transcript(&id).map(Some),
Op::StartConversation { message } => self.start_conversation(&message).map(Some),
Op::ConversationInput { id, message } => self.conversation_input(id, &message).map(|()| None),
Op::Conversations { id } => self.conversations(id).map(Some),
Op::AsyncPending => Ok(Some(self.async_pending())),
Op::Commands => Ok(Some(Value::Array(self.lane.stack.commands()))),
Op::Inspect { request, .. } if request == "async.pending" => Ok(Some(self.async_pending())),
Op::Inspect { request, .. } if request == "rlm.detached" => Ok(Some(
json!({ "cells": self.lane.stack.lanes.detached_cells(MAIN_LANE) }),
)),
Op::Inspect { request, .. } if request == "rlm.pool" => Ok(Some(self.lane.stack.pool_stats())),
Op::Inspect { request, payload } => {
let runtime = self.lane.stack.cell_handler(MAIN_LANE, None);
crate::inspect::inspect(Some(&*runtime), &request, payload, &kernel::Signal::new()).map(Some)
}
Op::Goal { args } => self.lane.stack.goal.command(&args).map(|text| Some(json!(text))),
Op::Observer { args } => self.observer_command(&args).map(|text| Some(json!(text))),
Op::ListSessions => {
let listed =
names::list_sessions(Path::new(self.repo.root()), &lock_session(&self.session).metadata().cwd);
Ok(Some(Value::Array(
listed
.into_iter()
.map(|s| {
json!({"path": s.metadata.path.display().to_string(), "id": s.metadata.id, "name": s.name,
"modified": s.metadata.modified_at as i64, "messageCount": s.message_count,
"firstMessage": s.first_message, "allMessagesText": s.all_messages_text,
"cwd": s.metadata.cwd})
})
.collect(),
)))
}
}
}
fn retry_decision(&mut self, answer: &ai::AssistantMessage) -> Option<WatchEvent> {
let policy = self.summary_retry();
let run = self.run.as_mut()?;
if run.signal.aborted() {
return None;
}
let journal = run.journal.run()?;
let (attempt, step) = (journal.attempt(), journal.step_id().to_string());
if !harness::chat::models::is_context_overflow(answer)
&& let Some(delay) = policy.retry_delay(attempt, answer)
{
let not_before = now_ms().saturating_add(i64::try_from(delay).unwrap_or(i64::MAX));
let message = answer
.error_message
.clone()
.unwrap_or_else(|| "Assistant request failed".into());
run.journal.schedule_retry(not_before, message.clone());
return Some(WatchEvent::RetryScheduled {
lane: MAIN_LANE.into(),
run_id: Some(run.id.clone()),
step,
attempt: attempt + 1,
max_attempts: policy.max_attempts(),
delay_ms: delay,
not_before,
error_message: message,
});
}
if attempt <= 1 {
return None;
}
let success = !matches!(answer.stop_reason, ai::StopReason::Error | ai::StopReason::Aborted);
let final_error = (!success).then(|| {
answer.error_message.clone().unwrap_or_else(|| {
let reason = serde_json::to_value(answer.stop_reason).unwrap_or(Value::Null);
format!("Assistant request ended with {}", reason.as_str().unwrap_or_default())
})
});
Some(WatchEvent::RetryEnd {
lane: MAIN_LANE.into(),
run_id: Some(run.id.clone()),
step,
attempt,
success,
final_error,
})
}
fn count_round(&mut self, message: &Value) {
if self.run.is_none() || message["role"] != "assistant" {
return;
}
let calls = message["content"]
.as_array()
.map_or(0, |c| c.iter().filter(|b| b["type"] == "toolCall").count());
if calls == 0 {
self.turn_ended(0, 0);
}
}
pub(super) fn turn_ended(&mut self, calls: usize, failed: usize) {
let Some(run) = self.run.as_ref().map(|r| r.id.clone()) else {
return;
};
let running = self.root_started_running();
let steers: Vec<String> = [
self.nudger.turn_ended(&run, calls, running),
self.skill_nudger.turn_ended(&run, calls, failed, running),
]
.into_iter()
.flatten()
.collect();
for steer in steers {
self.lane.stack.stats.nudge(&steer);
let _ = self.enqueue(QueueKind::Steer, steer, Vec::new(), None);
}
}
fn root_started_running(&self) -> u64 {
use kernel_apis::TaskHost;
let subagents = self.lane.stack.delegation.running(MAIN_LANE).len();
let tasks = self
.lane
.stack
.agents
.tasks()
.unwrap_or_default()
.iter()
.filter(|task| task["parentId"].is_null() && task["result"].is_null())
.count();
(subagents + tasks) as u64
}
fn thinking_levels(&self) -> Vec<String> {
ai::models::supported_thinking_levels(&self.model)
.into_iter()
.map(str::to_string)
.collect()
}
fn set_thinking(&mut self, level: &str) -> Result<(), String> {
let levels = self.thinking_levels();
if !levels.iter().any(|l| l == level) {
return Err(format!(
"Thinking level {level} is unavailable; choose one of: {}",
levels.join(", ")
));
}
if self.thinking != level {
self.thinking = level.to_string();
self.store_lane_config()?;
self.emit(WatchEvent::ConfigUpdate {
lane: MAIN_LANE.into(),
property: "thinkingLevel".into(),
value: json!(level),
});
}
Ok(())
}
fn state(&self) -> Value {
let queues = sync::lock(&self.queues);
let mut state = Map::new();
state.insert("model".into(), serde_json::to_value(&self.model).unwrap_or(Value::Null));
state.insert("thinkingLevel".into(), self.thinking.clone().into());
state.insert("isStreaming".into(), self.run.is_some().into());
state.insert("isCompacting".into(), self.compacting.is_some().into());
if self.turn_guard_checking() {
state.insert("isChecking".into(), true.into());
}
let mode = |all: bool| {
if all {
config::keys::QUEUE_ALL
} else {
config::keys::QUEUE_ONE_AT_A_TIME
}
};
state.insert("steeringMode".into(), mode(queues.steering_all).into());
state.insert("followUpMode".into(), mode(queues.follow_up_all).into());
state.insert("sessionFile".into(), self.session_file().into());
state.insert("sessionId".into(), lock_session(&self.session).id().into());
if let Some(name) = lock_session(&self.session).name() {
state.insert("sessionName".into(), name.into());
}
state.insert("autoCompactionEnabled".into(), self.auto_compaction.into());
state.insert("messageCount".into(), view::messages(&self.pi()).len().into());
state.insert(
"pendingMessageCount".into(),
(queues.items.len() + queues.delivered.len()).into(),
);
Value::Object(state)
}
fn recalled_memory(&self, text: &str) -> Option<Value> {
if !self.auto_memory.recall_ready() || !crate::auto_memory::worth_recalling(text) {
return None;
}
let entries = lock_session(&self.session)
.branch_entries(MAIN_LANE)
.unwrap_or_default();
let shown = crate::auto_memory::shown(&entries);
let recalled = self.auto_memory.recall(&self.lane.stack, text, &shown);
crate::auto_memory::recall_message(&recalled, now_ms() as u64)
}
fn routed_playbook(&self, text: &str) -> Option<Value> {
crate::playbook_route::route(text)?;
let manager = (self.runtime.config.settings_reader())();
if manager.settings().get("engineering") != Some(&Value::Bool(true)) {
return None;
}
let rigor = std::path::PathBuf::from(self.runtime.config.bundled_skills()?).join("pstack/rigor");
let entries = lock_session(&self.session)
.branch_entries(MAIN_LANE)
.unwrap_or_default();
let shown = crate::playbook_route::shown(&entries);
crate::playbook_route::playbook_message(text, &rigor, &shown, now_ms() as u64)
}
fn refinements_message(&self) -> Option<Value> {
if !self.auto_refine.on {
return None;
}
let entries = lock_session(&self.session)
.branch_entries(MAIN_LANE)
.unwrap_or_default();
let shown = crate::auto_refine::shown(&entries);
let active = self.lane.stack.ledger.active();
crate::auto_refine::message(&active, shown.as_deref(), now_ms() as u64)
}
fn refine_after_compaction(&self) {
let newest = {
let session = lock_session(&self.session);
let entries = session.branch_entries(MAIN_LANE).unwrap_or_default();
entries
.iter()
.rev()
.find(|entry| entry["type"] == "compaction")
.and_then(|entry| {
Some((
entry["id"].as_str()?.to_string(),
entry["summary"].as_str()?.to_string(),
))
})
};
let Some((id, summary)) = newest.filter(|(_, summary)| !summary.trim().is_empty()) else {
return;
};
if !self.auto_refine.start_pass() {
return;
}
let summarizer = self.summarizer();
crate::auto_refine::propose(self.lane.stack.ledger.clone(), id, summary, move |system, prompt| {
summarizer.ask(system, prompt)
});
}
pub(super) fn retain_compaction(&self) {
self.refine_after_compaction();
if !self.auto_memory.retain {
return;
}
let (session_id, entries) = {
let session = lock_session(&self.session);
(
session.id().to_string(),
session.branch_entries(MAIN_LANE).unwrap_or_default(),
)
};
let cwd = self.runtime.config.cwd.display().to_string();
if let Some(keep) = crate::auto_memory::summary_keep(&session_id, &cwd, &entries) {
self.keep_in_background(keep);
}
}
pub(super) fn retain_tail(&self, in_background: bool) {
if !self.auto_memory.retain {
return;
}
let (session_id, entries) = {
let session = lock_session(&self.session);
(
session.id().to_string(),
session.branch_entries(MAIN_LANE).unwrap_or_default(),
)
};
let cwd = self.runtime.config.cwd.display().to_string();
let Some(keep) = crate::auto_memory::tail_keep(&session_id, &cwd, &entries) else {
return;
};
if in_background {
self.keep_in_background(keep);
} else {
let summarizer = self.summarizer();
let agent_dir = self.runtime.config.agent_dir.clone();
crate::auto_memory::keep(
&self.lane.stack,
&agent_dir,
keep,
move |system, prompt| summarizer.ask(system, prompt),
crate::auto_memory::CLOSE_TIMEOUT,
);
}
}
fn keep_in_background(&self, keep: crate::auto_memory::Keep) {
let summarizer = self.summarizer();
let (stack, agent_dir, tx) = (
self.lane.stack.clone(),
self.runtime.config.agent_dir.clone(),
self.tx.clone(),
);
std::thread::spawn(move || {
let outcome = crate::auto_memory::keep(
&stack,
&agent_dir,
keep,
move |system, prompt| summarizer.ask(system, prompt),
IDLE_WAIT,
);
if let Some(outcome) = outcome {
let _ = tx.send(Input::MemoryKept(outcome));
}
});
}
fn memory_kept(&mut self, outcome: crate::auto_memory::Outcome) {
if outcome.shown() {
let message = crate::auto_memory::outcome_message(&outcome, now_ms() as u64);
self.announce_message(&message);
}
}
fn prompt(&mut self, message: String, images: Vec<Value>, waiter: Option<Reply>) -> Result<(), (String, Reply)> {
self.prompt_with(user_message(message, images), waiter, true)
}
#[allow(clippy::result_large_err)]
fn prompt_with(&mut self, prompt: Value, waiter: Option<Reply>, take_queued: bool) -> Result<(), (String, Reply)> {
let fail = |error: String, waiter: Option<Reply>| -> Result<(), (String, Reply)> {
match waiter {
Some(waiter) => Err((error, waiter)),
None => Err((error, Box::new(|_| {}))),
}
};
let api_key = self.api_key();
if api_key.is_none() && !lane::header_auth(&self.env, &self.model.provider) {
return fail(format!("No API key found for {}", self.model.provider), waiter);
}
let text = message_text(&prompt);
let continuation = prompt.get(crate::recovery::RECOVERY_DEPTH).is_some();
let mut naming_request = None;
let auto_name = self.auto_name
&& !continuation
&& prompt["role"] != "custom"
&& self.runtime.mode != "rpc"
&& !self.env.flag_off(AUTO_NAME_ENV);
let named = if auto_name {
names::apply_auto_name(&mut lock_session(&self.session), &text)
} else {
Ok(None)
};
match named {
Ok(Some(_)) => {
self.name_changed();
let naming = naming::naming_settings(&self.runtime.config.settings);
if naming.enabled {
let named = naming
.model
.as_deref()
.and_then(|spec| spec.split_once('/'))
.and_then(|(provider, id)| lane::catalog_model(provider, id, &self.env).ok());
let naming_model = named.unwrap_or_else(|| {
let chosen = naming::naming_model(naming.model.as_deref(), &self.model, &api_supported);
if chosen.provider == self.model.provider && chosen.id == self.model.id {
return self.model.clone();
}
lane::catalog_model(&chosen.provider, &chosen.id, &self.env).unwrap_or(chosen)
});
let key = self.keys.request_key(&naming_model.provider);
naming_request = Some((naming_model, key, text.clone()));
}
}
Ok(None) => {}
Err(error) => return fail(error, waiter),
}
let mut opening: Vec<Value> = self
.loki_notice
.take(crate::loki_notice::NOTICE_WAIT)
.map(|text| crate::loki_notice::notice_message(&text, now_ms() as u64))
.into_iter()
.chain(
self.memory_notice
.take()
.map(|text| crate::auto_memory::paused_message(&text, now_ms() as u64)),
)
.collect();
if prompt["role"] == "user" && !continuation {
opening.extend(self.recalled_memory(&text));
opening.extend(self.routed_playbook(&text));
opening.extend(self.refinements_message());
}
for message in opening {
self.announce_message(&message);
if let Err(error) = self.append(message) {
return fail(error, waiter);
}
}
if let Err(error) = self.store_lane_config() {
return fail(error, waiter);
}
let lane_config = lock_session(&self.session)
.value(LANE_CONFIG, MAIN_LANE)
.cloned()
.unwrap_or(Value::Null);
let started_tip = self.tip().map_or(Value::Null, Value::from);
let settings = self.run_settings();
let captured: Vec<(String, Value)> = select_accepted(&sync::lock(&self.queues), take_queued);
let mut inbox = self.lane_state()["inbox"].clone();
if let Some(items) = inbox.as_array_mut() {
items.retain(|item| !captured.iter().any(|(id, _)| item["entryId"] == id.as_str()));
}
let mut journal = match RunJournal::admit(
Some(&mut lock_session(&self.session)),
lane_config,
prompt.clone(),
(self.model.max_tokens, self.model.context_window),
settings,
&captured,
inbox,
) {
Ok(journal) => journal,
Err(error) => return fail(error, waiter),
};
if !captured.is_empty() {
sync::lock(&self.queues)
.items
.retain(|q| !captured.iter().any(|(id, _)| *id == q.entry_id));
self.queue_update();
}
let captured: Vec<Value> = captured.into_iter().map(|(_, message)| message).collect();
if let Some((naming_model, key, text)) = naming_request {
let (tx, provider) = (self.tx.clone(), self.provider.clone());
std::thread::spawn(move || {
let Ok(runtime) = tokio::runtime::Builder::new_current_thread().enable_all().build() else {
return;
};
let request = naming::request(&text);
let options = naming::options(key);
let mut sink = |_: &ai::AssistantMessageEvent| {};
let call = provider.stream(&naming_model, &request, &options, &mut sink);
if let Ok(title) = runtime.block_on(async { tokio::time::timeout(naming::TIMEOUT, call).await }) {
let _ = tx.send(Input::Title(Box::new(title)));
}
});
}
journal.ledger_counts_turns();
journal.set_retry_policy(self.summary_retry().journal_value());
if let Some(options) = self.provider.stream_options() {
journal.set_stream_options(options);
}
if let Some(run) = journal.run() {
self.lane.stack.agents.begin_root_turn(run.operation_id());
self.durable.children.set_root(
self.lane
.stack
.agents
.usage_root_for_lane(MAIN_LANE, run.operation_id()),
);
}
if self.model_unavailable {
let identity = json!({"provider": self.model.provider, "modelId": self.model.id});
let result = journal.fail_configuration(
&mut lock_session(&self.session),
"model_unavailable",
MODEL_UNAVAILABLE,
identity,
);
self.announce();
return fail(result.err().unwrap_or_else(|| MODEL_UNAVAILABLE.to_string()), waiter);
}
let prompt_entry = self.tip().unwrap_or_default();
if !continuation && prompt["role"] == "user" {
self.checkpoint_turn(&prompt_entry);
}
let submission = match self.start_turn(&prompt, &prompt_entry) {
Ok(submission) => submission,
Err(error) => {
let _ = journal.finish(Some(&mut lock_session(&self.session)), Some(("run_failed", &error)));
return fail(error, waiter);
}
};
let signal = AbortSignal::new();
let id = jsrt::random::uuid_v7(now_ms());
self.branches.run_started();
self.lane.stack.begin_turn();
self.lane.stack.stats.touch();
self.run = Some(Running {
id: id.clone(),
signal,
journal,
prompt,
captured,
submission: Some(submission),
prompt_pending: true,
turns: 0,
started_tip,
error: None,
waiter,
cancelled: false,
compaction_failed: false,
resume_overflow: None,
hiding: false,
ending: false,
});
self.persona_run_started();
self.turn_guard_cancel();
self.emit(WatchEvent::RunStart {
run_id: id,
started_at: now_ms(),
lane: MAIN_LANE.into(),
});
self.spawn_waiter();
Ok(())
}
fn recover(&mut self) -> OpResult {
let Some(recovered) = self.recovered.take() else {
return Ok(Some(json!({"resumed": false, "reason": "nothing to recover"})));
};
let summary = json!({
"operationId": recovered.operation_id, "status": recovered.status, "depth": recovered.depth,
"interruptedCalls": recovered.interrupted_calls, "queued": recovered.queued.len(),
});
let answer = |resumed: bool, run: Value, reason: &str| {
Ok(Some(
json!({"resumed": resumed, "runId": run, "reason": reason, "recovered": summary}),
))
};
if let Some(run) = self.resumed.take() {
return answer(true, json!(run), "durable run resumed");
}
if self.run.is_some() {
return answer(false, Value::Null, "a run is in progress");
}
let resume_off = self.env.flag_off(RECOVERY_RESUME_ENV);
let first = sync::lock(&self.queues)
.items
.iter()
.find(|q| q.kind != QueueKind::NextRun)
.cloned();
let prompt = match first {
_ if recovered.resume && !resume_off => {
let mut prompt = user_message(crate::recovery::CONTINUE_PROMPT.to_string(), Vec::new());
prompt[crate::recovery::RECOVERY_DEPTH] = json!(recovered.depth + 1);
Some((prompt, "interrupted run"))
}
Some(queued) if recovered.status.as_deref() != Some("aborted") => {
self.remove_queued(std::slice::from_ref(&queued.entry_id))?;
let mut prompt = queued.message;
prompt["timestamp"] = json!(now_ms());
Some((prompt, "queued message"))
}
_ => None,
};
let Some((prompt, reason)) = prompt else {
let reason = if recovered.operation_id.is_none() {
"nothing to recover"
} else if recovered.resume {
"resuming is off"
} else {
"the interrupted run is not resumed"
};
return answer(false, Value::Null, reason);
};
match self.prompt_with(prompt, None, false) {
Ok(()) => answer(true, json!(self.run_id()), reason),
Err((error, _)) => Err(error),
}
}
fn enqueue(
&mut self,
kind: QueueKind,
message: String,
images: Vec<Value>,
entry_id: Option<String>,
) -> Result<String, String> {
if message.is_empty() && images.is_empty() {
return Err(EMPTY_QUEUED.into());
}
let message = user_message(message, images);
let entry_id =
entry_id.unwrap_or_else(|| session_journal::lock_clock(&lock_session(&self.session).clock()).next_id());
let mut lane_state = self.lane_state();
if let Some(inbox) = lane_state["inbox"].as_array_mut() {
inbox.push(json!({"entryId": entry_id, "kind": kind.name()}));
}
if let Some(run) = self.run.as_mut() {
run.journal.set_inbox(lane_state["inbox"].clone());
}
lock_session(&self.session).commit(&[
Write::set(PENDING_ENTRY, &entry_id, json!({"type": "message", "payload": message})),
Write::set(LANE_STATE, MAIN_LANE, lane_state),
])?;
sync::lock(&self.queues).items.push(Queued {
kind,
message,
entry_id: entry_id.clone(),
turn: 0,
submission: None,
});
if self.run.is_some() {
self.submit_queued()?;
}
self.queue_update();
Ok(entry_id)
}
fn remove_queued(&mut self, ids: &[String]) -> Result<(), String> {
let mut lane_state = self.lane_state();
if let Some(inbox) = lane_state["inbox"].as_array_mut() {
inbox.retain(|item| !ids.iter().any(|id| item["entryId"] == id.as_str()));
}
if let Some(run) = self.run.as_mut() {
run.journal.set_inbox(lane_state["inbox"].clone());
}
let mut writes: Vec<Write> = ids.iter().map(|id| Write::delete(PENDING_ENTRY, id)).collect();
writes.push(Write::set(LANE_STATE, MAIN_LANE, lane_state));
lock_session(&self.session).commit(&writes)?;
if !ids.is_empty() {
self.withdraw_queued(ids);
}
for id in ids {
let mut queues = sync::lock(&self.queues);
if let Some(index) = queues.items.iter().position(|q| q.entry_id == *id) {
queues.items.remove(index);
}
drop(queues);
self.queue_update();
}
Ok(())
}
fn clear_queue(&mut self) -> Value {
let (steering, follow_up, cleared) = {
let queues = sync::lock(&self.queues);
let visible = queues.visible();
let pick = |kind: QueueKind| -> Vec<String> {
visible
.iter()
.filter(|q| q.kind == kind)
.map(|q| message_text(&q.message))
.collect()
};
let cleared: Vec<String> = queues.items.iter().map(|q| q.entry_id.clone()).collect();
let mut follow_up = pick(QueueKind::FollowUp);
follow_up.extend(pick(QueueKind::NextRun));
(pick(QueueKind::Steer), follow_up, cleared)
};
if !cleared.is_empty() {
let _ = self.remove_queued(&cleared);
}
json!({"steering": steering, "followUp": follow_up})
}
fn bash(&mut self, op: Op, reply: Reply) {
let Op::Bash { command, exclude, id } = op else { return };
let signal = kernel::Signal::new();
self.bash = Some(signal.clone());
let host = self.lane.host.clone();
let tx = self.tx.clone();
let prefix = self
.runtime
.config
.settings
.as_object()
.and_then(config::keys::shell_command_prefix);
std::thread::spawn(move || {
let result = user_bash::run(&host, &command, prefix.as_deref(), &signal, &mut |delta| {
let _ = tx.send(Input::BashOutput {
id: id.clone(),
delta: delta.to_string(),
});
});
let _ = tx.send(Input::BashDone {
command,
exclude,
result,
reply,
});
});
}
}
pub fn spawn(options: OpenOptions, sink: EventSink) -> Result<(Sender<Input>, JoinHandle<()>, Value), String> {
let (tx, rx) = std::sync::mpsc::channel();
let (ready_tx, ready_rx) = std::sync::mpsc::channel();
let input = tx.clone();
let trace_path = (options.env.var)(crate::startup_trace::TRACE_ENV);
let handle = std::thread::spawn(move || match Core::open(options, input, sink) {
Ok(core) => {
crate::startup_trace::trace_startup(trace_path.as_deref(), "worker.ready");
let _ = ready_tx.send(Ok((
core.snapshot(),
core.model().clone(),
core.thinking_level().to_string(),
)));
core.run_loop(rx);
}
Err(error) => {
let _ = ready_tx.send(Err(error));
}
});
let ready = ready_rx.recv().map_err(|e| e.to_string())??;
let (snapshot, model, thinking) = ready;
let mut summary = json!({"snapshot": snapshot, "model": serde_json::to_value(&model).unwrap_or(Value::Null)});
summary["thinkingLevel"] = json!(thinking);
Ok((tx, handle, summary))
}
pub fn call(tx: &Sender<Input>, op: Op) -> OpResult {
let (reply_tx, reply_rx) = std::sync::mpsc::channel();
tx.send(Input::Op(
op,
Box::new(move |result| {
let _ = reply_tx.send(result);
}),
))
.map_err(|_| SESSION_CLOSED.to_string())?;
reply_rx.recv().map_err(|_| SESSION_CLOSED.to_string())?
}