use crate::compose::{Config, Runtime, RuntimeEvents, Stack};
use crate::{ModelFlags, RunEnv as Env};
use agent::{AgentTool, AgentToolResult, StreamFn, ToolUpdate};
use ai::http::{BoxFuture, ReqwestTransport};
use ai::model_registry::ModelRegistry;
use ai::{
AbortSignal, AssistantMessage, EventSink, Message, Model, SimpleStreamOptions, StopReason, TextContent, Tool,
TranscriptContext, Transport, UserContent, UserMessage, UserMessageContent,
};
use host::Host;
use host::cell::{CellFormat, cell_output};
use host::secrets::OutputMasker;
use kernel::Kernel;
use lanes::{CellOutcome, Lanes};
use serde_json::{Value, json};
use session_journal::run::MAIN_LANE;
use std::future::Future;
use std::path::{Path, PathBuf};
use std::pin::pin;
use std::sync::{Arc, Mutex};
use std::task::Poll;
use std::time::Duration;
pub const CLOCK_CONTEXT_ENV: &str = "ULTRON_CLOCK_CONTEXT";
const RLM_DESCRIPTION: &str = "Run a Python cell in your persistent REPL: variables, imports and functions persist across calls, top-level `await` works, and the last expression's value is shown with anything printed (kept as `_`).\nPre-imported: `bash`, `read`, `edit`, `write`, `view_image`, `rlm`, `agents`, `workflows`, `background`, `tools`, `mcp`, `ctx`, `skills`, `memory`, `hints`, `agent`, `Budget`, `state`, `preview`, `asyncio`; `help(obj)` shows any API's docs.";
const RLM_SNIPPET: &str = "Python REPL for files, shell (`bash`), edits (`edit`), data and subagents";
pub const ABORT_REQUESTED: &str = "Abort requested";
pub fn rlm_tool() -> Tool {
Tool {
name: "rlm".into(),
description: RLM_DESCRIPTION.into(),
parameters: json!({
"type": "object",
"properties": {"code": {"type": "string", "description": "Python code for persistent RLM computation, typed agents, and data processing"}},
"required": ["code"],
}),
constrained_sampling: None,
}
}
use jsrt::date::now_ms;
pub fn text_block(text: String) -> UserContent {
UserContent::Text(TextContent {
text,
text_signature: None,
})
}
pub fn format_clock(ms: i64, zone: &jsrt::localtime::Zone) -> String {
let offset = zone.offset(ms as f64);
let local = jsrt::localtime::fields(ms as f64, offset);
let minutes = offset.div_euclid(60);
let sign = if minutes >= 0 { '+' } else { '-' };
format!(
"{}-{:02}-{:02} {:02}:{:02} UTC{sign}{:02}:{:02}",
local.year,
local.month,
local.day,
local.hour,
local.minute,
minutes.abs() / 60,
minutes.abs() % 60
)
}
pub const CLOCK_GAP_MS: i64 = 10 * 60 * 1000;
pub fn format_gap(ms: i64) -> String {
let minutes = ms.div_euclid(60_000);
if minutes < 120 {
return format!("{minutes} min");
}
let hours = minutes / 60;
if hours < 48 {
format!("{hours} h")
} else {
format!("{} d", hours / 24)
}
}
pub fn clock_zone(env: &Env) -> jsrt::localtime::Zone {
jsrt::localtime::Zone::from_env((env.var)("TZ").as_deref())
}
pub fn clock_enabled(env: &Env) -> bool {
!env.flag_off(CLOCK_CONTEXT_ENV)
}
fn clock_texts(messages: &[Value], zone: &jsrt::localtime::Zone) -> Vec<(usize, String, i64)> {
let mut out = Vec::new();
let mut previous: Option<i64> = None;
for (index, message) in messages.iter().enumerate() {
let at = message
.get("timestamp")
.and_then(Value::as_f64)
.filter(|t| t.is_finite() && *t > 0.0)
.map(|t| t as i64);
if let Some(at) = at
&& message.get("role").and_then(Value::as_str) == Some("user")
&& !is_compaction_summary(message)
&& previous.is_none_or(|p| at - p >= CLOCK_GAP_MS)
{
let gap = previous.map_or(String::new(), |p| {
format!(", {} after the previous message", format_gap(at - p))
});
out.push((index, format!("[clock] {}{gap}", format_clock(at, zone)), at));
}
if at.is_some() {
previous = at;
}
}
out
}
fn is_compaction_summary(message: &Value) -> bool {
let text = match &message["content"] {
Value::String(text) => Some(text.as_str()),
Value::Array(blocks) => blocks.first().and_then(|block| block["text"].as_str()),
_ => None,
};
text.is_some_and(|text| text.starts_with(session_journal::context::COMPACTION_SUMMARY_PREFIX))
}
pub fn clock_lines_in(messages: &[Value], zone: &jsrt::localtime::Zone) -> Vec<(usize, Message)> {
clock_texts(messages, zone)
.into_iter()
.map(|(index, text, at)| {
let line = Message::User(UserMessage {
content: UserMessageContent::Blocks(vec![text_block(text)]),
timestamp: at,
});
(index, line)
})
.collect()
}
pub fn with_clock_lines_in(messages: &[Value], zone: &jsrt::localtime::Zone) -> Option<Vec<Value>> {
let lines = clock_texts(messages, zone);
if lines.is_empty() {
return None;
}
let mut out = Vec::with_capacity(messages.len() + lines.len());
let mut pending = lines.into_iter().peekable();
for (index, message) in messages.iter().enumerate() {
if let Some((_, text, at)) = pending.next_if(|(i, _, _)| *i == index) {
out.push(json!({"role": "user", "content": [{"type": "text", "text": text}], "timestamp": at}));
}
out.push(message.clone());
}
Some(out)
}
pub fn result_footer(at_ms: i64, start_ms: i64, context_tokens: u64) -> String {
let seconds = (at_ms - start_ms).max(0) / 1000;
let (minutes, hours) = (seconds / 60, seconds / 3600);
let elapsed = if seconds < 60 {
format!("{seconds}s")
} else if minutes < 60 {
format!("{minutes}m{:02}s", seconds % 60)
} else if hours < 48 {
format!("{hours}h{:02}m", minutes % 60)
} else {
format!("{}d{}h", hours / 24, hours % 24)
};
if context_tokens == 0 {
return format!("[t+{elapsed}]");
}
let context = if context_tokens < 1000 {
context_tokens.to_string()
} else {
format!("{}k", (context_tokens + 500) / 1000)
};
format!("[t+{elapsed} ctx {context}]")
}
pub fn add_result_footers(messages: &mut [Message], start_ms: i64) {
let mut context = 0;
for message in messages {
match message {
Message::Assistant(assistant) => {
let usage = &assistant.usage;
context = usage.input + usage.cache_read + usage.cache_write + usage.output;
}
Message::ToolResult(result) if result.timestamp > 0 => {
result
.content
.push(text_block(result_footer(result.timestamp, start_ms, context)));
}
_ => {}
}
}
}
pub fn to_llm(messages: &[Value]) -> Vec<Message> {
session_journal::context::convert_to_llm(messages)
.into_iter()
.filter_map(|m| serde_json::from_value(m).ok())
.collect()
}
pub fn system_prompt(env: &Env, cwd: &str, loki_root: Option<&Path>) -> Result<String, String> {
system_prompt_with_guide(env, cwd, loki_root, &Default::default())
}
pub fn system_prompt_with_guide(
env: &Env,
cwd: &str,
loki_root: Option<&Path>,
guide: &resources::runtime_guide::RuntimeGuideOptions,
) -> Result<String, String> {
let settings = config::settings::SettingsManager::for_worker(Path::new(cwd), &env.agent_dir(), &env.home);
let mode = PromptMode::from_settings(&settings);
system_prompt_in_mode(env, cwd, loki_root, guide, &mode).map(|(prompt, _)| prompt)
}
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct PromptMode {
pub engineering: bool,
pub always_skills: Vec<String>,
pub no_skills: bool,
pub no_context_files: bool,
pub persona: bool,
pub model: String,
}
impl PromptMode {
pub fn from_settings(settings: &config::settings::SettingsManager) -> PromptMode {
let settings = settings.settings();
PromptMode {
engineering: settings.get("engineering") == Some(&Value::Bool(true)),
always_skills: settings
.get("alwaysSkills")
.and_then(Value::as_array)
.map(|names| names.iter().filter_map(Value::as_str).map(str::to_string).collect())
.unwrap_or_default(),
persona: resources::persona::enabled(settings),
..PromptMode::default()
}
}
}
pub fn system_prompt_in_mode(
env: &Env,
cwd: &str,
loki_root: Option<&Path>,
guide: &resources::runtime_guide::RuntimeGuideOptions,
mode: &PromptMode,
) -> Result<(String, Vec<String>), String> {
let resources = crate::session_resources::resolve_default(env);
system_prompt_with_resources(env, cwd, loki_root, guide, mode, &resources)
}
pub fn system_prompt_with_resources(
env: &Env,
cwd: &str,
loki_root: Option<&Path>,
guide: &resources::runtime_guide::RuntimeGuideOptions,
mode: &PromptMode,
extra: &crate::session_resources::SessionResources,
) -> Result<(String, Vec<String>), String> {
use resources::system_prompt::{BuildOptions, build_system_prompt};
let agent_dir = env.agent_dir().display().to_string();
let bundled = crate::session_resources::bundled_skills(&env.skills(), &*env.var);
let mut skills = crate::session_resources::skills(cwd, &agent_dir, extra, mode.no_skills, bundled.as_deref());
let mut warnings = Vec::new();
if !mode.no_skills {
warnings = resources::skills::apply_always_skills(&mut skills, &mode.always_skills)
.into_iter()
.map(|d| d.message)
.collect();
}
let persona = if mode.persona {
match resources::persona::read_personality(&env.agent_dir()) {
Ok(text) => text,
Err(warning) => {
warnings.push(warning);
None
}
}
} else {
None
};
let runtime = resources::runtime_guide::rlm_runtime_prompt(&["rlm"], guide).unwrap_or_default();
let loki_note = loki_root.and_then(loki::session_note);
let options = BuildOptions {
selected_tools: vec!["rlm".into()],
tool_snippets: vec![("rlm".into(), RLM_SNIPPET.into())],
tool_guidelines: vec![("rlm".into(), resources::runtime_guide::rlm_tool_guidelines(&["rlm"]))],
include_harness_docs: false,
context_files: if mode.no_context_files {
Vec::new()
} else {
resources::context_files::load_project_context_files(cwd, &agent_dir, &env.home.display().to_string())
},
skills,
bundled_skills_dir: bundled,
custom_prompt: extra.system_prompt.clone(),
append_system_prompt: extra.append_system_prompt.join("\n\n"),
sections: [("runtime".to_string(), runtime)]
.into_iter()
.chain(loki_note.map(|note| ("loki".to_string(), note)))
.chain(
resources::model_notes::model_notes(&mode.model)
.filter(|_| guide.durable_apis)
.map(|notes| ("model_notes".to_string(), notes)),
)
.collect(),
engineering: mode.engineering,
persona,
proactive_skills: mode.engineering && guide.durable_apis,
..BuildOptions::new(cwd)
};
Ok((build_system_prompt(&options, None)?, warnings))
}
pub fn registry(env: &Env) -> ModelRegistry {
let paths = config::paths::AgentPaths::new(env.agent_dir());
let models = paths.models();
let mut registry = ModelRegistry::load(&models, &env.home);
if let Some(credentials) = std::fs::read_to_string(paths.auth())
.ok()
.and_then(|text| config::json::parse(&text).ok())
{
let store = config::models_store::ModelsStore::beside(&models);
registry.import_legacy_radius(&credentials, &store, now_ms());
}
registry
}
pub fn catalog_model(provider: &str, id: &str, env: &Env) -> Result<Model, String> {
let registry = registry(env);
let model = registry
.find(provider, id)
.ok_or_else(|| format!("Model \"{provider}/{id}\" not found"))?;
Ok(for_requests(®istry, model, env))
}
pub fn for_requests(registry: &ModelRegistry, model: Model, env: &Env) -> Model {
prepare(registry, model, env)
}
pub fn subscription_providers(env: &Env) -> Vec<String> {
let registry = registry(env);
let options = crate::stored_auth::OAuthOptions::for_env(env);
let mut providers: Vec<String> = registry
.provider_ids()
.into_iter()
.filter(|p| {
if p == ai::claude_code::PROVIDER {
return registry.auth_configured(p, &*env.var, false);
}
stored_oauth(env, p)
&& crate::stored_auth::oauth_handler_with(env, p, &options).is_some_and(|oauth| oauth.is_subscription())
})
.collect();
let dynamic = ai::claude_subscription::PROVIDER.to_string();
if !providers.contains(&dynamic) {
providers.push(dynamic);
}
providers
}
fn stored_oauth(env: &Env, provider: &str) -> bool {
let auth = config::paths::AgentPaths::new(env.agent_dir()).auth();
config::auth::read_stored_credential(&auth, provider)
.is_some_and(|c| c.get("type").and_then(Value::as_str) == Some("oauth"))
}
fn prepare(registry: &ModelRegistry, model: Model, env: &Env) -> Model {
let mut model = registry.for_requests(model, env.var.clone());
if [ai::claude_code::PROVIDER, ai::claude_subscription::PROVIDER].contains(&model.provider.as_str()) {
return model;
}
let (env, provider) = (env.clone(), model.provider.clone());
model.request.get_or_insert_default().stored_auth = Some(Arc::new(move || {
crate::stored_auth::has_request_auth(&env, &provider)
.then(|| crate::stored_auth::request_auth(&env, &provider))
.flatten()
}));
model
}
pub fn resolve_model(flags: &ModelFlags, env: &Env) -> Result<Model, String> {
resolve_choice(flags, env, false).map(|choice| choice.model)
}
#[derive(Clone, Debug)]
pub struct ModelChoice {
pub model: Model,
pub thinking: Option<String>,
pub warning: Option<String>,
}
pub fn resolve_cli_model(
env: &Env,
provider: Option<&str>,
model: &str,
authenticated: bool,
) -> ai::model_resolver::CliModel {
let registry = registry(env);
let configured = if authenticated {
configured_providers(env, ®istry)
} else {
Vec::new()
};
registry.resolve_cli(provider, model, None, &|p: &str| configured.iter().any(|c| c == p))
}
pub fn resolve_choice(flags: &ModelFlags, env: &Env, continuing: bool) -> Result<ModelChoice, String> {
let Some(spec) = flags.model.as_deref() else {
if let Some(choice) = durable_choice(flags, env) {
return Ok(choice);
}
return initial_choice(flags, env, continuing)
.ok_or_else(|| "No model selected: pass --model <provider>/<id>".to_string());
};
let registry = registry(env);
let configured = configured_providers(env, ®istry);
let has_auth = |p: &str| configured.iter().any(|c| c == p);
let resolved = registry.resolve_cli(flags.provider.as_deref(), spec, flags.thinking.as_deref(), &has_auth);
let model = match (resolved.model, resolved.error) {
(Some(model), _) => model,
(None, error) => return Err(error.unwrap_or_else(|| format!("Model \"{spec}\" not found"))),
};
Ok(ModelChoice {
model: for_requests(®istry, model, env),
thinking: resolved.thinking_level,
warning: resolved.warning,
})
}
pub fn is_durable(env: &Env) -> bool {
config::settings::is_durable_process() || (env.var)(config::settings::DURABLE_CLIENT_ENV).as_deref() == Some("1")
}
fn durable_choice(flags: &ModelFlags, env: &Env) -> Option<ModelChoice> {
if flags.provider.is_some() || flags.models.is_some() || !is_durable(env) {
return None;
}
let spec = config::settings::SettingsManager::for_worker(&env.cwd, &env.agent_dir(), &env.home).durable_model();
let registry = registry(env);
let configured = configured_providers(env, ®istry);
let resolved = registry.resolve_cli(None, &spec, None, &|p: &str| configured.iter().any(|c| c == p));
let model = resolved.model.filter(|_| resolved.error.is_none())?;
Some(ModelChoice {
model: for_requests(®istry, model, env),
thinking: resolved.thinking_level,
warning: resolved.warning,
})
}
fn initial_choice(flags: &ModelFlags, env: &Env, continuing: bool) -> Option<ModelChoice> {
let settings = config::settings::SettingsManager::for_worker(&env.cwd, &env.agent_dir(), &env.home);
let all = settings.settings();
let text = |v: Option<Value>| v.and_then(|v| v.as_str().map(str::to_string));
let registry = registry(env);
let available = available_models(env);
let patterns: Vec<String> = match &flags.models {
Some(patterns) => patterns.clone(),
None => all
.get("enabledModels")
.and_then(Value::as_array)
.map(|a| a.iter().filter_map(Value::as_str).map(str::to_string).collect())
.unwrap_or_default(),
};
let (default_provider, default_model) = (text(settings.default_provider()), text(settings.default_model()));
let choice = |model: Model, thinking: Option<String>| ModelChoice {
model: for_requests(®istry, model, env),
thinking,
warning: None,
};
if !continuing && !patterns.is_empty() {
let (scoped, _) = ai::model_resolver::resolve_model_scope(&patterns, &available);
let saved = scoped.iter().find(|s| {
default_provider.as_deref() == Some(s.model.provider.as_str())
&& default_model.as_deref() == Some(s.model.id.as_str())
});
if let Some(pick) = saved.or(scoped.first()) {
return Some(choice(pick.model.clone(), pick.thinking_level.clone()));
}
}
let levels = all
.get("modelThinkingLevels")
.and_then(Value::as_object)
.map(|m| {
m.iter()
.filter_map(|(k, v)| Some((k.clone(), v.as_str()?.to_string())))
.collect()
})
.unwrap_or_default();
let initial = ai::model_resolver::InitialSettings {
default_provider,
default_model_id: default_model,
default_thinking_level: all
.get("defaultThinkingLevel")
.and_then(Value::as_str)
.map(str::to_string),
model_thinking_levels: levels,
};
let configured: Vec<String> = available.iter().map(|m| m.provider.clone()).collect();
let has_auth = |p: &str| configured.iter().any(|c| c == p);
let mut models = registry.all_models();
if let (Some(p), Some(id)) = (&initial.default_provider, &initial.default_model_id)
&& let Some(found) = registry.find(p, id)
&& !models.iter().any(|m| m.provider == found.provider && m.id == found.id)
{
models.push(found);
}
let (model, _) = ai::model_resolver::find_initial_model(&[], continuing, &initial, &models, &available, &has_auth);
model.map(|model| choice(model, None))
}
fn initial_level(all: &serde_json::Map<String, Value>, model: &Model) -> String {
all.get("modelThinkingLevels")
.and_then(|levels| levels.get(format!("{}/{}", model.provider, model.id)))
.and_then(Value::as_str)
.or_else(|| all.get("defaultThinkingLevel").and_then(Value::as_str))
.unwrap_or(model_scope::DEFAULT_THINKING_LEVEL)
.to_string()
}
pub fn initial_thinking(model: &Model, env: &Env) -> String {
let settings = config::settings::SettingsManager::for_worker(&env.cwd, &env.agent_dir(), &env.home);
initial_level(settings.settings(), model)
}
fn configured_providers(env: &Env, registry: &ModelRegistry) -> Vec<String> {
let auth = config::paths::AgentPaths::new(env.agent_dir()).auth();
registry
.provider_ids()
.into_iter()
.filter(|p| {
config::auth::read_stored_credential(&auth, p).is_some()
|| registry.auth_configured(p, &*env.var, env_api_key_with(env, registry, p).is_some())
})
.collect()
}
pub fn available_models(env: &Env) -> Vec<Model> {
let registry = registry(env);
let mut models: Vec<Model> = configured_providers(env, ®istry)
.into_iter()
.flat_map(|p| {
let registry = ®istry;
provider_models(env, registry, &p)
.into_iter()
.map(move |m| prepare(registry, m, env))
})
.collect();
models.extend(subscription_models(env, ®istry, &models));
models
}
fn provider_models(env: &Env, registry: &ModelRegistry, provider: &str) -> Vec<Model> {
let models = registry.models(provider);
let credential = || {
let auth = config::paths::AgentPaths::new(env.agent_dir()).auth();
config::auth::read_stored_credential(&auth, provider).and_then(|c| ai::auth::Credential::from_json(&c))
};
ai::auth::filter_models(provider, &models, |m| m.id.as_str(), credential)
.into_iter()
.cloned()
.collect()
}
fn subscription_models(env: &Env, registry: &ModelRegistry, listed: &[Model]) -> Vec<Model> {
use ai::claude_subscription::{PROVIDER, catalog, process};
let mut lookup: ai::claude_subscription::Env = [
process::COMMAND_ENV,
ai::claude_code_cli::CLAUDE_CODE_BIN_ENV,
"PATH",
"HOME",
]
.into_iter()
.filter_map(|k| (env.var)(k).map(|v| (k.to_string(), v)))
.collect();
lookup
.entry("HOME".into())
.or_insert_with(|| env.home.to_string_lossy().into_owned());
if process::resolve_claude(None, &lookup).is_none() {
return Vec::new();
}
catalog::pinned_routes()
.into_iter()
.filter(|(_, id, _)| !listed.iter().any(|m| m.provider == PROVIDER && m.id == *id))
.filter_map(|(_, id, _)| registry.find(PROVIDER, id))
.map(|m| prepare(registry, m, env))
.collect()
}
pub fn api_key(flags: &ModelFlags, env: &Env, provider: &str) -> Option<String> {
request_key(flags, env, provider).ok().flatten()
}
pub fn request_key(flags: &ModelFlags, env: &Env, provider: &str) -> Result<Option<String>, String> {
if let Some(key) = flags.api_key.as_deref() {
return Ok(Some(key.to_string()));
}
if let Some(key) = crate::stored_auth::resolved_key(env, provider)? {
return Ok(key);
}
match crate::stored_auth::stored_key(env, provider)? {
crate::stored_auth::Stored::Owns(key) => Ok(key),
crate::stored_auth::Stored::Nothing => {
let registry = registry(env);
let inherited = env_api_key_with(env, ®istry, provider);
registry.api_key(provider, None, &*env.var, inherited)
}
}
}
pub fn header_auth(env: &Env, provider: &str) -> bool {
crate::stored_auth::oauth_request_auth(env, provider).is_some_and(|auth| auth.headers.is_some())
|| crate::stored_auth::header_owned(env, provider)
}
pub fn env_api_key(env: &Env, provider: &str) -> Option<String> {
env_api_key_with(env, ®istry(env), provider)
}
pub(crate) fn env_api_key_over(
env: &Env,
provider: &str,
stored: &std::collections::HashMap<String, String>,
) -> Option<String> {
let lookup = |name: &str| stored.get(name).cloned().or_else(|| (env.var)(name));
env_api_key_in(env, ®istry(env), provider, &lookup)
}
fn env_api_key_with(env: &Env, registry: &ModelRegistry, provider: &str) -> Option<String> {
env_api_key_in(env, registry, provider, &*env.var)
}
fn env_api_key_in(
env: &Env,
registry: &ModelRegistry,
provider: &str,
lookup: &dyn Fn(&str) -> Option<String>,
) -> Option<String> {
let provider = if registry.radius_gateway(provider).is_some() {
"radius"
} else {
provider
};
let source = ai::env::EnvSource {
lookup,
exists: &|p: &Path| p.exists(),
home: Some(env.home.clone()),
};
ai::env::env_api_key_in(provider, &source)
}
pub fn api_supported(api: &str) -> bool {
ai::dispatch::APIS.contains(&api)
}
pub fn process_transport() -> ReqwestTransport {
ReqwestTransport::for_env(&|key| std::env::var(key).ok(), None)
}
pub type SettingsReader = Arc<dyn Fn() -> config::settings::SettingsManager + Send + Sync>;
struct LiveTransport {
current: Mutex<(Option<std::time::Duration>, Arc<dyn Transport>)>,
}
pub struct Provider {
transport: Arc<dyn Transport>,
api_key: Option<String>,
router: Option<Arc<ai::claude_subscription::fallback::Router>>,
request: crate::request_settings::RequestSettings,
live: Option<SettingsReader>,
live_transport: Option<LiveTransport>,
}
impl Provider {
pub fn new() -> Self {
Provider {
transport: Arc::new(process_transport().with_idle_timeout(None)),
api_key: None,
router: None,
request: Default::default(),
live: None,
live_transport: None,
}
}
pub fn with_request_settings(mut self, request: crate::request_settings::RequestSettings) -> Self {
self.request = request;
self
}
pub fn with_live_settings(mut self, settings: SettingsReader) -> Self {
let idle = ai::http::http_idle_timeout(settings().settings().get("httpIdleTimeoutMs"));
let transport: Arc<dyn Transport> = Arc::new(process_transport().with_idle_timeout(idle));
self.transport = transport.clone();
self.live_transport = Some(LiveTransport {
current: Mutex::new((idle, transport)),
});
self.live = Some(settings);
self
}
pub fn with_transport(mut self, transport: Arc<dyn Transport>) -> Self {
self.transport = transport;
self.live_transport = None;
self
}
fn current(
&self,
) -> (
std::borrow::Cow<'_, crate::request_settings::RequestSettings>,
Arc<dyn Transport>,
) {
let Some(read) = &self.live else {
return (std::borrow::Cow::Borrowed(&self.request), self.transport.clone());
};
let settings = read();
let request = crate::request_settings::RequestSettings::from_manager(&settings);
let transport = match &self.live_transport {
Some(live) => {
let idle = ai::http::http_idle_timeout(settings.settings().get("httpIdleTimeoutMs"));
let mut current = live.current.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
if current.0 != idle {
*current = (idle, Arc::new(process_transport().with_idle_timeout(idle)));
}
current.1.clone()
}
None => self.transport.clone(),
};
(std::borrow::Cow::Owned(request), transport)
}
pub fn stream_options(&self) -> Option<Value> {
self.current().0.stream_options()
}
pub fn with_router(router: Arc<ai::claude_subscription::fallback::Router>, transport: Arc<dyn Transport>) -> Self {
Provider {
router: Some(router),
..Provider::new()
}
.with_transport(transport)
}
pub fn with_key(api_key: Option<String>) -> Self {
Provider {
api_key,
..Provider::new()
}
}
pub fn with_idle_timeout(idle: Option<std::time::Duration>) -> Self {
Provider {
transport: Arc::new(process_transport().with_idle_timeout(idle)),
..Provider::new()
}
}
}
impl Default for Provider {
fn default() -> Self {
Self::new()
}
}
impl StreamFn for Provider {
fn stream<'a>(
&'a self,
model: &'a Model,
context: &'a TranscriptContext,
options: &'a SimpleStreamOptions,
sink: &'a mut EventSink<'_>,
) -> BoxFuture<'a, AssistantMessage> {
Box::pin(async move {
if options.base.signal.as_ref().is_some_and(AbortSignal::aborted) {
let mut message = error_message(model, String::new());
message.stop_reason = StopReason::Aborted;
message.error_message = None;
return message;
}
let mut keyed = options.clone();
if keyed.base.api_key.is_none() && self.api_key.is_some() {
keyed.base.api_key = self.api_key.clone();
}
let (request, transport) = self.current();
if let Err(error) = request.apply(&mut keyed) {
return error_message(model, error);
}
let options = &keyed;
let (routed, prepared) = match ai::model_registry::prepare_request(model, options) {
Ok(prepared) => prepared,
Err(error) => return error_message(model, error),
};
let model = routed.as_ref().unwrap_or(model);
let options = prepared.as_ref().unwrap_or(options);
match &self.router {
Some(router) => {
ai::dispatch::stream_simple_routed(router, model, context, options, &*transport, sink).await
}
None => ai::dispatch::stream_simple(model, context, options, &*transport, sink).await,
}
.unwrap_or_else(|e| error_message(model, e))
})
}
}
pub fn error_message(model: &Model, error: String) -> AssistantMessage {
let mut message: AssistantMessage = serde_json::from_value(json!({
"content": [], "api": model.api, "provider": model.provider, "model": model.id,
"usage": ai::Usage::default(), "stopReason": "stop", "timestamp": now_ms(),
}))
.expect("an empty assistant message deserializes");
message.stop_reason = StopReason::Error;
message.error_message = Some(error);
message
}
async fn until_aborted<T>(work: impl Future<Output = T>, signal: &AbortSignal) -> Option<T> {
let mut work = pin!(work);
let mut cancelled = pin!(signal.cancelled());
std::future::poll_fn(|cx| {
if let Poll::Ready(value) = work.as_mut().poll(cx) {
return Poll::Ready(Some(value));
}
match cancelled.as_mut().poll(cx) {
Poll::Ready(()) => Poll::Ready(None),
Poll::Pending => Poll::Pending,
}
})
.await
}
const CELL_BUDGET: Duration = Duration::from_secs(24 * 60 * 60);
const DEFAULT_CELL_YIELD_AFTER: Duration = Duration::from_secs(10);
pub fn cell_yield_after(raw: Option<&str>) -> Option<Duration> {
let raw = raw.map(|raw| raw.trim().to_lowercase()).unwrap_or_default();
if raw.is_empty() {
return Some(DEFAULT_CELL_YIELD_AFTER);
}
if matches!(raw.as_str(), "off" | "none" | "false" | "no") {
return None;
}
match raw.parse::<f64>() {
Ok(seconds) if seconds.is_finite() && seconds > 0.0 => Some(Duration::from_secs_f64(seconds)),
Ok(_) => None,
Err(_) => Some(DEFAULT_CELL_YIELD_AFTER),
}
}
pub struct Rlm {
tool: Tool,
lanes: Lanes,
lane: String,
masker: Arc<OutputMasker>,
mask_secrets: Option<String>,
max_bytes: usize,
spill_dir: PathBuf,
hints: Option<Arc<kernel_apis::cell_hints::CellHints>>,
images: Arc<crate::view_images::ViewImages>,
host: Option<Arc<Host>>,
budget: Arc<std::sync::OnceLock<crate::budget_note::BudgetNote>>,
stats: Option<Arc<crate::session_stats::SessionStats>>,
reminders: Option<Arc<crate::context_reminder::ContextReminders>>,
wake: crate::wake::RootWake,
yield_after: Option<Duration>,
}
impl Rlm {
fn cell_budget(&self) -> Duration {
match self.yield_after {
Some(after) if self.wake.woken(&self.lane) => after,
_ => CELL_BUDGET,
}
}
pub(crate) fn with_wake(mut self, wake: crate::wake::RootWake) -> Rlm {
self.wake = wake;
self
}
pub(crate) fn with_budget_note(mut self, budget: Arc<std::sync::OnceLock<crate::budget_note::BudgetNote>>) -> Rlm {
self.budget = budget;
self
}
pub(crate) fn with_stats(mut self, stats: Arc<crate::session_stats::SessionStats>) -> Rlm {
self.stats = Some(stats);
self
}
pub(crate) fn with_context_reminders(mut self, reminders: Arc<crate::context_reminder::ContextReminders>) -> Rlm {
self.reminders = Some(reminders);
self
}
fn context_reminder(&self, text: &str, images: usize) -> Option<String> {
self.reminders.as_ref()?.reminder(&self.lane, text, images)
}
fn with_reminder(&self, text: String) -> String {
match self.context_reminder(&text, 0) {
Some(line) => format!("{text}\n{line}"),
None => text,
}
}
fn count_cell(&self, code: &str, failed: bool, masked: usize) {
if let Some(stats) = &self.stats {
stats.cell(&self.lane, code, failed, masked);
}
}
fn budget_line(&self) -> Option<String> {
self.budget.get().and_then(|note| note(&self.lane))
}
fn hint(&self, text: &str, ename: Option<&str>) -> Option<String> {
let outcome = kernel_apis::cell_hints::CellOutcome { text, ename };
self.hints
.as_ref()
.and_then(|hints| hints.end_cell(&self.lane, &outcome))
}
fn with_hint(&self, text: String, ename: Option<&str>) -> String {
match self.hint(&text, ename) {
Some(hint) => format!("{text}\n{hint}"),
None => text,
}
}
fn end_cell(&self) -> Option<String> {
let host = self.host.as_ref()?;
host.cell_ended(&self.lane);
host.take_pending(&self.lane)
}
fn cell_format(&self) -> CellFormat<'_> {
CellFormat {
masker: &self.masker,
mask_secrets: self.mask_secrets.as_deref(),
max_bytes: self.max_bytes,
spill_dir: Some(&self.spill_dir),
}
}
}
impl AgentTool for Rlm {
fn tool(&self) -> &Tool {
&self.tool
}
fn execute<'a>(
&'a self,
_id: &'a str,
args: Value,
signal: &'a AbortSignal,
_update: &'a ToolUpdate<'a>,
) -> BoxFuture<'a, Result<AgentToolResult, String>> {
Box::pin(self.run_cell(args, signal))
}
}
impl Rlm {
async fn run_cell(&self, args: Value, signal: &AbortSignal) -> Result<AgentToolResult, String> {
let note = Mutex::new(None);
let result = self.run_routed_cell(args, signal, ¬e).await;
let Some(note) = note.lock().unwrap_or_else(std::sync::PoisonError::into_inner).take() else {
return result;
};
match result {
Err(text) => Err(format!("{note}\n{text}")),
Ok(mut result) => {
match result.content.iter_mut().find_map(|part| match part {
UserContent::Text(text) => Some(text),
UserContent::Image(_) => None,
}) {
Some(text) => text.text = format!("{note}\n{}", text.text),
None => result.content.insert(0, text_block(note)),
}
Ok(result)
}
}
}
async fn run_routed_cell(
&self,
args: Value,
signal: &AbortSignal,
note: &Mutex<Option<String>>,
) -> Result<AgentToolResult, String> {
{
let code = args["code"].as_str().ok_or("rlm needs a `code` string")?.to_string();
if let Some(hints) = &self.hints {
if let Some(refusal) = hints.refusal(&self.lane, &code) {
return Err(refusal);
}
hints.begin_cell(&self.lane, &code);
}
self.images.begin(&self.lane);
if let Some(host) = &self.host {
host.cell_started(&self.lane);
}
let (lanes, lane, source) = (self.lanes.clone(), self.lane.clone(), code.clone());
let started = tokio::task::spawn_blocking(move || lanes.start_routed(&lane, &source))
.await
.map_err(|e| e.to_string())
.and_then(|started| started);
let started = match started {
Ok(started) => {
*note.lock().unwrap_or_else(std::sync::PoisonError::into_inner) = started.note.clone();
Ok(started.cell)
}
Err(error) => Err(error),
};
let waited = match &started {
Ok(id) => {
let (lanes, id) = (self.lanes.clone(), id.clone());
let budget = self.cell_budget();
Some(tokio::task::spawn_blocking(move || lanes.wait(&id, budget)))
}
Err(_) => None,
};
let outcome: Result<Result<CellOutcome, String>, String> = match (started, waited) {
(Ok(id), Some(mut cell)) => match until_aborted(&mut cell, signal).await {
Some(done) => done.map_err(|e| e.to_string()),
None => {
let _ = self.lanes.cancel(&id, ABORT_REQUESTED);
let _ = cell.await;
self.count_cell(&code, true, 0);
let findings = self.end_cell();
self.images.take(&self.lane);
self.images.take_display(&self.lane);
return Err(match findings {
Some(findings) => format!("{ABORT_REQUESTED}\n{findings}"),
None => ABORT_REQUESTED.into(),
});
}
},
(Err(error), _) => Ok(Err(error)),
(Ok(_), None) => Err("cell vanished".into()),
};
let has_result = matches!(outcome, Ok(Ok(CellOutcome::Done(Ok(_)))));
if !has_result {
let left_running = matches!(outcome, Ok(Ok(CellOutcome::Running { .. })));
self.count_cell(&code, !left_running, 0);
}
let findings = self.end_cell();
let with_findings = |text: String| match &findings {
Some(findings) => format!("{text}\n{findings}"),
None => text,
};
let outcome = outcome.map_err(|e| self.with_reminder(with_findings(e.to_string())));
let images = self.images.take(&self.lane);
let shown = self.images.take_display(&self.lane);
let outcome = outcome?.map_err(|e| self.with_reminder(with_findings(e.to_string())))?;
if signal.aborted() {
if has_result {
self.count_cell(&code, false, 0);
}
return Err(with_findings(ABORT_REQUESTED.into()));
}
let result = match outcome {
CellOutcome::Done(result) => {
result.map_err(|e| self.with_reminder(with_findings(self.with_hint(e, Some("Error")))))?
}
CellOutcome::Running { cell, parked } => {
if !parked {
self.lanes.detach(&cell)?;
}
return Ok(AgentToolResult {
content: vec![text_block(with_findings(match parked {
true => detached_note(&cell, self.wake.woken(&self.lane)),
false => yielded_note(&cell, self.cell_budget()),
}))],
details: json!({}),
usage: None,
terminate: None,
});
}
};
let output = cell_output(&result, &self.cell_format());
self.count_cell(
&code,
output.is_err(),
output
.as_ref()
.map_or_else(|failure| failure.masked, |output| output.masked),
);
let output = output.map_err(|failure| {
self.with_reminder(with_findings(self.with_hint(failure.message, Some(&failure.ename))))
})?;
let hint = self.hint(&output.text, None);
let text = with_findings(crate::view_images::with_display_lines(
match output.text.is_empty() {
true => "(no result)".to_string(),
false => output.text,
},
&shown,
));
let text = match hint {
Some(hint) => format!("{text}\n{hint}"),
None => text,
};
let text = match self.budget_line() {
Some(line) => format!("{text}\n{line}"),
None => text,
};
let image_count = images.as_ref().map_or(0, |i| i.images.len());
let text = match self.context_reminder(&text, image_count) {
Some(line) => format!("{text}\n{line}"),
None => text,
};
Ok(AgentToolResult {
content: crate::view_images::cell_content(images.as_ref(), text),
details: crate::view_images::with_display_details(
self.host.as_ref().map_or_else(
|| json!({}),
|host| {
let mask = |text: &str| self.masker.mask_counted(text, self.mask_secrets.as_deref()).0;
crate::cell_file_changes::details(host, &self.lane, &mask)
},
),
&shown,
),
usage: None,
terminate: None,
})
}
}
}
pub struct Lane {
pub host: Arc<Host>,
pub stack: Arc<Stack>,
pub tool: Arc<Rlm>,
pub events: Arc<RuntimeEvents>,
}
impl Lane {
pub fn open(runtime: &Runtime, model: &Model, api_key: Option<String>, session_id: &str) -> Result<Lane, String> {
Lane::open_with(runtime, model, api_key, session_id, None)
}
pub fn open_with(
runtime: &Runtime,
model: &Model,
api_key: Option<String>,
session_id: &str,
subagents: Option<crate::compose::SubagentHost>,
) -> Result<Lane, String> {
let stack = runtime.stack_with(model, api_key, session_id, subagents)?;
let tool = Arc::new(stack.rlm(MAIN_LANE)?);
Ok(Lane {
host: stack.host.clone(),
events: stack.events.clone(),
tool,
stack,
})
}
pub fn system_message(&self, system: &str) -> Option<Message> {
ai::transcript::create_initial_system_message(Some(system), Some(std::slice::from_ref(&self.tool.tool)))
.map(Message::System)
}
pub fn tools(&self) -> Vec<Arc<dyn AgentTool>> {
vec![self.tool.clone() as Arc<dyn AgentTool>]
}
pub fn kernel(&self) -> Option<Arc<Kernel>> {
self.stack.lanes.kernel(MAIN_LANE)
}
pub fn shutdown(&self) {
self.stack.close();
}
pub fn hand_over(&self) {
self.stack.hand_over();
}
}
pub fn detached_note(cell: &str, woken: bool) -> String {
if woken {
format!(
"Cell {cell} is still running in the background (it waits on the host); its end arrives as a <runtime_event kind=\"cell_done\" id=\"{cell}\">. Do other work or end your turn."
)
} else {
format!(
"Cell {cell} is still running in the background (it waits on the host); its end is reported as a <runtime_event kind=\"cell_done\" id=\"{cell}\"> with a later rlm result, and nothing wakes you after you reply. Do other work meanwhile; `await rlm.cells()` lists it while it runs and `await rlm.cancel(\"{cell}\")` stops it."
)
}
}
pub fn yielded_note(cell: &str, after: Duration) -> String {
format!(
"Cell {cell} was still running after {} s, so it continues in the background; its end (with its result) arrives as a <runtime_event kind=\"cell_done\" id=\"{cell}\">. Do other work or end your turn. Its variables are not in your next cell until it ends (that cell runs in a side lane); `await rlm.cancel(\"{cell}\")` stops it.",
after.as_secs_f64()
)
}
pub(crate) fn rlm_over(
config: &Config,
lanes: Lanes,
lane: &str,
spill_dir: PathBuf,
hints: Option<Arc<kernel_apis::cell_hints::CellHints>>,
images: Arc<crate::view_images::ViewImages>,
host: Option<Arc<Host>>,
) -> Rlm {
let mut tool = rlm_tool();
let listing = kernel_apis::CodeSkills::new(kernel_apis::CodeSkillsOptions::new(
&config.skills_dir,
&config.runtime_path,
))
.describe();
if !listing.is_empty() {
tool.description = format!("{}\n{listing}", tool.description);
}
Rlm {
tool,
lanes,
lane: lane.to_string(),
masker: config.masker.clone(),
mask_secrets: config.mask_secrets.clone(),
max_bytes: kernel::rlm_output_budget(config.output_bytes.as_deref()) as usize,
spill_dir,
hints,
images,
host,
budget: Arc::new(std::sync::OnceLock::new()),
stats: None,
reminders: None,
wake: crate::wake::RootWake::default(),
yield_after: cell_yield_after(config.cell_yield_after.as_deref()),
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn cell_yield_after_defaults_to_ten_seconds_and_can_be_turned_off() {
assert_eq!(cell_yield_after(None), Some(Duration::from_secs(10)));
assert_eq!(cell_yield_after(Some(" ")), Some(Duration::from_secs(10)));
assert_eq!(cell_yield_after(Some("2.5")), Some(Duration::from_millis(2500)));
assert_eq!(cell_yield_after(Some("junk")), Some(Duration::from_secs(10)));
for off in ["0", "off", "OFF", "none", "-1", "inf", "NaN"] {
assert_eq!(cell_yield_after(Some(off)), None, "{off}");
}
}
#[test]
fn a_yielded_cell_says_its_end_arrives_as_an_event() {
let note = yielded_note("cell-7", Duration::from_secs(10));
assert!(note.starts_with("Cell cell-7 was still running after 10 s"));
assert!(note.contains("<runtime_event kind=\"cell_done\" id=\"cell-7\">"));
assert!(note.contains("end your turn"));
}
}