Struct CapabilityFilter 

pub struct CapabilityFilter<T: Filterable> { /* private fields */ }

A filter for capabilities based on session state.

Use this to control which tools, resources, or prompts are visible to each session.

Example

use tower_mcp::{CapabilityFilter, DenialBehavior, Tool, Filterable};

// Filter that only shows tools starting with "public_"
let filter = CapabilityFilter::new(|_session, tool: &Tool| {
    tool.name().starts_with("public_")
});

// Filter with custom denial behavior
let filter_with_401 = CapabilityFilter::new(|_session, tool: &Tool| {
    tool.name() != "admin"
}).denial_behavior(DenialBehavior::Unauthorized);

Implementations

impl<T: Filterable> CapabilityFilter<T>

pub fn new<F>(filter: F) -> Self

where F: Fn(&SessionState, &T) -> bool + Send + Sync + 'static,

Create a new capability filter with the given predicate.

The predicate receives the session state and capability, and returns true if the capability should be visible to the session.

Example

use tower_mcp::{CapabilityFilter, Tool, Filterable};

let filter = CapabilityFilter::new(|_session, tool: &Tool| {
    // Check session extensions for auth claims
    // session.extensions().get::<UserClaims>()...
    tool.name() != "admin_only"
});

pub fn denial_behavior(self, behavior: DenialBehavior) -> Self

Set the behavior when a filtered capability is accessed directly.

Default is DenialBehavior::NotFound.

Example

use tower_mcp::{CapabilityFilter, DenialBehavior, Tool, Filterable};

let filter = CapabilityFilter::new(|_, tool: &Tool| tool.name() != "secret")
    .denial_behavior(DenialBehavior::Unauthorized);

pub fn is_visible(&self, session: &SessionState, capability: &T) -> bool

Check if the given capability is visible to the session.

pub fn denial_error(&self, name: &str) -> Error

Get the error to return when access is denied.

impl CapabilityFilter<Tool>

pub fn write_guard<F>(is_write_allowed: F) -> Self

where F: Fn(&SessionState) -> bool + Send + Sync + 'static,

Create a filter that blocks non-read-only tools when the predicate returns false.

Read-only tools (those with read_only_hint = true) are always allowed. Non-read-only tools are only allowed when is_write_allowed returns true for the current session.

This provides annotation-based write protection without requiring manual guards in every write tool handler.

Example

use tower_mcp::{CapabilityFilter, Tool};

// Block all write tools unconditionally
let filter = CapabilityFilter::<Tool>::write_guard(|_session| false);

// Allow writes based on session state
// let filter = CapabilityFilter::<Tool>::write_guard(|session| {
//     session.get::<WriteEnabled>().is_some()
// });

Trait Implementations

impl<T: Filterable> Clone for CapabilityFilter<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Filterable> Debug for CapabilityFilter<T>

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

Formats the value using the given formatter.