Struct ToolRouter 

#[non_exhaustive]
pub struct ToolRouter<S> {
    pub map: HashMap<Cow<'static, str>, ToolRoute<S>>,
    pub transparent_when_not_found: bool,
    disabled: HashSet<Cow<'static, str>>,
    notifier: Option<Arc<dyn Fn() + Sync + Send>>,
}

Available on crate feature mcp and non-WebAssembly only.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

map: HashMap<Cow<'static, str>, ToolRoute<S>>

transparent_when_not_found: bool

disabled: HashSet<Cow<'static, str>>

notifier: Option<Arc<dyn Fn() + Sync + Send>>

Implementations

impl<S> ToolRouter<S>

where S: MaybeSend + 'static,

pub fn new() -> ToolRouter<S>

pub fn with_route<R, A>(self, route: R) -> ToolRouter<S>

where R: IntoToolRoute<S, A>,

pub fn with_sync_tool<T>(self) -> ToolRouter<S>

where T: SyncTool<S> + 'static,

Add a tool that implements [SyncTool]

pub fn with_async_tool<T>(self) -> ToolRouter<S>

where T: AsyncTool<S> + 'static,

Add a tool that implements [AsyncTool]

pub fn add_route(&mut self, item: ToolRoute<S>)

pub fn merge(&mut self, other: ToolRouter<S>)

pub fn remove_route(&mut self, name: &str)

Remove a tool route from the router.

The disabled state is preserved: if the name was in the disabled set, it stays there so that a future add_route or merge with the same name will inherit the disabled state. To also clear the disabled marker, call enable_route afterwards.

pub fn has_route(&self, name: &str) -> bool

Returns true if the tool is registered and not currently disabled.

pub fn disable_route(&mut self, name: impl Into<Cow<'static, str>>) -> bool

Disable a tool by name. Hidden from list_all, get, rejected by call. Re-enable with enable_route.

Returns true if the name was newly added to the disabled set. The name is recorded even if no matching route exists yet, so routes added later will inherit the disabled state.

pub fn enable_route(&mut self, name: &str) -> bool

Re-enable a previously disabled tool. Returns true if the name was in the disabled set.

pub fn is_disabled(&self, name: &str) -> bool

Returns true if the tool exists in the router and is currently disabled. Returns false if the tool does not exist or if the name was pre-disabled without a matching route.

pub fn with_disabled(self, name: impl Into<Cow<'static, str>>) -> ToolRouter<S>

Builder-style variant of disable_route.

The name is recorded even if no matching route has been added yet, so it can be called before with_route in a builder chain.

pub fn set_notifier(&mut self, f: impl Fn() + Send + Sync + 'static)

Install a callback invoked when the visible tool list changes.

pub fn clear_notifier(&mut self)

pub fn bind_peer_notifier(&mut self, peer: &Peer<RoleServer>)

Install a notifier that sends notifications/tools/list_changed via the given peer.

pub async fn call( &self, context: ToolCallContext<'_, S>, ) -> Result<CallToolResponse, ErrorData>

pub fn list_all(&self) -> Vec<Tool>

pub fn get(&self, name: &str) -> Option<&Tool>

Get a tool definition by name.

Returns the tool if found and enabled, or None if the tool does not exist or is disabled.

Trait Implementations

impl<S> Add for ToolRouter<S>

where S: MaybeSend + 'static,

type Output = ToolRouter<S>

The resulting type after applying the + operator.

fn add(self, other: ToolRouter<S>) -> <ToolRouter<S> as Add>::Output

Performs the + operation.

impl<S> AddAssign for ToolRouter<S>

where S: MaybeSend + 'static,

fn add_assign(&mut self, other: ToolRouter<S>)

Performs the += operation.

impl<S> Clone for ToolRouter<S>

fn clone(&self) -> ToolRouter<S>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<S> Debug for ToolRouter<S>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<S> Default for ToolRouter<S>

fn default() -> ToolRouter<S>

Returns the “default value” for a type.

impl<S> IntoIterator for ToolRouter<S>

type Item = ToolRoute<S>

The type of the elements being iterated over.

type IntoIter = IntoValues<Cow<'static, str>, ToolRoute<S>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <ToolRouter<S> as IntoIterator>::IntoIter

Creates an iterator from a value.