use infinity_agent_core::ThreadId;
use std::collections::HashMap;
use std::path::{Path, PathBuf};
use std::rc::Rc;
use std::sync::Arc;
use async_trait::async_trait;
use infinity_agent_core::system::local::ChannelSender;
use infinity_agent_core::system::{ThreadConfig, ThreadConfigSource};
use infinity_agent_core::tools::Tool;
use infinity_agent_core::tools::config::ToolSetConfig;
use infinity_agent_core::tools::rap_tool::{
RapInvocationParams, RapToolDescriptor, invoke_rap_tool,
};
use infinity_protocol::DaemonMessage;
use rap_client::http::{HttpClient, SimpleHttpClient};
use rap_client::notifier::RapNotifier;
use rap_protocol::ToolsetManifest;
use crate::memory_store::PersistentConversationStore;
use crate::session::SessionStoreHandle;
use crate::session::observer::SubscriberMap;
use crate::{config, mcp_proxy, set_title_tool};
type BoxError = Box<dyn std::error::Error + Send + Sync>;
enum ServerSpec {
Command { command: String, cwd: PathBuf },
Mcp {
name: String,
command: Vec<String>,
env: HashMap<String, String>,
},
HttpMcp {
name: String,
url: String,
headers: HashMap<String, String>,
},
External { url: String },
}
#[expect(
clippy::large_enum_variant,
reason = "at most a handful of servers exist per session"
)]
enum ServerState {
Down,
Up {
base_url: String,
manifest: ToolsetManifest,
child: Option<tokio::process::Child>,
#[expect(dead_code, reason = "held for ownership; never polled")]
task: Option<tokio::task::JoinHandle<()>>,
},
}
pub struct ManagedRapServer {
pub config_id: Option<String>,
session_id: ThreadId,
spec: ServerSpec,
state: tokio::sync::Mutex<ServerState>,
}
impl ManagedRapServer {
fn new(session_id: ThreadId, config_id: Option<String>, spec: ServerSpec) -> Self {
Self {
config_id,
session_id,
spec,
state: tokio::sync::Mutex::new(ServerState::Down),
}
}
pub async fn current_base_url(&self) -> Option<String> {
match &*self.state.lock().await {
ServerState::Up { base_url, .. } => Some(base_url.clone()),
ServerState::Down => None,
}
}
pub async fn ensure_up(&self) -> Result<ToolsetManifest, BoxError> {
let mut state = self.state.lock().await;
if let ServerState::Up { manifest, .. } = &*state {
return Ok(manifest.clone());
}
let (base_url, mut child, task) = match &self.spec {
ServerSpec::Command { command, cwd } => {
tracing::info!(
"Booting RAP server for session {}: {command}",
self.session_id
);
let (child, port) = spawn_rap_server(command, cwd).await?;
(format!("http://127.0.0.1:{port}"), Some(child), None)
}
ServerSpec::Mcp { name, command, env } => {
let (port, task) =
mcp_proxy::start_mcp_proxy(name.clone(), command.clone(), env.clone()).await?;
(format!("http://127.0.0.1:{port}"), None, Some(task))
}
ServerSpec::HttpMcp { name, url, headers } => {
let (port, task) =
mcp_proxy::start_http_mcp_proxy(name.clone(), url.clone(), headers.clone())
.await?;
(format!("http://127.0.0.1:{port}"), None, Some(task))
}
ServerSpec::External { url } => (url.clone(), None, None),
};
match fetch_manifest(&base_url).await {
Ok(manifest) => {
*state = ServerState::Up {
base_url,
manifest: manifest.clone(),
child,
task,
};
Ok(manifest)
}
Err(e) => {
if let Some(child) = &mut child {
let _ = child.start_kill();
let _ = child.wait().await;
}
if let Some(task) = task {
task.abort();
}
Err(e)
}
}
}
pub async fn invoke_endpoint(&self) -> Result<String, BoxError> {
Ok(self.ensure_up().await?.endpoint)
}
pub async fn shutdown(&self) {
let mut state = self.state.lock().await;
match &self.spec {
ServerSpec::Command { .. } => {
if let ServerState::Up { child, .. } = &mut *state
&& let Some(mut child) = child.take()
{
#[cfg(unix)]
{
use nix::sys::signal::{self, Signal};
use nix::unistd::Pid;
if let Some(id) = child.id() {
let _ = signal::kill(Pid::from_raw(-(id as i32)), Signal::SIGINT);
}
}
#[cfg(not(unix))]
{
let _ = child.start_kill();
}
let _ = child.wait().await;
tracing::info!("Stopped RAP server for session {}", self.session_id);
}
*state = ServerState::Down;
}
ServerSpec::Mcp { .. } | ServerSpec::HttpMcp { .. } | ServerSpec::External { .. } => {}
}
}
}
async fn fetch_manifest(base_url: &str) -> Result<ToolsetManifest, BoxError> {
let http = SimpleHttpClient::new();
let url = format!("{}/.well-known/rap-toolset", base_url.trim_end_matches('/'));
let (status, body) = http
.get(&url)
.await
.map_err(|e| format!("failed to fetch toolset manifest from {url}: {e}"))?;
if !(200..300).contains(&status) {
return Err(format!("toolset manifest fetch from {url} returned status {status}").into());
}
let manifest: ToolsetManifest = serde_json::from_slice(&body)
.map_err(|e| format!("invalid toolset manifest from {url}: {e}"))?;
Ok(manifest)
}
pub struct MigrationServer {
pub config_id: Option<String>,
pub url: String,
pub port: Option<u16>,
pub needs_migration: bool,
_server: ManagedRapServer,
}
pub async fn boot_migration_servers(
cwd: &Path,
user_config_path: Option<&Path>,
) -> Result<Vec<MigrationServer>, BoxError> {
let (_source_info, specs) =
collect_server_specs(&ThreadId::from("migration"), cwd, user_config_path)?;
let mut servers = Vec::new();
for server in specs {
let manifest = match server.ensure_up().await {
Ok(m) => m,
Err(e) => {
tracing::warn!("failed to boot RAP server for migration: {e}");
continue;
}
};
let url = server
.current_base_url()
.await
.expect("bug: server is up right after ensure_up");
let port = if matches!(server.spec, ServerSpec::External { .. }) {
None
} else {
url.rsplit_once(':')
.and_then(|(_, p)| p.trim_end_matches('/').parse().ok())
};
servers.push(MigrationServer {
config_id: server.config_id.clone(),
url,
port,
needs_migration: manifest.needs_migration,
_server: server,
});
}
Ok(servers)
}
pub fn migration_server_ports(servers: &[MigrationServer]) -> HashMap<String, u16> {
servers
.iter()
.filter(|s| s.needs_migration)
.filter_map(|s| Some((s.config_id.clone()?, s.port?)))
.collect()
}
async fn spawn_rap_server(
command: &str,
cwd: &Path,
) -> Result<(tokio::process::Child, u16), BoxError> {
use infinity_agent_core::tools::config::CommandServerReady;
use std::process::Stdio;
use tokio::io::AsyncBufReadExt;
let working_dir = cwd.join(".infinity");
std::fs::create_dir_all(&working_dir).ok();
let mut child = tokio::process::Command::new("sh")
.args(["-c", command])
.env("RAP_EMBEDDED", "1")
.current_dir(&working_dir)
.process_group(0)
.stdout(Stdio::piped())
.stderr(Stdio::null())
.kill_on_drop(true)
.spawn()
.map_err(|e| format!("failed to spawn '{command}': {e}"))?;
let stdout = child.stdout.take().ok_or("no stdout")?;
let mut reader = tokio::io::BufReader::new(stdout);
let mut line = String::new();
reader
.read_line(&mut line)
.await
.map_err(|e| format!("failed to read startup line: {e}"))?;
if line.is_empty() {
let _ = child.kill().await;
return Err("server exited before emitting port".into());
}
let ready: CommandServerReady = serde_json::from_str(line.trim())
.map_err(|e| format!("invalid startup JSON: {e} (got: {line})"))?;
Ok((child, ready.port))
}
pub struct ManagedRapTool {
pub descriptor: RapToolDescriptor,
pub server: Arc<ManagedRapServer>,
pub http_client: SimpleHttpClient,
}
#[async_trait]
impl Tool<ChannelSender> for ManagedRapTool {
fn name(&self) -> &str {
&self.descriptor.name
}
fn description(&self) -> &str {
&self.descriptor.description
}
fn parameters(&self) -> serde_json::Value {
self.descriptor.parameters.clone()
}
fn display_script(&self) -> Option<&str> {
self.descriptor.display_script.as_deref()
}
async fn execute(
&self,
args: serde_json::Value,
id: rap_protocol::ToolCallId,
call_id: Option<rap_protocol::ProviderCallId>,
context: &infinity_agent_core::tools::ToolContext<ChannelSender>,
) -> Result<(), BoxError> {
let endpoint = self.server.invoke_endpoint().await?;
invoke_rap_tool(
&self.http_client,
RapInvocationParams {
endpoint: &endpoint,
operation: &self.descriptor.name,
arguments: args,
id,
call_id,
callback_url: None,
},
context,
)
.await
}
}
struct SessionToolset {
tools: Vec<Rc<dyn Tool<ChannelSender>>>,
servers: Vec<Arc<ManagedRapServer>>,
extra_system_prompt: String,
}
#[derive(Clone)]
pub struct SessionRapManager {
toolsets: Rc<tokio::sync::Mutex<HashMap<ThreadId, Rc<SessionToolset>>>>,
conversation_store: PersistentConversationStore,
session_store: SessionStoreHandle,
user_rap_config: Option<PathBuf>,
subscriber_map: SubscriberMap,
shutdown_log: Rc<std::cell::RefCell<Vec<ThreadId>>>,
}
impl SessionRapManager {
pub fn new(
conversation_store: PersistentConversationStore,
session_store: SessionStoreHandle,
user_rap_config: Option<PathBuf>,
subscriber_map: SubscriberMap,
) -> Self {
Self {
toolsets: Rc::new(tokio::sync::Mutex::new(HashMap::new())),
conversation_store,
session_store,
user_rap_config,
subscriber_map,
shutdown_log: Rc::new(std::cell::RefCell::new(Vec::new())),
}
}
fn info(&self, session_id: &ThreadId<str>, text: String) {
let msg = DaemonMessage::Info {
thread_id: Some(infinity_protocol::ThreadRef::local(session_id.to_owned())),
text,
};
crate::session::observer::broadcast_to_thread(&self.subscriber_map, session_id, &msg, None);
}
async fn get_or_init(
&self,
session_id: &ThreadId<str>,
) -> Result<Rc<SessionToolset>, BoxError> {
let mut toolsets = self.toolsets.lock().await;
if let Some(ts) = toolsets.get(session_id) {
return Ok(ts.clone());
}
let cwd = {
let store = self.session_store.lock().await;
store.get_cwd(session_id).clone()
};
let mut servers: Vec<Arc<ManagedRapServer>> = Vec::new();
match collect_server_specs(session_id, &cwd, self.user_rap_config.as_deref()) {
Ok((source_info, specs)) => {
self.info(session_id, source_info);
for server in specs {
servers.push(Arc::new(server));
}
}
Err(e) => {
self.info(
session_id,
format!("Warning: failed to read RAP config: {e}"),
);
}
}
let http_client = SimpleHttpClient::new();
let mut tools: Vec<Rc<dyn Tool<ChannelSender>>> = Vec::new();
let mut tool_count = 0usize;
for server in &servers {
match server.ensure_up().await {
Ok(manifest) => {
for def in manifest.tools {
tool_count += 1;
tools.push(Rc::new(ManagedRapTool {
descriptor: def.into(),
server: server.clone(),
http_client: http_client.clone(),
}));
}
}
Err(e) => {
self.info(
session_id,
format!("Warning: failed to start RAP server: {e}"),
);
}
}
}
if tool_count > 0 {
self.info(session_id, format!("Loaded {tool_count} RAP tool(s)"));
}
tools.push(Rc::new(set_title_tool::SetTitleTool {
conversation_store: self.conversation_store.clone(),
}));
let extra_system_prompt = format!(
"The user's current working directory is: {cwd:?}\n\n\
Use the `set_title` tool to give the current thread a short, descriptive title. \
Set it once at the start when the user's intent becomes clear, and update it only \
when the overall scope of work changes significantly. Do not call it repeatedly \
for minor follow-ups within the same task."
);
let toolset = Rc::new(SessionToolset {
tools,
servers,
extra_system_prompt,
});
toolsets.insert(session_id.to_owned(), toolset.clone());
Ok(toolset)
}
pub async fn shutdown_session(&self, session_id: &ThreadId<str>) {
let toolset = {
let toolsets = self.toolsets.lock().await;
toolsets.get(session_id).cloned()
};
if let Some(toolset) = toolset {
for server in &toolset.servers {
server.shutdown().await;
}
}
self.shutdown_log.borrow_mut().push(session_id.to_owned());
}
pub async fn evict_session(&self, session_id: &ThreadId<str>) {
self.shutdown_session(session_id).await;
self.toolsets.lock().await.remove(session_id);
}
pub async fn shutdown_all(&self) {
let session_ids: Vec<ThreadId> = self.toolsets.lock().await.keys().cloned().collect();
for session_id in session_ids {
self.shutdown_session(&session_id).await;
}
}
pub fn times_shut_down(&self, session_id: &ThreadId<str>) -> usize {
self.shutdown_log
.borrow()
.iter()
.filter(|s| *s == session_id)
.count()
}
}
#[async_trait(?Send)]
impl ThreadConfigSource<ChannelSender, SimpleHttpClient> for SessionRapManager {
async fn resolve(
&self,
thread_id: &ThreadId<str>,
) -> Result<ThreadConfig<ChannelSender, SimpleHttpClient>, BoxError> {
let session_id = self.conversation_store.get_root_thread_id(thread_id);
let toolset = self.get_or_init(&session_id).await?;
let mut urls = Vec::new();
for server in &toolset.servers {
if let Some(url) = server.current_base_url().await {
urls.push(url);
}
}
Ok(ThreadConfig {
tools: toolset.tools.clone(),
extra_system_prompt: Some(toolset.extra_system_prompt.clone()),
rap_notifier: Some(RapNotifier::new(urls, SimpleHttpClient::new())),
})
}
}
fn collect_server_specs(
session_id: &ThreadId<str>,
cwd: &Path,
user_config_path: Option<&Path>,
) -> Result<(String, Vec<ManagedRapServer>), BoxError> {
let (source_info, merged) = config::load_merged_rap_config(cwd, user_config_path)?;
let Some(merged) = merged else {
return Ok((source_info, Vec::new()));
};
let mut servers = Vec::new();
for entry in merged.tool_sets {
let (id, spec) = match entry {
ToolSetConfig::ToolsetServer { server_url, id } => {
(id, ServerSpec::External { url: server_url })
}
ToolSetConfig::ToolsetCommand { command, id, .. } => (
id,
ServerSpec::Command {
command,
cwd: cwd.to_path_buf(),
},
),
ToolSetConfig::McpServer {
name,
command,
env,
id,
} => (id, ServerSpec::Mcp { name, command, env }),
ToolSetConfig::HttpMcpServer {
name,
url,
headers,
id,
} => (id, ServerSpec::HttpMcp { name, url, headers }),
};
servers.push(ManagedRapServer::new(session_id.to_owned(), id, spec));
}
Ok((source_info, servers))
}