Module handlers 

Traits and types for handling different MCP requests (tools, prompts, etc.). Handler traits for extensible MCP protocol support

This module provides trait definitions for handling various MCP protocol features including elicitation, completion, resource templates, and ping.

Handler Types

ElicitationHandler

Handle server-initiated user input requests. Useful for asking users for additional information during tool execution.

CompletionProvider

Provide argument completion suggestions for tools and commands. Implements autocomplete functionality in MCP clients.

ResourceTemplateHandler

Manage dynamic resource templates with parameter substitution. Enables pattern-based resource access (e.g., file:///{path}).

PingHandler

Handle bidirectional ping/pong for connection health monitoring.

Example: Implementing an Elicitation Handler

use turbomcp_protocol::{ElicitationHandler, ElicitationContext, ElicitationResponse};
use turbomcp_protocol::Result;
use async_trait::async_trait;
use std::collections::HashMap;

struct MyElicitationHandler;

#[async_trait]
impl ElicitationHandler for MyElicitationHandler {
    async fn handle_elicitation(
        &self,
        context: &ElicitationContext
    ) -> Result<ElicitationResponse> {
        // Check if we can handle this elicitation type
        if !self.can_handle(context) {
            return Ok(ElicitationResponse {
                accepted: false,
                content: None,
                decline_reason: Some("Unsupported elicitation type".to_string()),
            });
        }

        // Process the elicitation (e.g., prompt user)
        let mut response_data = HashMap::new();
        response_data.insert(
            "user_input".to_string(),
            serde_json::json!("User provided value")
        );

        Ok(ElicitationResponse {
            accepted: true,
            content: Some(response_data),
            decline_reason: None,
        })
    }

    fn can_handle(&self, context: &ElicitationContext) -> bool {
        // Check if elicitation has required input
        context.required && !context.message.is_empty()
    }

    fn priority(&self) -> i32 {
        100 // Higher priority than default (0)
    }
}

Example: Implementing a Completion Provider

use turbomcp_protocol::{CompletionProvider, CompletionContext, CompletionItem};
use turbomcp_protocol::Result;
use async_trait::async_trait;

struct FilePathCompletionProvider;

#[async_trait]
impl CompletionProvider for FilePathCompletionProvider {
    async fn provide_completions(
        &self,
        context: &CompletionContext
    ) -> Result<Vec<CompletionItem>> {
        // Provide file path completions
        let mut completions = vec![
            CompletionItem {
                value: "/home/user/documents".to_string(),
                label: Some("Documents".to_string()),
                documentation: Some("User documents folder".to_string()),
                sort_priority: Some(1),
                insert_text: None,
                metadata: Default::default(),
            },
            CompletionItem {
                value: "/home/user/downloads".to_string(),
                label: Some("Downloads".to_string()),
                documentation: Some("Downloads folder".to_string()),
                sort_priority: Some(2),
                insert_text: None,
                metadata: Default::default(),
            },
        ];

        Ok(completions)
    }

    fn can_provide(&self, context: &CompletionContext) -> bool {
        // Only provide completions for "path" arguments
        context.argument_name.as_deref() == Some("path")
    }
}

Structs

CompletionItem

A single completion item

ElicitationResponse

Response to an elicitation request

HandlerCapabilities

Handler capability tracking

PingResponse

Response to a ping request

ResolvedResource

Resolved resource from template

ResourceTemplate

Resource template definition

ServerInfo

Server metadata information

ServerInitiatedCapabilities

Capabilities for server-initiated features

TemplateParam

Template parameter definition

Traits

CompletionProvider

Provider for argument completion

ElicitationHandler

Handler for server-initiated elicitation requests

JsonRpcHandler

Handler for JSON-RPC requests - Core abstraction for MCP protocol implementation

PingHandler

Handler for bidirectional ping requests

ResourceTemplateHandler

Handler for resource templates