Struct GuardLayer 

pub struct GuardLayer<G> { /* private fields */ }

A tower Layer that applies a guard function before the inner service.

Guards run before the tool handler and can short-circuit with an error message. Use via ToolBuilderWithHandler::guard or Tool::with_guard rather than constructing directly.

Example

use tower_mcp::{ToolBuilder, ToolRequest, CallToolResult};
use schemars::JsonSchema;
use serde::Deserialize;

#[derive(Debug, Deserialize, JsonSchema)]
struct DeleteInput { id: String, confirm: bool }

let tool = ToolBuilder::new("delete")
    .description("Delete a record")
    .handler(|input: DeleteInput| async move {
        Ok(CallToolResult::text(format!("deleted {}", input.id)))
    })
    .guard(|req: &ToolRequest| {
        let confirm = req.args.get("confirm").and_then(|v| v.as_bool()).unwrap_or(false);
        if !confirm {
            return Err("Must set confirm=true to delete".to_string());
        }
        Ok(())
    })
    .build();

Implementations

impl<G> GuardLayer<G>

pub fn new(guard: G) -> Self

Create a new guard layer from a closure.

The closure receives a &ToolRequest and returns Ok(()) to proceed or Err(String) to reject with an error message.

Trait Implementations

impl<G: Clone> Clone for GuardLayer<G>

fn clone(&self) -> GuardLayer<G>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<G, S> Layer<S> for GuardLayer<G>

where G: Clone,

type Service = GuardService<G, S>

The wrapped service

fn layer(&self, inner: S) -> Self::Service

Wrap the given service with the middleware, returning a new service that has been decorated with the middleware.