Struct PromptBuilderWithHandler 

pub struct PromptBuilderWithHandler<F> { /* private fields */ }

Builder state after handler is specified

This allows either calling .build() to create the prompt directly, or .layer() to apply middleware before building.

Implementations

impl<F, Fut> PromptBuilderWithHandler<F>

where F: Fn(HashMap<String, String>) -> Fut + Send + Sync + Clone + 'static, Fut: Future<Output = Result<GetPromptResult>> + Send + 'static,

pub fn build(self) -> Prompt

Build the prompt without any middleware

pub fn layer<L>(self, layer: L) -> Prompt

where L: Layer<PromptHandlerService<F>> + Send + Sync + 'static, L::Service: Service<PromptRequest, Response = GetPromptResult> + Clone + Send + 'static, <L::Service as Service<PromptRequest>>::Error: Display + Send, <L::Service as Service<PromptRequest>>::Future: Send,

Apply a tower middleware layer to this prompt

The layer wraps the prompt handler, allowing middleware like timeouts, rate limiting, or retries to be applied to this specific prompt.

Example

use std::collections::HashMap;
use std::time::Duration;
use tower::timeout::TimeoutLayer;
use tower_mcp::prompt::PromptBuilder;
use tower_mcp::protocol::{GetPromptResult, PromptMessage, PromptRole, Content};

let prompt = PromptBuilder::new("slow_prompt")
    .description("A prompt that might take a while")
    .handler(|_args: HashMap<String, String>| async move {
        Ok(GetPromptResult {
            description: Some("Generated prompt".to_string()),
            messages: vec![PromptMessage {
                role: PromptRole::User,
                content: Content::Text {
                    text: "Hello!".to_string(),
                    annotations: None,
                },
            }],
        })
    })
    .layer(TimeoutLayer::new(Duration::from_secs(5)));