use std::sync::{Arc, OnceLock};
use arc_swap::ArcSwap;
use rmcp::handler::server::tool::ToolRoute;
type Notifier<S> = Box<dyn Fn(Arc<Vec<ToolRoute<S>>>) + Send + Sync>;
pub struct Tools<S> {
routes: ArcSwap<Vec<ToolRoute<S>>>,
notifier: OnceLock<Notifier<S>>,
}
impl<S> std::fmt::Debug for Tools<S> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("Tools")
.field("routes", &self.routes.load().len())
.field("notifier", &self.notifier.get().is_some())
.finish()
}
}
impl<S> Tools<S> {
pub fn new(routes: impl IntoIterator<Item = ToolRoute<S>>) -> Arc<Self> {
Arc::new(Self {
routes: ArcSwap::from_pointee(routes.into_iter().collect()),
notifier: OnceLock::new(),
})
}
pub fn replace(&self, routes: impl IntoIterator<Item = ToolRoute<S>>) {
let routes = Arc::new(routes.into_iter().collect::<Vec<_>>());
self.routes.store(Arc::clone(&routes));
if let Some(notifier) = self.notifier.get() {
notifier(routes);
}
}
pub fn routes(&self) -> Arc<Vec<ToolRoute<S>>> {
self.routes.load_full()
}
pub(crate) fn on_replace(
&self,
notifier: impl Fn(Arc<Vec<ToolRoute<S>>>) + Send + Sync + 'static,
) -> bool {
self.notifier.set(Box::new(notifier)).is_ok()
}
}
#[cfg(test)]
mod tests {
use super::*;
use rmcp::model::{CallToolResult, Tool};
use std::sync::atomic::{AtomicUsize, Ordering};
struct Server;
fn route(name: &'static str) -> ToolRoute<Server> {
let schema: Arc<rmcp::model::JsonObject> = Arc::new(Default::default());
ToolRoute::new_dyn(Tool::new(name, "", schema), |_context| {
Box::pin(async { Ok(CallToolResult::success(vec![])) })
})
}
fn names(tools: &Tools<Server>) -> Vec<String> {
tools
.routes()
.iter()
.map(|route| route.attr.name.to_string())
.collect()
}
#[test]
fn replace_swaps_the_served_set() {
let tools = Tools::new([route("alpha"), route("beta")]);
assert_eq!(names(&tools), ["alpha", "beta"]);
tools.replace([route("gamma")]);
assert_eq!(names(&tools), ["gamma"], "wholesale, not merged");
tools.replace([]);
assert!(names(&tools).is_empty(), "and emptying is allowed");
}
#[test]
fn the_notifier_receives_the_new_list_once_per_replace() {
let tools = Tools::new([route("alpha")]);
let calls = Arc::new(AtomicUsize::new(0));
let seen = Arc::new(ArcSwap::from_pointee(Vec::<String>::new()));
let (calls_in, seen_in) = (calls.clone(), seen.clone());
assert!(tools.on_replace(move |routes| {
calls_in.fetch_add(1, Ordering::SeqCst);
seen_in.store(Arc::new(
routes.iter().map(|r| r.attr.name.to_string()).collect(),
));
}));
tools.replace([route("beta"), route("gamma")]);
assert_eq!(calls.load(Ordering::SeqCst), 1);
assert_eq!(seen.load().as_slice(), ["beta", "gamma"]);
tools.replace([route("delta")]);
assert_eq!(calls.load(Ordering::SeqCst), 2);
assert_eq!(seen.load().as_slice(), ["delta"]);
}
#[test]
fn the_new_routes_are_readable_from_inside_the_notifier() {
let tools = Tools::new([route("alpha")]);
let observed = Arc::new(ArcSwap::from_pointee(Vec::<String>::new()));
let weak = Arc::downgrade(&tools);
let observed_in = observed.clone();
tools.on_replace(move |_new| {
let Some(live) = weak.upgrade() else { return };
observed_in.store(Arc::new(
live.routes()
.iter()
.map(|r| r.attr.name.to_string())
.collect(),
));
});
tools.replace([route("beta")]);
assert_eq!(
observed.load().as_slice(),
["beta"],
"the swap is visible before the callback runs",
);
}
#[test]
fn replacing_without_a_notifier_is_fine() {
let tools = Tools::new([route("alpha")]);
tools.replace([route("beta")]);
assert_eq!(names(&tools), ["beta"]);
}
#[test]
fn the_notifier_can_only_be_claimed_once() {
let tools: Arc<Tools<Server>> = Tools::new([]);
assert!(tools.on_replace(|_| {}));
assert!(!tools.on_replace(|_| {}));
}
}