use crate::RunEnv as Env;
use crate::async_events::RuntimeEvent;
use crate::lane::{Provider, Rlm, rlm_over};
use crate::session_stats::{GuardOutcome, SessionStats};
use agent::{AgentOptions, AgentTool, StreamFn};
use ai::{Message, Model, UserMessage, UserMessageContent};
use delegation::agents::{Agents, AgentsOptions, Completion, PredictCall, predict_adapter};
use delegation::child::agent_runner;
use delegation::host::{ChildRun, ChildRunner, Delegation, DelegationOptions, DetachedEnd};
use delegation::usage::UsageLedger;
use host::Host;
use host::file_hooks::{FileHooks, GuardRecord, OnRecord};
use host::loki_guard::{LokiGuard, LokiMode, git_root, loki_mode};
use inference::Inference;
use jsrt::sync;
use kernel::store::{FileDocumentStore, MemoryDocumentStore};
use kernel::{ContinuityPolicy, HostHandler, Kernel, KernelOptions, Signal};
use kernel_apis::{
CodeSkills, CodeSkillsOptions, DurableWork, DurableWorkOptions, GoalDriver, HintsModule, KernelApis, MemoryApi,
MemoryBackend, MemoryService, SchedulesModule, SkillSource, SkillsModule, TaskGoalJobs,
};
use lanes::Park;
use lanes::{CellEnd, Lanes, LanesOptions};
use serde_json::{Map, Value, json};
use std::collections::HashMap;
use std::path::{Path, PathBuf};
use std::sync::mpsc::Receiver;
use std::sync::{Arc, Condvar, Mutex, Weak};
use std::time::Duration;
pub const CONTEXT_REMINDER_ENV: &str = "ULTRON_CONTEXT_REMINDER";
pub const CONTEXT_REMINDER_TOKENS_ENV: &str = "ULTRON_CONTEXT_REMINDER_TOKENS";
pub const GUIDE_ENV: &str = "ULTRON_GUIDE";
pub const LOKI_ENV: &str = "ULTRON_LOKI";
pub const LOKI_TIMEOUT_MS_ENV: &str = "ULTRON_LOKI_TIMEOUT_MS";
pub const MASK_SECRETS_ENV: &str = "ULTRON_MASK_SECRETS";
pub const READ_HANDLE_BYTES_ENV: &str = "ULTRON_READ_HANDLE_BYTES";
pub const EXTENSIONS_UNSUPPORTED: &str = "Pi extensions are not supported by ultron-rs";
pub type McpListener = Arc<dyn Fn(&Arc<mcp::gateway::Gateway>) + Send + Sync>;
#[derive(Clone, Default)]
pub struct Services {
pub memory: Option<Arc<dyn MemoryBackend>>,
pub on_mcp: Option<McpListener>,
pub mcp_notices: Option<mcp::gateway::NoticeSink>,
pub session: crate::session_flags::SessionFlags,
pub resources: Arc<crate::session_resources::SessionResources>,
pub values: Option<services::SessionValues>,
pub on_schedules: Option<kernel_apis::prompt_schedule::Listener>,
pub agent_lanes: Option<AgentLanes>,
}
pub type AgentLanes = Arc<dyn Fn(Weak<Stack>) -> delegation::agents::LaneRunner + Send + Sync>;
pub struct Config {
pub cwd: PathBuf,
pub home: PathBuf,
pub agent_dir: PathBuf,
pub settings: Value,
pub loki: LokiMode,
pub loki_hygiene: loki::hygiene::Level,
pub loki_root: Option<PathBuf>,
pub runtime_path: PathBuf,
pub skills_dir: PathBuf,
pub mask_secrets: Option<String>,
pub output_bytes: Option<String>,
pub cell_yield_after: Option<String>,
pub snapshot_key: Option<Vec<u8>>,
pub spawn_depth: u32,
pub async_events: bool,
pub ts_guide: bool,
pub hints: bool,
pub turn_guards: bool,
pub result_footer: bool,
pub tool_rounds_nudge: u64,
pub skill_nudge: u64,
pub context_images: usize,
pub frame_env: HashMap<String, String>,
pub var: crate::VarLookup,
pub masker: Arc<host::secrets::OutputMasker>,
pub project_trusted: bool,
pub provider_token: mcp::connection::ProviderToken,
pub outside_changes: host::file_hooks::OutsideChanges,
pub lsp: Option<lsp::LspGuard>,
pub terminal_theme: Arc<std::sync::Mutex<Option<String>>>,
}
pub fn workspace_snapshotter() -> host::file_hooks::Snapshotter {
std::sync::Arc::new(|dir: &Path| {
let picture = delegation::workspace::snapshot_workspace(dir);
Ok(host::file_hooks::Snapshot {
root: picture.root,
entries: picture.entries,
complete: picture.complete,
})
})
}
const SESSION_ENV_NAMES: &[&str] = &[
"PATH",
"HOME",
"USER",
"LOGNAME",
"SHELL",
"TERM",
"LANG",
"LANGUAGE",
"LC_ALL",
"LC_CTYPE",
"TZ",
"TMPDIR",
"XDG_CONFIG_HOME",
"XDG_DATA_HOME",
"XDG_CACHE_HOME",
"XDG_STATE_HOME",
"XDG_RUNTIME_DIR",
"PYTHONPATH",
"PYTHONHOME",
"VIRTUAL_ENV",
config::env::OFFLINE_ENV,
config::env::SKIP_VERSION_CHECK_ENV,
kernel::env::PYTHON_ENV,
kernel::env::RLM_ENV_ALLOW_ENV,
kernel::env::BASH_YIELD_AFTER_ENV,
kernel::env::RLM_MAX_MEMORY_MB_ENV,
kernel::env::RLM_MAX_CPU_SECONDS_ENV,
kernel::env::RLM_OUTPUT_BYTES_ENV,
kernel::env::RLM_MAX_TREE_MEMORY_MB_ENV,
kernel::env::RLM_TREE_MEMORY_BACKEND_ENV,
];
pub fn session_environment(var: &dyn Fn(&str) -> Option<String>) -> Vec<(String, String)> {
let mut names: Vec<String> = std::env::vars_os()
.filter_map(|(name, _)| name.into_string().ok())
.collect();
for name in SESSION_ENV_NAMES {
if !names.iter().any(|known| known == name) {
names.push((*name).to_string());
}
}
names
.into_iter()
.filter_map(|name| var(&name).map(|value| (name, value)))
.collect()
}
pub fn ts_guide(var: &dyn Fn(&str) -> Option<String>) -> bool {
var(GUIDE_ENV).as_deref() == Some("ts")
}
pub fn hints(var: &dyn Fn(&str) -> Option<String>) -> bool {
kernel_apis::cell_hints::hints_enabled(var(kernel_apis::cell_hints::HINTS_ENV).as_deref())
}
pub const TURN_GUARDS_ENV: &str = "ULTRON_TURN_GUARDS";
pub fn turn_guards(var: &dyn Fn(&str) -> Option<String>) -> bool {
!ts_guide(var) && !crate::flag_off(var(TURN_GUARDS_ENV).as_deref())
}
impl Config {
pub fn child_env(&self) -> Vec<(String, String)> {
session_environment(&*self.var)
}
pub fn from_env(env: &Env) -> Config {
let agent_dir = env.agent_dir();
let manager = config::settings::SettingsManager::for_worker(&env.cwd, &agent_dir, &env.home);
let settings = Value::Object(manager.settings().clone());
let loki_settings = loki::settings::saved(manager.global_settings());
let loki = loki_mode((env.var)(LOKI_ENV).as_deref(), &loki_settings);
let loki_hygiene = loki::hygiene::level((env.var)(loki::hygiene::HYGIENE_ENV).as_deref(), &loki_settings);
let loki_root = (loki != LokiMode::Off).then(|| git_root(&env.cwd).unwrap_or_else(|| env.cwd.clone()));
let skills_dir = (env.var)(kernel::env::CODE_SKILLS_DIR_ENV)
.map(|dir| dir.trim().to_string())
.filter(|dir| !dir.is_empty())
.map_or_else(|| agent_dir.join("skills"), PathBuf::from);
let lsp = lsp::enabled((env.var)(lsp::LSP_ENV).as_deref(), &settings)
.then(|| lsp::LspGuard::new(session_environment(&*env.var)));
Config {
cwd: env.cwd.clone(),
home: env.home.clone(),
snapshot_key: kernel::snapshot_store::session_snapshot_key(&agent_dir, &*env.var),
agent_dir,
settings,
loki,
loki_hygiene,
loki_root,
runtime_path: env.runtime(),
skills_dir,
mask_secrets: (env.var)(MASK_SECRETS_ENV),
output_bytes: (env.var)(kernel::env::RLM_OUTPUT_BYTES_ENV),
cell_yield_after: (env.var)(kernel::env::CELL_YIELD_AFTER_ENV),
spawn_depth: delegation::host::spawn_depth_limit((env.var)(delegation::host::SPAWN_DEPTH_ENV).as_deref()),
async_events: crate::async_events::async_events_enabled(
(env.var)(crate::async_events::ASYNC_EVENTS_ENV).as_deref(),
),
ts_guide: ts_guide(&*env.var),
hints: hints(&*env.var),
turn_guards: turn_guards(&*env.var),
result_footer: !ts_guide(&*env.var) && config::keys::result_footer(manager.global_settings()),
tool_rounds_nudge: crate::nudge::tool_rounds_nudge_from_env(
(env.var)(crate::nudge::TOOL_ROUNDS_NUDGE_ENV).as_deref(),
),
skill_nudge: crate::nudge::skill_nudge_from_env((env.var)(crate::nudge::SKILL_NUDGE_ENV).as_deref()),
context_images: crate::view_images::context_image_budget(
(env.var)(crate::view_images::CONTEXT_IMAGES_ENV).as_deref(),
),
frame_env: inference::frame_env(&*env.var),
var: env.var.clone(),
masker: Arc::default(),
project_trusted: manager.is_project_trusted(),
outside_changes: host::file_hooks::OutsideChanges::default(),
lsp,
terminal_theme: Arc::default(),
provider_token: {
let env = env.clone();
Arc::new(move |provider: &str| crate::lane::api_key(&crate::ModelFlags::default(), &env, provider))
},
}
}
pub fn settings_reader(&self) -> Arc<dyn Fn() -> config::settings::SettingsManager + Send + Sync> {
let (cwd, agent_dir, trusted) = (self.cwd.clone(), self.agent_dir.clone(), self.project_trusted);
Arc::new(move || config::settings::SettingsManager::create(&cwd, &agent_dir, trusted))
}
pub fn bundled_skills(&self) -> Option<String> {
let root = self.runtime_path.ancestors().nth(4)?;
crate::session_resources::bundled_skills(&root.join("skills"), &*self.var)
}
pub fn mcp_gateway(&self) -> Arc<mcp::gateway::Gateway> {
let masker = self.masker.clone();
mcp::gateway::Gateway::new(mcp::gateway::GatewayOptions {
agent_dir: self.agent_dir.clone(),
project_trusted: self.project_trusted,
servers: None,
env: mcp::connection::ConnectionEnv {
cwd: self.cwd.clone(),
home: self.home.clone(),
env_overlay: HashMap::new(),
client_version: config::version().to_string(),
log: Some(Arc::new(mcp::log::ServerLog::new(self.agent_dir.join("mcp.log")))),
secrets: Some(Arc::new(move |values: &[String]| {
let values: Vec<Value> = values.iter().map(|v| Value::String(v.clone())).collect();
masker.register_secret_values(&values);
})),
provider_token: Some(self.provider_token.clone()),
proxy: Some(ai::net::ProxyEnv::from_lookup(&*self.var)),
var: Some(self.var.clone()),
..mcp::connection::ConnectionEnv::default()
},
open_url: Some(config::browser::browser_opener(
(self.var)("PATH"),
(self.var)("HOME"),
config::browser::opener_vars(&*self.var),
)),
})
}
pub fn model(&self, provider: &str, id: &str) -> Option<Model> {
let env = Env {
cwd: self.cwd.clone(),
home: self.home.clone(),
var: self.var.clone(),
package: PathBuf::new(),
};
crate::lane::catalog_model(provider, id, &env).ok()
}
pub fn find_models(&self) -> Value {
let env = Env {
cwd: self.cwd.clone(),
home: self.home.clone(),
var: self.var.clone(),
package: PathBuf::new(),
};
Value::Array(
crate::lane::available_models(&env)
.iter()
.map(|m| json!({"provider": m.provider, "id": m.id, "name": m.name}))
.collect(),
)
}
pub fn race_models(&self) -> Value {
let picked = config::keys::rlm_model_settings((self.settings_reader())().global_settings()).race_models;
picked
.into_iter()
.filter(|spec| spec.split_once('/').is_some_and(|(p, id)| self.model(p, id).is_some()))
.map(Value::String)
.collect()
}
fn model_check(self: &Arc<Self>) -> delegation::host::ModelCheck {
let config = self.clone();
Arc::new(move |spec: &str| {
match spec
.split_once('/')
.and_then(|(provider, id)| config.model(provider, id))
{
Some(_) => Ok(()),
None => Err(format!("model must be provider/model naming a known model, not {spec}")),
}
})
}
fn file_hooks_in(&self, cwd: &Path, record: Option<OnRecord>) -> FileHooks {
let mut hooks = FileHooks::with_snapshots(cwd, workspace_snapshotter());
hooks.ignore_outside(self.outside_changes.clone());
hooks.protect(config::paths::AgentPaths::new(&self.agent_dir).protected(), &self.home);
match (
crate::guard_log::loki_log((self.var)(crate::guard_log::LOKI_LOG_ENV).as_deref()),
record,
) {
(Some(log), Some(record)) => hooks.on_record(Arc::new(move |outcome: &GuardRecord| {
log(outcome);
record(outcome);
})),
(Some(only), None) | (None, Some(only)) => hooks.on_record(only),
(None, None) => {}
}
if let Some(root) = &self.loki_root {
let root = if cwd == self.cwd {
root.clone()
} else {
git_root(cwd).unwrap_or_else(|| cwd.to_path_buf())
};
let post_write = git_root(cwd).is_some() && root.join(".loki").is_dir();
hooks.add(Box::new(
LokiGuard::new(&root, self.loki)
.with_post_write(post_write)
.with_hygiene(self.loki_hygiene)
.with_project_python(crate::guard_log::project_python(&*self.var, &self.cwd))
.with_timeout(host::loki_guard::loki_timeout(
(self.var)(LOKI_TIMEOUT_MS_ENV).as_deref(),
)),
));
}
if let Some(lsp) = &self.lsp {
hooks.add(Box::new(lsp.clone()));
}
hooks
}
fn session_dir(&self, kind: &str, session_id: &str) -> PathBuf {
self.agent_dir.join(kind).join(session_id)
}
}
fn lane_dir(lane: &str) -> String {
lane.chars()
.map(|c| {
if c.is_ascii_alphanumeric() || "._-".contains(c) {
c
} else {
'_'
}
})
.collect()
}
fn max_live_kernels(settings: &Value) -> usize {
settings["rlm"]["maxLiveKernels"]
.as_u64()
.filter(|n| *n >= 1)
.map_or(16, |n| n.min(1024) as usize)
}
fn lane_snapshot_path(config: &Arc<Config>, session_id: &str) -> lanes::SnapshotPathFn {
let snapshots = config.session_dir("rlm-snapshots", session_id);
Arc::new(move |lane: &str| {
Some(
snapshots
.join(format!("{}.snapshot", lane_dir(lane)))
.display()
.to_string(),
)
})
}
pub fn mcp_runtime_guide(config: &Config) -> resources::runtime_guide::RuntimeGuideOptions {
let tool = config.mcp_gateway().tool();
resources::runtime_guide::RuntimeGuideOptions {
mcp_servers: tool
.as_ref()
.map(|t| mcp::gateway::server_names_of(&t.description))
.unwrap_or_default(),
extension_tools: tool
.into_iter()
.map(|t| resources::runtime_guide::ExtensionToolSummary {
name: t.name,
description: t.description,
})
.collect(),
durable_apis: !config.ts_guide,
delivery: if config.async_events {
resources::runtime_guide::EventDelivery::Wake
} else {
resources::runtime_guide::EventDelivery::Off
},
host_waits: !config.ts_guide,
hints: config.hints,
result_footer: config.result_footer,
..Default::default()
}
}
#[derive(Clone)]
pub struct SystemPrompt(Arc<PromptState>);
type RenderPrompt = dyn Fn(&crate::lane::PromptMode) -> Result<(String, Vec<String>), String> + Send + Sync;
type RenderChildPrompt = dyn Fn(&crate::lane::PromptMode, ChildReader) -> Result<String, String> + Send + Sync;
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct ChildReader {
pub in_memory: bool,
pub memory: crate::memory_guidance::MemoryGuidance,
}
struct PromptState {
render: Option<Box<RenderPrompt>>,
render_child: Option<Box<RenderChildPrompt>>,
child: Mutex<Option<(crate::lane::PromptMode, ChildReader, String)>>,
mode: Box<dyn Fn() -> crate::lane::PromptMode + Send + Sync>,
current: Mutex<(crate::lane::PromptMode, String, Vec<String>)>,
persona: Mutex<Option<bool>>,
model: Mutex<String>,
}
impl SystemPrompt {
pub fn fixed(text: impl Into<String>) -> SystemPrompt {
SystemPrompt(Arc::new(PromptState {
render: None,
render_child: None,
child: Mutex::new(None),
mode: Box::new(crate::lane::PromptMode::default),
current: Mutex::new((Default::default(), text.into(), Vec::new())),
persona: Mutex::new(None),
model: Mutex::new(String::new()),
}))
}
fn rendered(
env: &Env,
config: &Config,
trusted: bool,
guide: resources::runtime_guide::RuntimeGuideOptions,
flags: &crate::session_flags::SessionFlags,
extra: Arc<crate::session_resources::SessionResources>,
) -> Result<SystemPrompt, String> {
let (cwd, agent_dir) = (env.cwd.clone(), config.agent_dir.clone());
let (no_skills, no_context_files) = (flags.no_skills, flags.no_context_files);
let mode = move || {
let settings = config::settings::SettingsManager::create(&cwd, &agent_dir, trusted);
crate::lane::PromptMode {
no_skills,
no_context_files,
..crate::lane::PromptMode::from_settings(&settings)
}
};
let (env, loki_root) = (env.clone(), config.loki_root.clone());
let (child_env, child_loki, child_extra) = (env.clone(), loki_root.clone(), extra.clone());
let child_guide = guide.clone();
let render = move |mode: &crate::lane::PromptMode| {
crate::lane::system_prompt_with_resources(
&env,
&env.cwd.display().to_string(),
loki_root.as_deref(),
&guide,
mode,
&extra,
)
};
let render_child = move |mode: &crate::lane::PromptMode, reader: ChildReader| {
let guide = resources::runtime_guide::RuntimeGuideOptions {
reader: resources::runtime_guide::GuideReader::Subagent {
swarm: !reader.in_memory,
},
memory: reader.memory,
..child_guide.clone()
};
crate::lane::system_prompt_with_resources(
&child_env,
&child_env.cwd.display().to_string(),
child_loki.as_deref(),
&guide,
mode,
&child_extra,
)
.map(|(text, _)| text)
};
let initial = mode();
let (text, warnings) = render(&initial)?;
Ok(SystemPrompt(Arc::new(PromptState {
render: Some(Box::new(render)),
render_child: Some(Box::new(render_child)),
child: Mutex::new(None),
mode: Box::new(mode),
current: Mutex::new((initial, text, warnings)),
persona: Mutex::new(None),
model: Mutex::new(String::new()),
})))
}
pub fn current(&self) -> String {
let state = &self.0;
let Some(render) = &state.render else {
return sync::lock(&state.current).1.clone();
};
let mut mode = (state.mode)();
if let Some(persona) = *sync::lock(&state.persona) {
mode.persona = persona;
}
mode.model = sync::lock(&state.model).clone();
let mut current = sync::lock(&state.current);
if current.0 != mode
&& let Ok((text, warnings)) = render(&mode)
{
*current = (mode, text, warnings);
}
current.1.clone()
}
pub fn child_current(&self, reader: ChildReader, model: &str) -> String {
let state = &self.0;
let Some(render) = &state.render_child else {
return self.current();
};
let mut mode = (state.mode)();
if let Some(persona) = *sync::lock(&state.persona) {
mode.persona = persona;
}
mode.model = model.to_string();
let mut child = sync::lock(&state.child);
if let Some((cached, cached_reader, text)) = &*child
&& *cached == mode
&& *cached_reader == reader
{
return text.clone();
}
match render(&mode, reader) {
Ok(text) => {
*child = Some((mode, reader, text.clone()));
text
}
Err(_) => {
drop(child);
self.current()
}
}
}
pub fn set_persona(&self, persona: Option<bool>) {
*sync::lock(&self.0.persona) = persona;
}
pub fn set_model(&self, id: &str) {
*sync::lock(&self.0.model) = id.to_string();
}
pub fn warnings(&self) -> Vec<String> {
sync::lock(&self.0.current).2.clone()
}
}
pub struct Runtime {
pub config: Arc<Config>,
pub services: Services,
pub diagnostics: Vec<String>,
pub system: SystemPrompt,
pub sessions_dir: PathBuf,
pub mode: String,
pub hindsight: Option<hindsight::Endpoint>,
pub memorantado: Option<memorantado::Endpoint>,
pub memory_notice: Option<String>,
pub memory_explicit: bool,
}
pub struct MemoryChoice {
pub backend: memorantado::Backend,
pub hindsight: Option<hindsight::Endpoint>,
pub explicit: bool,
}
pub fn memory_backend(
var: &dyn Fn(&str) -> Option<String>,
manager: &config::settings::SettingsManager,
agent_dir: &Path,
) -> MemoryChoice {
let (url, source) = hindsight::resolve::resolve_in(var, manager);
let hindsight_set = source != hindsight::resolve::Source::Default;
let hindsight = hindsight::Endpoint::at(url, var);
let resolved = match (&hindsight, hindsight_set) {
(None, _) => memorantado::Hindsight::Off,
(Some(_), false) => memorantado::Hindsight::Default,
(Some(_), true) => memorantado::Hindsight::Set,
};
let backend = memorantado::Endpoint::choose(var, manager, agent_dir, resolved, &memorantado::resolve::probe);
let explicit = hindsight_set
|| (backend.memorantado().is_some()
&& (memorantado::resolve::choice(manager) == Some(memorantado::Choice::Memorantado)
|| var(memorantado::resolve::MEMORANTADO_URL_ENV).is_some()
|| memorantado::resolve::setting_url(manager).is_some()));
MemoryChoice {
backend,
hindsight,
explicit,
}
}
impl Runtime {
pub fn new(env: &Env, mode: &str, sessions_dir: PathBuf, services: Services) -> Result<Runtime, String> {
let mut services = services;
let config = Config::from_env(env);
let trusted = config.project_trusted;
let manager = config::settings::SettingsManager::create(&env.cwd, &config.agent_dir, trusted);
let mut resolved = crate::session_resources::resolve(
env,
config::settings::SettingsManager::create(&env.cwd, &config.agent_dir, trusted),
services.session.append_system_prompt.as_deref(),
);
resolved
.skill_paths
.extend(services.session.skill_paths.iter().cloned());
services.resources = Arc::new(resolved);
let mut diagnostics: Vec<String> = Vec::new();
let MemoryChoice {
backend,
hindsight,
explicit: memory_explicit,
} = memory_backend(&*env.var, &manager, &config.agent_dir);
let memory_notice = match &backend {
memorantado::Backend::Memorantado { endpoint, up: false } => Some(endpoint.paused_notice()),
_ => None,
};
diagnostics.extend(memory_notice.clone());
let hindsight = hindsight.filter(|_| backend == memorantado::Backend::Hindsight);
let memorantado = backend.memorantado().cloned();
let runtime_guide = resources::runtime_guide::RuntimeGuideOptions {
memory_topics: memorantado.is_some() && services.memory.is_none(),
..mcp_runtime_guide(&config)
};
let system = match &services.session.system_prompt {
Some(text) => SystemPrompt::fixed(text.clone()),
None => SystemPrompt::rendered(
env,
&config,
trusted,
runtime_guide,
&services.session,
services.resources.clone(),
)?,
};
diagnostics.extend(system.warnings());
if let Err(error) =
crate::core::turn_guard::parse_checks(config.settings.as_object().unwrap_or(&Default::default()))
{
diagnostics.push(format!("{error}; no turn-end check runs"));
}
Ok(Runtime {
config: Arc::new(config),
services,
diagnostics,
system,
sessions_dir,
mode: mode.to_string(),
hindsight,
memorantado,
memory_notice,
memory_explicit,
})
}
pub fn stack(&self, model: &Model, api_key: Option<String>, session_id: &str) -> Result<Arc<Stack>, String> {
self.stack_with(model, api_key, session_id, None)
}
pub fn stack_with(
&self,
model: &Model,
api_key: Option<String>,
session_id: &str,
subagents: Option<SubagentHost>,
) -> Result<Arc<Stack>, String> {
let mut subagents = subagents;
let memory_children = subagents
.is_none()
.then(|| Arc::new(crate::memory_children::MemoryChildren::default()));
let config = self.config.clone();
let values = self.services.values.clone();
let jobs: Arc<dyn kernel::store::DocumentStore> = match &values {
Some(values) => Arc::new(crate::session_modules::ModuleJobJournal(
crate::session_modules::ModuleDocument(values.document(session_journal::ns::MODULE, "jobs")),
)),
None => Arc::new(kernel::store::FileDocumentStore::new(
config.session_dir("rlm-modules", session_id).join("jobs.json"),
)),
};
let stats = Arc::new(SessionStats::system("lane"));
let memory_records = Arc::new(kernel_apis::memory_records::RecordIndex::for_agent_dir(
&config.agent_dir,
));
let skill_runs = Arc::new(delegation::skill_runs::RunBook::default());
let observers = self
.memory_pointers(session_id, &memory_records)
.into_iter()
.chain(self.situational_skills())
.chain(Some(skill_runs.clone() as Arc<dyn host::file_hooks::CellObserver>))
.collect();
let host = Arc::new(
self.host_in(&config.cwd, session_id, "bash", Some(&stats), observers)?
.with_journal(jobs)?,
);
crate::guard_log::loki_setup(&config);
let modules = |name: &str| -> Arc<dyn kernel::store::DocumentStore> {
match &values {
Some(values) => Arc::new(crate::session_modules::ModuleDocument(
values.document(session_journal::ns::MODULE, name),
)),
None => Arc::new(FileDocumentStore::new(
config
.session_dir("rlm-modules", session_id)
.join(format!("{name}.json")),
)),
}
};
let (cwd, home) = (config.cwd.display().to_string(), config.home.display().to_string());
let backend = match (&self.services.memory, &self.memorantado, &self.hindsight) {
(Some(backend), _, _) => Some(backend.clone()),
(None, Some(endpoint), _) => Some(Arc::new(
endpoint
.session_backend(session_id, &cwd, &home)
.map_err(|e| e.to_string())?,
) as Arc<dyn MemoryBackend>),
(None, None, Some(endpoint)) => Some(Arc::new(
endpoint
.session_backend(session_id, &cwd, &home)
.map_err(|e| e.to_string())?,
) as Arc<dyn MemoryBackend>),
(None, None, None) => None,
};
let memory = match &backend {
Some(backend) => Some(
MemoryService::new(
match &values {
Some(values) => Arc::new(crate::session_modules::ModuleDocument(values.document(
session_journal::ns::MEMORY_ROOT.namespace,
session_journal::ns::MEMORY_ROOT.key,
))),
None => modules("memory"),
},
backend.clone(),
kernel_apis::worker_gate(),
)
.map_err(|e| format!("memory: {e:?}"))?
.with_records(memory_records.clone())
.with_root(config.cwd.clone()),
),
None => None,
};
let skills_config = config.clone();
let no_skills = self.services.session.no_skills;
let extra = self.services.resources.clone();
let loader: kernel_apis::SkillLoader = Arc::new(move || Ok(skill_sources(&skills_config, &extra, no_skills)));
let code = CodeSkills::new(CodeSkillsOptions::for_session(
&config.skills_dir,
&config.runtime_path,
config.child_env(),
));
let clock = kernel_apis::util::system_clock();
let local = Arc::new(services::LocalServices::worker(match &values {
Some(values) => Box::new(values.keyed(session_journal::ns::LOCAL)),
None => Box::new(kernel_apis::artifacts::FileKeyedDocuments::new(
config.session_dir("rlm-modules", session_id).join("local.json"),
)),
}));
let branch = values.as_ref().map(crate::session_modules::main_branch);
let refinements = services::instruction_hook(local.clone(), branch.clone());
let ledger = crate::auto_refine::Ledger {
services: local.clone(),
branch: branch.clone(),
};
let gateway = config.mcp_gateway();
let notices = gateway.start(self.services.mcp_notices.clone());
if let Some(notify) = &self.services.mcp_notices {
for (message, level) in notices {
notify(&message, &level);
}
}
if let Some(on_mcp) = &self.services.on_mcp {
on_mcp(&gateway);
}
let images = Arc::new(crate::view_images::ViewImages::new(
model.clone(),
config.cwd.clone(),
config.agent_dir.clone(),
config.project_trusted,
));
let keys = crate::request_keys::Keys::new(
api_key.map(|key| (model.provider.clone(), key)),
config.provider_token.clone(),
);
let root_model = Arc::new(Mutex::new(model.clone()));
self.system.set_model(&model.id);
let judge_ledger: Arc<std::sync::OnceLock<UsageLedger>> = Arc::default();
let judge_rows: Arc<std::sync::OnceLock<services::SessionValues>> = Arc::default();
if let Some(values) = &values {
let _ = judge_rows.set(values.clone());
}
let judge = Arc::new(crate::session_judge::module(
&config,
root_model.clone(),
keys.clone(),
judge_rows.clone(),
judge_ledger.clone(),
));
let skills = Arc::new(SkillsModule::new(modules("skills"), loader, clock.clone(), Some(code)));
let skill_checks: Arc<std::sync::OnceLock<delegation::spawn_contract::CheckRunner>> = Arc::default();
let procedures = Arc::new(delegation::skill_runs::SkillRuns {
book: skill_runs,
skills: skills.clone(),
judge: judge.clone(),
cwd: config.cwd.clone(),
env: config.child_env(),
runner: skill_checks.clone(),
proposals: config::paths::AgentPaths::new(&config.agent_dir).skill_proposals(),
session_id: Some(session_id.to_string()),
now: clock.clone(),
});
let _ = procedures.interrupt_orphans();
let apis = ApiModules {
local: Arc::new(services::LocalServicesModule {
services: local,
branch,
}),
gates: Arc::new(services::ReleaseGateModule::new(modules("release-gates"), None)),
procedures,
skills,
memory: Arc::new(MemoryApi {
service: memory.map(|memory| memory.with_judge(crate::session_judge::decider(judge.clone()))),
}),
hints: Arc::new(HintsModule::new(modules("hints"))),
images: Arc::new(crate::session_images::module(&config, session_id)),
diagram: Arc::new(crate::session_diagrams::module(&config, session_id, images.clone())),
knowledge: Arc::new(crate::session_knowledge::module(
&config,
self.memorantado.clone(),
judge.clone(),
)),
judge,
schedule: Arc::new(
kernel_apis::prompt_schedule::ScheduleModule::new(
match &values {
Some(values) => Box::new(values.keyed(kernel_apis::prompt_schedule::NAMESPACE)),
None => Box::new(kernel_apis::artifacts::MemoryKeyedDocuments::default()),
},
session_id,
kernel_apis::prompt_schedule::clock_for(&*config.var),
self.services.on_schedules.clone(),
)
.with_github(kernel_apis::prompt_schedule::GitHub::for_env(&*config.var)),
),
tools: Arc::new(kernel_apis::ToolCalls::new(
gateway.tool().is_some().then(|| {
Arc::new(crate::session_tools::SessionTools { mcp: gateway.clone() })
as Arc<dyn kernel_apis::ToolRunner>
}),
modules("tool-calls"),
)),
instances: Arc::new(kernel_apis::InstancesModule::new(modules("instances"), None)),
progress: Arc::new(kernel_apis::ProgressModule::new(modules("progress"))),
family: Arc::new(kernel_apis::FamilyModule::new(
modules("family"),
kernel_apis::FamilyOptions::default(),
)),
sessions: Arc::new(session_search(&config, &self.sessions_dir, session_id)),
};
let var = |key: &str| (config.var)(key);
let context_reminders = Arc::new(crate::context_reminder::ContextReminders::new(
crate::context_reminder::ReminderSettings::from_vars(
var(CONTEXT_REMINDER_ENV).as_deref(),
var(CONTEXT_REMINDER_TOKENS_ENV).as_deref(),
),
));
let cell_hints = Arc::new(kernel_apis::cell_hints::CellHints::new(
apis.hints.clone(),
kernel_apis::cell_hints::CellHintsOptions {
enabled: config.hints,
guards: config.turn_guards,
max_per_tag: kernel_apis::cell_hints::hint_max_per_tag(
var(kernel_apis::cell_hints::HINTS_MAX_ENV).as_deref(),
),
async_events: config.async_events,
read_handle_bytes: kernel_apis::cell_hints::read_handle_bytes(var(READ_HANDLE_BYTES_ENV).as_deref()),
..Default::default()
},
));
let session_id = session_id.to_string();
let system = self.system.clone();
let sessions_dir = self.sessions_dir.clone();
let services = self.services.clone();
let model = model.clone();
let frame_stream = crate::request_keys::lane_stream(config.settings_reader(), keys.clone());
let child = ChildDefaults {
model: model.clone(),
keys: keys.clone(),
};
let mut built: Result<(), String> = Ok(());
let (schedules_store, goal_store) = (modules("schedules"), modules("goal"));
let wake = crate::wake::RootWake::default();
let hints_wake = wake.clone();
cell_hints.set_lane_woken(Arc::new(move |lane: &str| hints_wake.woken(lane)));
let memory_children_on = memory_children.is_some();
let agent_lanes = self.services.agent_lanes.clone();
let stack = Arc::new_cyclic(|me: &Weak<Stack>| {
let runner_stack = me.clone();
let (store, inner, agent_stores) = match subagents.take() {
Some(host) => (Some(host.store), (host.runner)(me.clone()), host.agents),
None => {
let factory: delegation::child::ChildAgentFactory =
Arc::new(move |run: &ChildRun| child_agent(&runner_stack, &child, run));
let runner = match &memory_children {
Some(children) => children.runner(factory),
None => agent_runner(factory),
};
let agent_stores = agent_lanes.as_ref().map(|lanes| {
let lanes = lanes.clone();
AgentStores {
tasks: Box::new(MemoryDocumentStore::default()),
definitions: Box::new(MemoryDocumentStore::default()),
usage: Box::new(MemoryDocumentStore::default()),
lanes: Box::new(move |stack| lanes(stack)),
frames: Arc::new(inference::MemoryTraceStore::default()),
}
});
(None, runner, agent_stores)
}
};
let goal_slot: Arc<std::sync::OnceLock<Arc<GoalDriver>>> = Arc::new(std::sync::OnceLock::new());
let frames = inference::FrameSession::new(match &agent_stores {
Some(stores) => stores.frames.clone(),
None => Arc::new(inference::MemoryTraceStore::default()),
});
let (agents, usage, task_ends) = typed_agents(
&config,
agent_stores,
me.clone(),
root_model.clone(),
keys.clone(),
goal_slot.clone(),
Some(refinements),
crate::frames::frame_runner(frames.clone()),
&stats,
);
let _ = judge_ledger.set(usage.clone());
frames.set_tasks(Arc::new(crate::frames::StackFrameTasks {
agents: agents.clone(),
usage: usage.clone(),
stack: me.clone(),
}));
let schedules = Arc::new(SchedulesModule::new(schedules_store, None));
let goal = Arc::new(GoalDriver::new(
goal_store,
Arc::new(TaskGoalJobs::new(Arc::new(agents.clone()), host.clone())),
kernel_apis::util::system_clock(),
));
let _ = goal_slot.set(goal.clone());
let closer = me.clone();
let runner: ChildRunner = Arc::new(move |run: ChildRun| {
let lane = run.lane_name.clone();
let result = inner(run);
if let Some(stack) = closer.upgrade() {
stack.cell_hints.run_ended(&lane);
let _ = stack.lanes.close_lane(&lane);
stack.retire_workspace(&lane);
}
result
});
let mut options = DelegationOptions::new(runner);
if let Some(store) = store {
options.store = store;
}
let lane_wake = wake.clone();
options.collect = Arc::new(move |lane: &str| lane_wake.collect_mode(lane));
options.spawn_depth = config.spawn_depth;
options.session_id = session_id.clone();
options.workspace = Some(config.cwd.clone());
options.now = Box::new(|| jsrt::date::now_ms() as f64);
options.keep_worktrees = delegation::worktrees::keep_worktrees(
(config.var)(delegation::worktrees::KEEP_WORKTREES_ENV).as_deref(),
);
let settings = config.settings_reader();
options.worktree_setup = Arc::new(move || {
let configured = config::keys::worktree_settings(settings().settings());
Some(delegation::worktrees::WorktreeSetup {
link: configured.link,
copy: configured.copy,
command: configured.command,
timeout_ms: None,
})
});
let merges = stats.clone();
options.on_merge = Some(Arc::new(move |task: &str, status: &str| merges.merge(task, status)));
options.model_check = Some(config.model_check());
options.check_runner = crate::contract_checks::check_runner(me.clone());
let _ = skill_checks.set(options.check_runner.clone());
options.command_env = config.child_env();
let (delegation, child_ends) = Delegation::new(options);
let settings = config.settings_reader();
delegation.set_child_model(Arc::new(move || {
config::keys::rlm_model_settings(settings().global_settings()).child_model
}));
let pruning = delegation.clone();
std::thread::spawn(move || pruning.prune_orphan_worktrees());
agents.set_worktree_children(delegation.clone());
let factory_stack = me.clone();
let handler_stack = me.clone();
let lanes = Lanes::new(LanesOptions {
create: Arc::new(move |lane| {
let stack = factory_stack.upgrade().ok_or("the session is closed")?;
stack.kernel(lane)
}),
handlers: Arc::new(move |lane, signal, park| match handler_stack.upgrade() {
Some(stack) => stack.cell_handler(lane, Some((signal, park))),
None => Arc::new(Closed) as Arc<dyn HostHandler>,
}),
max_lanes: 64,
cancel_grace: Duration::from_secs(5),
pool: Some(lanes::PoolLimits::new(
max_live_kernels(&config.settings),
Some(lane_snapshot_path(&config, &session_id)),
)),
});
let (lanes, cell_ends) = match lanes {
Ok(pair) => {
let calls = stats.clone();
pair.0
.observe_requests(Arc::new(move |kind: &str| calls.host_call(kind)));
let guards_of = me.clone();
pair.0.extend_pool_stats(Arc::new(move |pool: &mut Value| {
if let Some(stack) = guards_of.upgrade() {
let guards = stack.guard_stats();
if !guards.is_empty() {
pool["guards"] = Value::Array(guards);
}
}
}));
pair
}
Err(error) => {
built = Err(error);
let (lanes, ends) = Lanes::new(LanesOptions {
create: Arc::new(|_| Err("no lanes".into())),
handlers: Arc::new(|_, _, _| Arc::new(Closed) as Arc<dyn HostHandler>),
max_lanes: 1,
cancel_grace: Duration::ZERO,
pool: None,
})
.expect("one lane is a valid limit");
(lanes, ends)
}
};
let events = Arc::new(RuntimeEvents::new(
(task_ends, child_ends, cell_ends),
config.async_events,
session_mask(&config),
));
Stack {
config,
mcp: gateway,
host,
delegation,
apis,
model,
root_model,
keys,
frame_stream,
session_id,
sessions_dir,
system,
services,
lanes,
workspaces: Mutex::new(HashMap::new()),
kernel_sandbox: std::sync::OnceLock::new(),
events,
cell_progress: Arc::new(Mutex::new(None)),
agents,
usage,
frames,
schedules,
goal,
work: std::sync::OnceLock::new(),
cell_hints,
context: std::sync::OnceLock::new(),
images,
swarm: std::sync::OnceLock::new(),
budget_note: Arc::new(std::sync::OnceLock::new()),
request_layer: Arc::new(std::sync::OnceLock::new()),
context_reminders,
lane_steer: Arc::new(std::sync::OnceLock::new()),
stats,
judge_rows,
retired_guards: Mutex::new(Vec::new()),
wake,
memory_children: memory_children_on,
ledger,
}
});
built?;
if let Some(children) = memory_children {
children.attach_reminders(stack.context_reminders.clone());
let _ = stack
.lane_steer
.set(Arc::new(move |lane: &str, message: &str| children.steer(lane, message)));
}
stack.lanes.open(session_journal::run::MAIN_LANE)?;
let work = DurableWork::open(
DurableWorkOptions::new(Arc::new(stack.agents.clone()))
.schedules(stack.schedules.clone())
.goal(stack.goal.clone())
.jobs(stack.host.clone()),
)?;
let _ = stack.work.set(work);
Ok(stack)
}
fn file_hooks_in(
&self,
cwd: &Path,
stats: Option<&Arc<SessionStats>>,
observers: Vec<Arc<dyn host::file_hooks::CellObserver>>,
) -> FileHooks {
let record = stats.map(|stats| {
let stats = stats.clone();
Arc::new(move |record: &GuardRecord| {
stats.guard(&GuardOutcome {
guard: &record.guard,
phase: record.phase,
outcome: record.outcome,
ms: record.ms as f64,
});
}) as OnRecord
});
let hooks = self.config.file_hooks_in(cwd, record);
for observer in observers {
hooks.observe(observer);
}
hooks
}
fn situational_skills(&self) -> Option<Arc<dyn host::file_hooks::CellObserver>> {
let config = self.config.clone();
let (extra, no_skills) = (self.services.resources.clone(), self.services.session.no_skills);
let resolve = move |name: &str| {
let cwd = config.cwd.display().to_string();
let agent_dir = config.agent_dir.display().to_string();
let bundled = config.bundled_skills();
let skill = crate::session_resources::skills(&cwd, &agent_dir, &extra, no_skills, bundled.as_deref())
.into_iter()
.find(|skill| skill.name == name)?;
let raw = std::fs::read_to_string(&skill.file_path).ok()?;
Some((skill.file_path, resources::frontmatter::strip(&raw).ok()?))
};
let (cwd, agent_dir, home) = (
self.config.cwd.clone(),
self.config.agent_dir.clone(),
self.config.home.clone(),
);
let session_cwd = cwd.clone();
let engineering = move || {
config::settings::SettingsManager::for_worker(&cwd, &agent_dir, &home)
.settings()
.get("engineering")
== Some(&Value::Bool(true))
};
crate::situational_skills::session_observer(
&self.config.settings,
&session_cwd,
Box::new(resolve),
Box::new(engineering),
)
}
fn memory_pointers(
&self,
session_id: &str,
records: &Arc<kernel_apis::memory_records::RecordIndex>,
) -> Option<Arc<dyn host::file_hooks::CellObserver>> {
let config = &self.config;
let filters = match &self.services.memory {
Some(backend) => backend.scope_tags(),
None if self.memorantado.is_some() || self.hindsight.is_some() => kernel_apis::memory::worker_scope_tags(
session_id,
&config.cwd.display().to_string(),
&config.home.display().to_string(),
),
None => return None,
};
kernel_apis::memory_pointers::session_pointers(&config.settings, records.clone(), filters)
}
fn host_in(
&self,
cwd: &Path,
session_id: &str,
spill: &str,
stats: Option<&Arc<SessionStats>>,
observers: Vec<Arc<dyn host::file_hooks::CellObserver>>,
) -> Result<Host, String> {
let config = &self.config;
let jobs_dir = self.sessions_dir.join("rlm-jobs").join(session_id);
let spill_dir = config.session_dir("rlm-output", session_id).join(spill);
let tmp_dir = config.session_dir("rlm-tmp", session_id);
for dir in [&spill_dir, &tmp_dir] {
std::fs::create_dir_all(dir).map_err(|e| format!("{}: {e}", dir.display()))?;
}
let shell_path = config
.settings
.as_object()
.and_then(|settings| config::keys::shell_path(settings, &config.home));
Ok(Host::new(
cwd,
jobs_dir,
spill_dir,
Box::new(self.file_hooks_in(cwd, stats, observers)),
)
.with_shell_path(shell_path)
.with_base_env(config.child_env())
.recording_cell_writes(!config.ts_guide)
.sandboxed(&config.settings, &config.home, Some(&tmp_dir)))
}
}
fn skill_sources(
config: &Config,
extra: &crate::session_resources::SessionResources,
no_skills: bool,
) -> Vec<SkillSource> {
let cwd = config.cwd.display().to_string();
let agent_dir = config.agent_dir.display().to_string();
let bundled = config.bundled_skills();
crate::session_resources::skills(&cwd, &agent_dir, extra, no_skills, bundled.as_deref())
.into_iter()
.map(|skill| SkillSource {
content: std::fs::read_to_string(&skill.file_path).unwrap_or_default(),
name: skill.name,
description: skill.description,
file_path: skill.file_path,
disable_model_invocation: skill.disable_model_invocation,
})
.collect()
}
struct ApiModules {
local: Arc<dyn kernel_apis::ApiModule>,
gates: Arc<services::ReleaseGateModule>,
skills: Arc<SkillsModule>,
procedures: Arc<delegation::skill_runs::SkillRuns>,
memory: Arc<MemoryApi>,
hints: Arc<HintsModule>,
images: Arc<kernel_apis::ImagesModule>,
diagram: Arc<diagram::DiagramModule>,
judge: Arc<judge::JudgeModule>,
knowledge: Arc<graph::KnowledgeModule>,
schedule: Arc<kernel_apis::prompt_schedule::ScheduleModule>,
tools: Arc<kernel_apis::ToolCalls>,
instances: Arc<kernel_apis::InstancesModule>,
progress: Arc<kernel_apis::ProgressModule>,
family: Arc<kernel_apis::FamilyModule>,
sessions: Arc<kernel_apis::SessionsModule>,
}
pub fn store_roots(agent_dir: &Path, home: &Path, session_root: Option<&Path>) -> Vec<PathBuf> {
let paths = config::paths::AgentPaths::new(agent_dir);
let mut projects: Vec<PathBuf> =
std::fs::read_dir(home.join(config::paths::AGENT_CONFIG_DIR_NAME).join("projects"))
.map(|entries| entries.flatten().map(|entry| entry.path().join("sessions")).collect())
.unwrap_or_default();
projects.sort();
let mut roots: Vec<PathBuf> = Vec::new();
for root in session_root
.map(Path::to_path_buf)
.into_iter()
.chain([paths.experimental_sessions_dir(), paths.sessions_dir()])
.chain(projects)
{
if !roots.contains(&root) {
roots.push(root);
}
}
roots
}
pub(crate) fn session_roots(config: &Config, sessions_dir: &Path) -> Vec<PathBuf> {
store_roots(&config.agent_dir, &config.home, sessions_dir.parent())
}
fn session_search(config: &Config, sessions_dir: &Path, session_id: &str) -> kernel_apis::SessionsModule {
kernel_apis::SessionsModule::new(
session_roots(config, sessions_dir),
session_id,
&config.cwd.display().to_string(),
kernel_apis::util::system_clock(),
)
}
struct Workspace {
cwd: PathBuf,
env: Vec<(String, String)>,
host: Arc<Host>,
}
struct Closed;
impl HostHandler for Closed {
fn handle(&self, kind: &str, _: Map<String, Value>, _: &Signal) -> Result<Value, String> {
Err(format!("The session is closed ({kind})"))
}
}
pub struct Stack {
config: Arc<Config>,
mcp: Arc<mcp::gateway::Gateway>,
pub host: Arc<Host>,
pub delegation: Delegation,
pub lanes: Lanes,
pub events: Arc<RuntimeEvents>,
apis: ApiModules,
model: Model,
root_model: Arc<Mutex<Model>>,
keys: crate::request_keys::Keys,
frame_stream: Arc<dyn StreamFn>,
session_id: String,
sessions_dir: PathBuf,
system: SystemPrompt,
services: Services,
workspaces: Mutex<HashMap<String, Workspace>>,
kernel_sandbox: std::sync::OnceLock<Option<Arc<sandbox::Launcher>>>,
pub cell_progress: Arc<Mutex<Option<harness::chat::CellProgress>>>,
pub agents: Agents,
pub usage: UsageLedger,
pub frames: Arc<inference::FrameSession>,
pub schedules: Arc<SchedulesModule>,
pub goal: Arc<GoalDriver>,
pub work: std::sync::OnceLock<DurableWork>,
cell_hints: Arc<kernel_apis::cell_hints::CellHints>,
pub context: std::sync::OnceLock<Arc<kernel_apis::ContextControl>>,
pub images: Arc<crate::view_images::ViewImages>,
pub swarm: std::sync::OnceLock<Arc<crate::swarm_ops::SwarmOps>>,
pub budget_note: Arc<std::sync::OnceLock<crate::budget_note::BudgetNote>>,
pub request_layer: Arc<std::sync::OnceLock<crate::request_layer::RequestLayer>>,
pub context_reminders: Arc<crate::context_reminder::ContextReminders>,
pub lane_steer: Arc<std::sync::OnceLock<crate::agent_hub::LaneSteer>>,
pub stats: Arc<SessionStats>,
judge_rows: Arc<std::sync::OnceLock<services::SessionValues>>,
retired_guards: Mutex<Vec<Value>>,
pub wake: crate::wake::RootWake,
memory_children: bool,
pub ledger: crate::auto_refine::Ledger,
}
impl Stack {
pub fn record_judge_rows_in(&self, session: crate::durable_store::SharedSession) {
let _ = self.judge_rows.set(services::SessionValues::shared(session));
}
pub(crate) fn config(&self) -> &Arc<Config> {
&self.config
}
pub fn memory(&self) -> Option<&kernel_apis::MemoryService> {
self.apis.memory.service.as_ref()
}
pub fn prompt_schedules(&self) -> &Arc<kernel_apis::prompt_schedule::ScheduleModule> {
&self.apis.schedule
}
pub fn pool_stats(&self) -> Value {
self.lanes.pool_stats()
}
pub fn guard_stats(&self) -> Vec<Value> {
let mut totals = self.host.guard_stats();
let others: Vec<Vec<Value>> = sync::lock(&self.workspaces)
.values()
.map(|w| w.host.guard_stats())
.chain(std::iter::once(sync::lock(&self.retired_guards).clone()))
.collect();
for stats in others {
add_guard_stats(&mut totals, &stats);
}
totals
}
pub fn begin_turn(&self) {
self.host.begin_turn();
for workspace in sync::lock(&self.workspaces).values() {
workspace.host.begin_turn();
}
for retired in sync::lock(&self.retired_guards).iter_mut() {
retired["turnMs"] = json!(0);
}
}
fn retire_workspace(&self, lane: &str) {
let Some(workspace) = sync::lock(&self.workspaces).remove(lane) else {
return;
};
add_guard_stats(&mut sync::lock(&self.retired_guards), &workspace.host.guard_stats());
}
fn host_of(&self, lane: &str) -> Arc<Host> {
sync::lock(&self.workspaces)
.get(lane)
.map_or_else(|| self.host.clone(), |w| w.host.clone())
}
pub fn cell_handler(&self, lane: &str, cell: Option<(Signal, Park)>) -> Arc<dyn HostHandler> {
let cell_signal = cell.as_ref().map(|(signal, _)| signal.clone());
let delegation: Arc<dyn HostHandler> = match cell {
Some((signal, park)) => Arc::new(self.delegation.cell_handler(lane, signal, park)),
None => Arc::new(self.delegation.lane_handler(lane)),
};
let router = Router {
delegation,
host: self.host_of(lane),
progress: (lane == session_journal::run::MAIN_LANE).then(|| self.cell_progress.clone()),
lane: lane.to_string(),
config: self.config.clone(),
swarm: self.swarm.get().cloned(),
cell: cell_signal.clone().map(CellShell::new),
};
let models = crate::frame_models::resolver(self.config.clone());
let inference = Inference::new(
Arc::new(router),
self.root_model(),
None,
Arc::new(crate::lane::process_transport()),
self.sessions_dir.join("rlm-context").join(&self.session_id),
)
.with_stream(self.frame_stream.clone())
.with_models(Arc::new(move |spec: &str| models(spec).map(|(model, _)| (model, None))))
.with_session(self.frames.clone(), lane);
let settings = self.config.settings_reader();
let models = move || {
let settings = settings();
let rlm = config::keys::rlm_model_settings(settings.global_settings());
inference::ModelSettings {
frame_model: rlm.frame_model,
frame_thinking: rlm.frame_thinking,
child_model: rlm.child_model,
review_model: config::keys::review_model(settings.global_settings()),
map_tokens: rlm.map_tokens,
}
};
let frames = inference::Frames::new(inference, self.config.frame_env.clone(), models);
let frames: Arc<dyn HostHandler> = match cell_signal {
Some(cell) => Arc::new(FramesOfCell {
inner: Arc::new(frames),
cell,
}),
None => Arc::new(frames),
};
let typed: Arc<dyn HostHandler> = Arc::new(self.agents.handler(lane, frames));
let mut apis = KernelApis::new(typed)
.with_host(Arc::new(self.agents.clone()), lane)
.with(self.schedules.clone() as Arc<dyn kernel_apis::ApiModule>)
.with(self.goal.clone() as Arc<dyn kernel_apis::ApiModule>);
if let Some(context) = self.context.get() {
apis = apis.with(context.clone() as Arc<dyn kernel_apis::ApiModule>);
}
let apis = apis
.with(self.apis.skills.clone())
.with(self.apis.procedures.clone())
.with(self.apis.memory.clone())
.with(self.apis.hints.clone())
.with(self.apis.images.clone())
.with(self.apis.diagram.clone())
.with(self.apis.judge.clone())
.with(self.apis.knowledge.clone())
.with(self.apis.schedule.clone())
.with(self.apis.tools.clone())
.with(self.apis.local.clone())
.with(self.apis.gates.clone())
.with(self.apis.instances.clone())
.with(self.apis.progress.clone())
.with(self.apis.sessions.clone())
.with(Arc::new(crate::agent_hub::Family::new(
self.apis.family.clone(),
self.delegation.clone(),
self.lane_steer.clone(),
)) as Arc<dyn kernel_apis::ApiModule>);
let observed: Arc<dyn HostHandler> = if self.cell_hints.active() {
Arc::new(ObservedByHints {
inner: Arc::new(apis),
hints: self.cell_hints.clone(),
lane: lane.to_string(),
})
} else {
Arc::new(apis)
};
let viewed: Arc<dyn HostHandler> = Arc::new(crate::view_images::ViewImageLayer {
inner: observed,
images: self.images.clone(),
lane: lane.to_string(),
});
Arc::new(crate::request_layer::Layered {
inner: viewed,
layer: self.request_layer.clone(),
lane: lane.to_string(),
})
}
fn kernel(&self, lane: &str) -> Result<Kernel, String> {
let config = &self.config;
let (cwd, extra) = match sync::lock(&self.workspaces).get(lane) {
Some(workspace) => (workspace.cwd.clone(), workspace.env.clone()),
None => (config.cwd.clone(), Vec::new()),
};
let spill_dir = config.session_dir("rlm-output", &self.session_id).join(lane_dir(lane));
let mut options = KernelOptions::new(&cwd, &config.runtime_path);
options.base_env = Some(config.child_env());
options.env = vec![
(
kernel::env::CODE_SKILLS_DIR_ENV.into(),
config.skills_dir.display().to_string(),
),
(kernel::env::RLM_SPILL_DIR_ENV.into(), spill_dir.display().to_string()),
(kernel::env::FILE_HOOKS_ENV.into(), "1".into()),
(kernel::env::RLM_STREAM_OUTPUT_ENV.into(), "1".into()),
("HOME".into(), config.home.display().to_string()),
];
options.env.extend(extra);
let snapshots = config.session_dir("rlm-snapshots", &self.session_id);
std::fs::DirBuilder::new()
.recursive(true)
.create(&snapshots)
.map_err(|e| format!("{}: {e}", snapshots.display()))?;
options.snapshot_path = Some(snapshots.join(format!("{}.snapshot", lane_dir(lane))));
options.snapshot_key = config.snapshot_key.clone();
options.continuity = Some(ContinuityPolicy::default());
options.sandbox = self.kernel_launcher(lane)?;
options.tree_memory = Some(kernel::TreeMemoryOptions {
backend: Some(
(config.var)(kernel::env::RLM_TREE_MEMORY_BACKEND_ENV)
.filter(|value| !value.trim().is_empty())
.unwrap_or_else(|| "watchdog".into()),
),
..kernel::TreeMemoryOptions::default()
});
Kernel::new(options, self.cell_handler(lane, None)).map_err(|e| e.to_string())
}
fn kernel_launcher(&self, lane: &str) -> Result<Option<Arc<sandbox::Launcher>>, String> {
let host = self.host_of(lane);
let workspace = sync::lock(&self.workspaces).contains_key(lane);
if !workspace && let Some(launcher) = self.kernel_sandbox.get() {
return Ok(launcher.clone());
}
let context = self.sessions_dir.join("rlm-context").join(&self.session_id);
std::fs::create_dir_all(&context).map_err(|e| format!("{}: {e}", context.display()))?;
let launcher = host.launcher().map(|launcher| {
let mut policy = launcher.policy.clone();
policy.writable.push(std::fs::canonicalize(&context).unwrap_or(context));
Arc::new(sandbox::Launcher::new(launcher.mode, policy))
});
if !workspace {
let _ = self.kernel_sandbox.set(launcher.clone());
}
Ok(launcher)
}
pub fn rlm(&self, lane: &str) -> Result<Rlm, String> {
self.lanes.open(lane)?;
let spill_dir = self
.config
.session_dir("rlm-output", &self.session_id)
.join(lane_dir(lane));
let hints = self.cell_hints.active().then(|| self.cell_hints.clone());
Ok(rlm_over(
&self.config,
self.lanes.clone(),
lane,
spill_dir,
hints,
self.images.clone(),
Some(self.host_of(lane)),
)
.with_budget_note(self.budget_note.clone())
.with_stats(self.stats.clone())
.with_context_reminders(self.context_reminders.clone())
.with_wake(self.wake.clone()))
}
pub fn commands(&self) -> Vec<Value> {
let bundled = self.config.bundled_skills();
let commands = crate::commands::list_commands_with(
&self.config.cwd.display().to_string(),
&self.config.agent_dir.display().to_string(),
bundled.as_deref(),
&self.services.resources,
);
crate::session_flags::filter_commands(commands, &self.services.session)
}
pub fn prompt_templates(&self) -> Vec<resources::prompt_templates::PromptTemplate> {
crate::session_resources::prompts(
&self.config.cwd.display().to_string(),
&self.config.agent_dir.display().to_string(),
&self.services.resources,
)
}
pub fn model(&self) -> &Model {
&self.model
}
pub fn root_model(&self) -> Model {
sync::lock(&self.root_model).clone()
}
pub fn set_root_model(&self, model: &Model) {
*sync::lock(&self.root_model) = model.clone();
self.system.set_model(&model.id);
self.images.set_model(None, model.clone());
}
pub fn keys(&self) -> &crate::request_keys::Keys {
&self.keys
}
pub fn system(&self) -> String {
self.system.current()
}
pub fn child_system(&self, model: &Model) -> String {
self.system.child_current(
ChildReader {
in_memory: self.memory_children,
memory: crate::memory_guidance::memory_guidance(model, &self.root_model(), true),
},
&model.id,
)
}
pub fn hand_over(&self) {
if let Some(work) = self.work.get() {
work.hand_over();
}
self.apis.tools.close();
self.mcp.close();
self.lanes.close();
self.stats.close();
}
pub fn close(&self) {
if let Some(work) = self.work.get() {
work.close();
}
self.apis.tools.close();
self.mcp.close();
self.agents.close();
self.delegation.close();
self.lanes.close();
self.stats.close();
}
pub fn cell_hints(&self) -> &Arc<kernel_apis::cell_hints::CellHints> {
&self.cell_hints
}
pub fn mcp(&self) -> &Arc<mcp::gateway::Gateway> {
&self.mcp
}
pub fn tool_calls(&self) -> &Arc<kernel_apis::ToolCalls> {
&self.apis.tools
}
pub fn mask(&self) -> crate::async_events::MaskText {
session_mask(&self.config)
}
}
pub struct SubagentHost {
pub store: Box<dyn kernel::store::DocumentStore>,
pub runner: Box<dyn FnOnce(Weak<Stack>) -> delegation::host::ChildRunner>,
pub agents: Option<AgentStores>,
}
pub struct AgentStores {
pub tasks: Box<dyn kernel::store::DocumentStore>,
pub definitions: Box<dyn kernel::store::DocumentStore>,
pub usage: Box<dyn kernel::store::DocumentStore>,
pub lanes: Box<dyn FnOnce(Weak<Stack>) -> delegation::agents::LaneRunner>,
pub frames: Arc<dyn inference::TraceStore>,
}
#[allow(clippy::too_many_arguments)]
fn typed_agents(
config: &Config,
stores: Option<AgentStores>,
stack: Weak<Stack>,
root_model: Arc<Mutex<Model>>,
keys: crate::request_keys::Keys,
goal: Arc<std::sync::OnceLock<Arc<GoalDriver>>>,
refinements: Option<delegation::agents::RefinementsHook>,
frames: delegation::agents::FrameRunner,
stats: &Arc<SessionStats>,
) -> (Agents, UsageLedger, Receiver<delegation::agents::TaskEnd>) {
let (tasks, definitions, usage_store, lanes) = match stores {
Some(stores) => (
stores.tasks,
stores.definitions,
stores.usage,
Some(hinted_lanes((stores.lanes)(stack.clone()), {
let stack = stack.clone();
Arc::new(move |lane: &str| {
if let Some(stack) = stack.upgrade() {
stack.cell_hints.run_ended(lane);
}
})
})),
),
None => (
Box::new(MemoryDocumentStore::default()) as Box<dyn kernel::store::DocumentStore>,
Box::new(MemoryDocumentStore::default()) as Box<dyn kernel::store::DocumentStore>,
Box::new(MemoryDocumentStore::default()) as Box<dyn kernel::store::DocumentStore>,
None,
),
};
let var = config.var.clone();
let root_budget = delegation::usage::root_budget_settings(&config.settings["rootBudget"]);
let limits = delegation::usage::limits_from_env(&|key| var(key), &root_budget);
let refused = stats.clone();
let usage = UsageLedger::new(
usage_store,
delegation::usage::UsageOptions {
limits,
on_refused: Some(Arc::new(move |_: &str| refused.usage_limit_block())),
keep_turns: true,
..Default::default()
},
)
.unwrap_or_else(|_| {
UsageLedger::new(Box::new(MemoryDocumentStore::default()), Default::default()).expect("an empty ledger opens")
});
let mut options = AgentsOptions::new(tasks);
options.definition_store = Some(definitions);
options.usage = Some(usage.clone());
options.lanes = lanes;
options.frames = Some(frames);
options.root_turns = true;
options.refinements = refinements;
options.pricing = Some(crate::budget_pricing::pricing(config, root_model.clone()));
let context_stack = stack.clone();
options.on_task_end = Some(Arc::new(move |task: &Value, cost, _| {
if let (Some(goal), Some(id)) = (goal.get(), task["id"].as_str()) {
let _ = goal.task_ended(id, task.get("result"));
}
if let Some(stack) = context_stack.upgrade()
&& let Some(context) = stack.context.get()
{
context.task_ended(task, cost);
}
}));
let settings = config.settings_reader();
options.predict = Some(predict_adapter(Arc::new(move |call: PredictCall<'_>| {
let model = sync::lock(&root_model).clone();
let idle = ai::http::http_idle_timeout(settings().settings().get("httpIdleTimeoutMs"));
let provider = crate::request_keys::Keyed {
inner: Provider::with_idle_timeout(idle),
keys: keys.clone(),
};
complete_once(&model, &provider, &call)
})));
let (pin_stack, unpin_stack) = (stack.clone(), stack.clone());
options.pin_lane = Some(Arc::new(move |lane: &str, holder: &str| {
pin_stack.upgrade().is_some_and(|stack| stack.lanes.pin(lane, holder))
}));
options.unpin_lane = Some(Arc::new(move |lane: &str, holder: &str| {
if let Some(stack) = unpin_stack.upgrade() {
stack.lanes.unpin(lane, holder);
}
}));
let extras_stack = stack.clone();
options.status_extras = Some(Arc::new(move |lane: &str| match extras_stack.upgrade() {
Some(stack) => crate::agents::status_extras(&stack.host, stack.tool_calls(), lane),
None => Map::new(),
}));
let reuse_stack = stack;
options.before_lane_reuse = Some(Arc::new(move |lane: &str| {
let stack = reuse_stack.upgrade().ok_or("The session is closed")?;
match stack.lanes.kernel(lane) {
Some(kernel) => kernel.reset_scratch().map(drop).map_err(|e| e.to_string()),
None => Ok(()),
}
}));
let (agents, ends) = Agents::new(options);
(agents, usage, ends)
}
pub fn hinted_lanes(
runner: delegation::agents::LaneRunner,
ended: Arc<dyn Fn(&str) + Send + Sync>,
) -> delegation::agents::LaneRunner {
Arc::new(move |run: delegation::agents::LaneRun| {
let lane = run.lane.clone();
let result = runner(run);
ended(&lane);
result
})
}
fn complete_once(model: &Model, provider: &dyn StreamFn, call: &PredictCall<'_>) -> Result<Completion, String> {
let context = ai::TranscriptContext {
messages: vec![
Message::System(ai::SystemMessage {
content: ai::SystemContent::Text(call.system.to_string()),
sections: None,
tools_added: None,
tools_removed: None,
timestamp: jsrt::date::now_ms(),
}),
Message::User(UserMessage {
content: UserMessageContent::Text(call.user.clone()),
timestamp: jsrt::date::now_ms(),
}),
],
};
let abort = ai::AbortSignal::new();
let mut options = ai::SimpleStreamOptions::default();
options.base.signal = Some(abort.clone());
let (signal, done) = (call.signal.clone(), Signal::new());
let watched = done.clone();
let watcher = std::thread::spawn(move || {
while !watched.is_aborted() {
if signal.wait(Duration::from_millis(200)) {
abort.abort();
return;
}
}
});
let mut sink = |_: &ai::AssistantMessageEvent| {};
let runtime = tokio::runtime::Builder::new_current_thread()
.enable_all()
.build()
.map_err(|e| e.to_string());
let message = runtime.map(|runtime| runtime.block_on(provider.stream(model, &context, &options, &mut sink)));
done.abort("done");
let _ = watcher.join();
let message = message?;
let text = message
.content
.iter()
.filter_map(|c| match c {
ai::AssistantContent::Text(text) => Some(text.text.as_str()),
_ => None,
})
.collect::<Vec<_>>()
.join("");
let stop = serde_json::to_value(message.stop_reason)
.ok()
.and_then(|v| v.as_str().map(str::to_string))
.unwrap_or_default();
Ok(Completion {
text,
stop_reason: stop,
error_message: message.error_message,
})
}
pub struct ChildSetup {
pub model: Model,
pub system: String,
pub thinking: String,
}
pub fn child_setup(stack: &Stack, run: &ChildRun) -> ChildSetup {
let model = run
.model
.as_deref()
.and_then(|spec| spec.split_once('/'))
.and_then(|(provider, id)| stack.config.model(provider, id))
.unwrap_or_else(|| stack.model.clone());
let root_cwd = stack.config.cwd.display().to_string();
let mut system = stack.child_system(&model);
if let Some(cwd) = run.cwd.as_deref() {
let host = Runtime {
config: stack.config.clone(),
services: stack.services.clone(),
diagnostics: Vec::new(),
system: SystemPrompt::fixed(""),
sessions_dir: stack.sessions_dir.clone(),
mode: String::new(),
hindsight: None,
memorantado: None,
memory_notice: None,
memory_explicit: false,
}
.host_in(
Path::new(cwd),
&stack.session_id,
&lane_dir(&run.lane_name),
Some(&stack.stats),
Vec::new(),
);
match host {
Ok(host) => {
let host = host.with_env(run.env.clone()).sharing_jobs(&stack.host);
sync::lock(&stack.workspaces).insert(
run.lane_name.clone(),
Workspace {
cwd: PathBuf::from(cwd),
env: run.env.clone(),
host: Arc::new(host),
},
);
system = system.split(&root_cwd).collect::<Vec<_>>().join(cwd);
}
Err(error) => system.push_str(&format!("\n\nThe worktree could not be prepared: {error}")),
}
}
stack.images.set_model(Some(&run.lane_name), model.clone());
stack.context_reminders.set_limit(
&run.lane_name,
crate::context_reminder::lane_limit(&model, true, harness::chat::CompactionPolicy::default().reserve_tokens),
);
stack
.stats
.child_model(&run.task_id, &format!("{}/{}", model.provider, model.id));
ChildSetup {
model,
system,
thinking: run.thinking.clone().unwrap_or_else(|| "off".into()),
}
}
fn child_agent(stack: &Weak<Stack>, defaults: &ChildDefaults, run: &ChildRun) -> (AgentOptions, Box<dyn StreamFn>) {
let Some(stack) = stack.upgrade() else {
let mut options = AgentOptions::new(defaults.model.clone());
options.system_prompt = Some("The session ended before this subagent started.".into());
let provider = crate::request_keys::Keyed {
inner: Provider::new(),
keys: defaults.keys.clone(),
};
return (options, Box::new(provider));
};
let setup = child_setup(&stack, run);
let system = setup.system;
let mut options = AgentOptions::new(setup.model);
options.system_prompt = Some(system.clone());
options.thinking_level = setup.thinking;
match stack.rlm(&run.lane_name) {
Ok(tool) => options.tools = vec![Arc::new(tool) as Arc<dyn AgentTool>],
Err(error) => options.system_prompt = Some(format!("{system}\n\nThe REPL failed to start: {error}")),
}
let provider = crate::request_keys::Keyed {
inner: Provider::new().with_live_settings(stack.config.settings_reader()),
keys: stack.keys.clone(),
};
(options, Box::new(provider))
}
struct ChildDefaults {
model: Model,
keys: crate::request_keys::Keys,
}
struct Router {
delegation: Arc<dyn HostHandler>,
host: Arc<Host>,
progress: Option<Arc<Mutex<Option<harness::chat::CellProgress>>>>,
lane: String,
config: Arc<Config>,
swarm: Option<Arc<crate::swarm_ops::SwarmOps>>,
cell: Option<CellShell>,
}
pub const CELL_CANCELLED_SHELL: &str = "the cell was cancelled; its shell command was stopped";
#[derive(Clone)]
struct CellShell {
waits: Signal,
jobs: Arc<Mutex<(Vec<String>, bool)>>,
}
impl CellShell {
fn new(waits: Signal) -> CellShell {
CellShell {
waits,
jobs: Arc::default(),
}
}
fn cancelled(&self, request: &Signal) -> bool {
self.waits.is_aborted() && !request.is_aborted()
}
fn run(
&self,
host: &Arc<Host>,
lane: &str,
kind: &str,
payload: Map<String, Value>,
request: &Signal,
) -> Result<Value, String> {
if self.cancelled(request) {
return Err(CELL_CANCELLED_SHELL.into());
}
let combined = Signal::new();
let follow = |source: &Signal| {
let target = combined.clone();
source.link(move |reason| target.abort(reason))
};
let links = (follow(request), follow(&self.waits));
let result = host.handle_lane(lane, kind, payload, &combined);
drop(links);
if let Ok(value) = &result {
let job = match kind {
"shell.run" => value["id"].as_str(),
_ => value["job"]["id"].as_str(),
};
if let Some(job) = job.filter(|_| kind != "shell.cancel") {
self.track(host, lane, job, request);
}
}
if self.cancelled(request) {
return Err(CELL_CANCELLED_SHELL.into());
}
result
}
fn track(&self, host: &Arc<Host>, lane: &str, job: &str, request: &Signal) {
let mut jobs = sync::lock(&self.jobs);
if !jobs.0.iter().any(|known| known == job) {
jobs.0.push(job.to_string());
}
if jobs.1 {
return;
}
jobs.1 = true;
drop(jobs);
let stop = {
let (host, lane, request, list) = (host.clone(), lane.to_string(), request.clone(), self.jobs.clone());
move |_reason: String| stop_cell_jobs(&host, &lane, &request, &list)
};
if self.waits.on_abort(stop).is_none() {
stop_cell_jobs(host, lane, request, &self.jobs);
}
}
}
impl HostHandler for Router {
fn handle(&self, kind: &str, payload: Map<String, Value>, signal: &Signal) -> Result<Value, String> {
if kind == "rlm.find_models" {
return Ok(self.config.find_models());
}
if kind == "rlm.race_models" {
return Ok(self.config.race_models());
}
if let Some(swarm) = &self.swarm
&& let Some(result) = swarm.handle(&self.lane, kind, &payload, signal)
{
return result;
}
if kind == crate::turns::CELL_OUTPUT {
if let Some(progress) = &self.progress {
crate::turns::publish_output(
progress,
payload.get("text").and_then(Value::as_str).unwrap_or(""),
&session_mask(&self.config),
);
}
return Ok(Value::Null);
}
if Delegation::serves(kind) {
return self.delegation.handle(kind, payload, signal);
}
if kind == "ext.call" || kind == "ext.list" {
return Err(EXTENSIONS_UNSUPPORTED.into());
}
let shell = matches!(kind, "bash" | "shell.run" | "shell.result");
let result = match &self.cell {
Some(cell) if shell => cell.run(&self.host, &self.lane, kind, payload, signal),
_ => self.host.handle_lane(&self.lane, kind, payload, signal),
};
if shell
&& let (Some(progress), Ok(value)) = (&self.progress, &result)
&& let Some(output) = value["output"].as_str().filter(|o| !o.is_empty())
&& let Some(progress) = sync::lock(progress).as_ref()
{
let output = session_mask(&self.config)(output);
progress.output(
if output.ends_with('\n') {
output
} else {
format!("{output}\n")
}
.as_str(),
);
}
result
}
}
fn stop_cell_jobs(host: &Arc<Host>, lane: &str, request: &Signal, jobs: &Mutex<(Vec<String>, bool)>) {
if request.is_aborted() {
return;
}
let ids = std::mem::take(&mut sync::lock(jobs).0);
for id in ids {
let mut payload = Map::new();
payload.insert("id".into(), Value::String(id));
let _ = host.handle_lane(lane, "shell.cancel", payload, &Signal::new());
}
}
struct ObservedByHints {
inner: Arc<dyn HostHandler>,
hints: Arc<kernel_apis::cell_hints::CellHints>,
lane: String,
}
impl HostHandler for ObservedByHints {
fn handle(&self, kind: &str, payload: Map<String, Value>, signal: &Signal) -> Result<Value, String> {
let started = jsrt::date::now_ms();
let observed = payload.clone();
let result = self.inner.handle(kind, payload, signal);
self.hints
.observe(&self.lane, kind, &observed, result.as_ref().ok(), started);
result
}
}
struct FramesOfCell {
inner: Arc<dyn HostHandler>,
cell: Signal,
}
impl HostHandler for FramesOfCell {
fn handle(&self, kind: &str, payload: Map<String, Value>, signal: &Signal) -> Result<Value, String> {
if kind != "rlm.infer" && kind != "rlm.map" {
return self.inner.handle(kind, payload, signal);
}
let combined = Signal::new();
let done = Signal::new();
let (cell, request, abort, finished) = (self.cell.clone(), signal.clone(), combined.clone(), done.clone());
let watcher = std::thread::spawn(move || {
while !finished.wait(Duration::from_millis(20)) {
for source in [&cell, &request] {
if source.is_aborted() {
abort.abort(source.reason().unwrap_or_else(|| "the cell was cancelled".into()));
return;
}
}
}
});
let result = self.inner.handle(kind, payload, &combined);
done.abort("finished");
let _ = watcher.join();
result
}
}
pub fn task_event_summary(task: &Value) -> String {
let result = &task["result"];
let detail = if result["status"] == "succeeded" {
match &result["value"] {
Value::String(text) => text.clone(),
other => other.to_string(),
}
} else {
result["error"].as_str().unwrap_or_default().to_string()
};
let tag = if result.is_object() {
delegation::verdict::verdict_tag(result)
} else {
None
};
let definition = task["definition"].as_str().unwrap_or("undefined");
match tag {
Some(tag) => format!("{definition}: {tag} {detail}"),
None => format!("{definition}: {detail}"),
}
}
pub fn session_mask(config: &Config) -> crate::async_events::MaskText {
let (masker, flag) = (config.masker.clone(), config.mask_secrets.clone());
Arc::new(move |text: &str| masker.mask_counted(text, flag.as_deref()).0)
}
pub struct RuntimeEvents {
ends: Arc<(Mutex<Vec<RuntimeEvent>>, Condvar)>,
enabled: bool,
mask: crate::async_events::MaskText,
}
impl RuntimeEvents {
fn new(
(task_ends, child_ends, cell_ends): (
Receiver<delegation::agents::TaskEnd>,
Receiver<DetachedEnd>,
Receiver<CellEnd>,
),
enabled: bool,
mask: crate::async_events::MaskText,
) -> Self {
let ends: Arc<(Mutex<Vec<RuntimeEvent>>, Condvar)> = Arc::default();
fn read<T: Send + 'static>(
from: Receiver<T>,
into: &Arc<(Mutex<Vec<RuntimeEvent>>, Condvar)>,
event: fn(T) -> Option<RuntimeEvent>,
) {
let into = into.clone();
std::thread::spawn(move || {
for end in from {
if let Some(event) = event(end) {
sync::lock(&into.0).push(event);
into.1.notify_all();
}
}
});
}
read(task_ends, &ends, task_end_event);
read(child_ends, &ends, |end| Some(child_end_event(end)));
read(cell_ends, &ends, |end| Some(cell_end_event(end)));
RuntimeEvents { ends, enabled, mask }
}
pub fn recv(&self, wait: Duration) -> Vec<RuntimeEvent> {
let ends = sync::lock(&self.ends.0);
let (mut ends, _) = self
.ends
.1
.wait_timeout_while(ends, wait, |ends| ends.is_empty())
.unwrap_or_else(std::sync::PoisonError::into_inner);
std::mem::take(&mut *ends)
}
pub fn root_lines(&self, events: &[RuntimeEvent]) -> Vec<String> {
events
.iter()
.filter(|e| e.lane == session_journal::run::MAIN_LANE)
.map(|e| {
crate::async_events::runtime_event_line(&e.kind, &e.id, &e.status, &e.summary, &e.fetch, &self.mask)
})
.collect()
}
pub fn enabled(&self) -> bool {
self.enabled
}
}
fn task_end_event(end: delegation::agents::TaskEnd) -> Option<RuntimeEvent> {
if end.awaited {
return None;
}
let task = &end.task;
Some(RuntimeEvent {
kind: end.kind.into(),
id: task["id"].as_str().unwrap_or_default().into(),
status: task_status(task).into(),
summary: task_event_summary(task),
fetch: end.fetch.clone(),
lane: end.owner_lane.clone(),
root_id: end.root_id.clone(),
})
}
fn child_end_event(end: DetachedEnd) -> RuntimeEvent {
let task = &end.task;
RuntimeEvent {
kind: end.kind.into(),
id: task["id"].as_str().unwrap_or_default().into(),
status: task_status(task).into(),
summary: task_event_summary(task),
fetch: end.fetch.clone(),
lane: end.owner_lane.clone(),
root_id: None,
}
}
fn cell_end_event(end: CellEnd) -> RuntimeEvent {
let (status, summary) = match &end.outcome {
Ok(result) => (
if result.status == kernel::Status::Ok {
"completed"
} else {
"failed"
},
[result.stdout.as_str(), result.result.as_deref().unwrap_or_default()].join(" "),
),
Err(error) => ("failed", error.clone()),
};
RuntimeEvent {
kind: "cell_done".into(),
id: end.cell,
status: status.into(),
summary,
fetch: "await rlm.cells()".into(),
lane: end.lane,
root_id: None,
}
}
fn task_status(task: &Value) -> &str {
task["result"]["status"]
.as_str()
.or(task["state"].as_str())
.unwrap_or("ended")
}
pub fn only_rlm(tools: &[Value]) -> bool {
tools.len() == 1 && tools[0]["name"] == json!("rlm")
}
fn add_guard_stats(totals: &mut Vec<Value>, more: &[Value]) {
const COUNTERS: [&str; 7] = [
"checks",
"blocked",
"unchecked",
"afterChecks",
"afterFindings",
"totalMs",
"turnMs",
];
for (index, stats) in more.iter().enumerate() {
match totals.get_mut(index).filter(|t| t["name"] == stats["name"]) {
Some(total) => {
for key in COUNTERS {
let sum = total[key].as_u64().unwrap_or(0) + stats[key].as_u64().unwrap_or(0);
total[key] = json!(sum);
}
}
None => totals.push(stats.clone()),
}
}
}