From ebfa3b0393c2203ae05928c647a53def846b1a8c Mon Sep 17 00:00:00 2001 From: tanish111 Date: Tue, 18 Nov 2025 20:59:18 +0530 Subject: [PATCH 1/6] feat: implement SEP-986 tool name validation and error reporting Adds validation for MCP tool naming conventions as specified in SEP-986. Ensures Rust SDK enforces standardized tool name formats, provides clear errors for invalid names, and improves consistency across implementations. Signed-off-by: tanish111 --- crates/rmcp/src/handler/server.rs | 1 + crates/rmcp/src/handler/server/router/tool.rs | 13 +- .../handler/server/tool_name_validation.rs | 309 ++++++++++++++++++ 3 files changed, 320 insertions(+), 3 deletions(-) create mode 100644 crates/rmcp/src/handler/server/tool_name_validation.rs diff --git a/crates/rmcp/src/handler/server.rs b/crates/rmcp/src/handler/server.rs index 4f9edbc0..dd3e3d3d 100644 --- a/crates/rmcp/src/handler/server.rs +++ b/crates/rmcp/src/handler/server.rs @@ -9,6 +9,7 @@ pub mod prompt; mod resource; pub mod router; pub mod tool; +pub mod tool_name_validation; pub mod wrapper; impl Service for H { async fn handle_request( diff --git a/crates/rmcp/src/handler/server/router/tool.rs b/crates/rmcp/src/handler/server/router/tool.rs index bdef13e0..04c0bc0f 100644 --- a/crates/rmcp/src/handler/server/router/tool.rs +++ b/crates/rmcp/src/handler/server/router/tool.rs @@ -4,8 +4,11 @@ use futures::{FutureExt, future::BoxFuture}; use schemars::JsonSchema; use crate::{ - handler::server::tool::{ - CallToolHandler, DynCallToolHandler, ToolCallContext, schema_for_type, + handler::server::{ + tool::{ + CallToolHandler, DynCallToolHandler, ToolCallContext, schema_for_type, + }, + tool_name_validation::validate_and_warn_tool_name, }, model::{CallToolResult, Tool, ToolAnnotations}, }; @@ -219,7 +222,11 @@ where } pub fn add_route(&mut self, item: ToolRoute) { - self.map.insert(item.attr.name.clone(), item); + let new_name = &item.attr.name; + // Validate tool name according to SEP specification + // This validates both new routes and updates (when replacing a route with a different name) + validate_and_warn_tool_name(new_name); + self.map.insert(new_name.clone(), item); } pub fn merge(&mut self, other: ToolRouter) { diff --git a/crates/rmcp/src/handler/server/tool_name_validation.rs b/crates/rmcp/src/handler/server/tool_name_validation.rs new file mode 100644 index 00000000..c934d153 --- /dev/null +++ b/crates/rmcp/src/handler/server/tool_name_validation.rs @@ -0,0 +1,309 @@ +//! Tool name validation utilities according to SEP: Specify Format for Tool Names +//! +//! Tool names SHOULD be between 1 and 128 characters in length (inclusive). +//! Tool names are case-sensitive. +//! Allowed characters: uppercase and lowercase ASCII letters (A-Z, a-z), digits +//! (0-9), underscore (_), dash (-), and dot (.). +//! Tool names SHOULD NOT contain spaces, commas, or other special characters. + +use std::collections::HashSet; + +/// Result of tool name validation containing validation status and warnings. +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct ToolNameValidationResult { + /// Whether the tool name is valid according to the specification + pub is_valid: bool, + /// Array of warning messages about non-conforming aspects of the tool name + pub warnings: Vec, +} + +impl ToolNameValidationResult { + /// Create a new validation result + pub fn new(is_valid: bool, warnings: Vec) -> Self { + Self { is_valid, warnings } + } +} + +/// Validates a tool name according to the SEP specification. +/// +/// # Arguments +/// +/// * `name` - The tool name to validate +/// +/// # Returns +/// +/// A `ToolNameValidationResult` containing validation result and any warnings +/// +/// # Examples +/// +/// ``` +/// use rmcp::model::tool_name_validation::validate_tool_name; +/// +/// let result = validate_tool_name("my_tool"); +/// assert!(result.is_valid); +/// assert!(result.warnings.is_empty()); +/// ``` +pub fn validate_tool_name(name: &str) -> ToolNameValidationResult { + let mut warnings = Vec::new(); + + // Check length + if name.is_empty() { + return ToolNameValidationResult::new( + false, + vec!["Tool name cannot be empty".to_string()], + ); + } + + if name.len() > 128 { + return ToolNameValidationResult::new( + false, + vec![format!( + "Tool name exceeds maximum length of 128 characters (current: {})", + name.len() + )], + ); + } + + // Check for specific problematic patterns (these are warnings, not validation failures) + if name.contains(' ') { + warnings.push( + "Tool name contains spaces, which may cause parsing issues".to_string(), + ); + } + + if name.contains(',') { + warnings.push( + "Tool name contains commas, which may cause parsing issues".to_string(), + ); + } + + // Check for potentially confusing patterns (leading/trailing dashes, dots, slashes) + if name.starts_with('-') || name.ends_with('-') { + warnings.push( + "Tool name starts or ends with a dash, which may cause parsing issues in some contexts" + .to_string(), + ); + } + + if name.starts_with('.') || name.ends_with('.') { + warnings.push( + "Tool name starts or ends with a dot, which may cause parsing issues in some contexts" + .to_string(), + ); + } + + // Check for invalid characters + let mut invalid_chars = HashSet::new(); + let valid_chars: HashSet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789._-" + .chars() + .collect(); + + for ch in name.chars() { + if !valid_chars.contains(&ch) { + invalid_chars.insert(ch); + } + } + + if !invalid_chars.is_empty() { + let invalid_chars_list: Vec = invalid_chars + .iter() + .map(|c| format!("\"{}\"", c)) + .collect(); + warnings.push(format!( + "Tool name contains invalid characters: {}", + invalid_chars_list.join(", ") + )); + warnings.push( + "Allowed characters are: A-Z, a-z, 0-9, underscore (_), dash (-), and dot (.)" + .to_string(), + ); + + return ToolNameValidationResult::new(false, warnings); + } + + // Verify the pattern matches (double check with character-by-character validation) + // We've already validated characters above, just need to verify length is within bounds + if name.len() < 1 || name.len() > 128 { + return ToolNameValidationResult::new( + false, + vec!["Tool name length must be between 1 and 128 characters".to_string()], + ); + } + + ToolNameValidationResult::new(true, warnings) +} + +/// Issues warnings for non-conforming tool names. +/// +/// # Arguments +/// +/// * `name` - The tool name that triggered the warnings +/// * `warnings` - Array of warning messages +/// +/// # Examples +/// +/// ``` +/// use rmcp::model::tool_name_validation::issue_tool_name_warning; +/// +/// issue_tool_name_warning("my tool", vec!["Tool name contains spaces".to_string()]); +/// ``` +pub fn issue_tool_name_warning(name: &str, warnings: &[String]) { + if !warnings.is_empty() { + tracing::warn!("Tool name validation warning for \"{}\":", name); + for warning in warnings { + tracing::warn!(" - {}", warning); + } + tracing::warn!("Tool registration will proceed, but this may cause compatibility issues."); + tracing::warn!("Consider updating the tool name to conform to the MCP tool naming standard."); + tracing::warn!( + "See SEP: Specify Format for Tool Names (https://github.com/modelcontextprotocol/modelcontextprotocol/issues/986) for more details." + ); + } +} + +/// Validates a tool name and issues warnings for non-conforming names. +/// +/// # Arguments +/// +/// * `name` - The tool name to validate +/// +/// # Returns +/// +/// `true` if the name is valid, `false` otherwise +/// +/// # Examples +/// +/// ``` +/// use rmcp::model::tool_name_validation::validate_and_warn_tool_name; +/// +/// let is_valid = validate_and_warn_tool_name("my_tool"); +/// assert!(is_valid); +/// ``` +pub fn validate_and_warn_tool_name(name: &str) -> bool { + let result = validate_tool_name(name); + + // Always issue warnings for any validation issues (both invalid names and warnings) + issue_tool_name_warning(name, &result.warnings); + + result.is_valid +} +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_valid_tool_names() { + let max_length_name = "a".repeat(128); + let valid_names = vec![ + "my_tool", + "MyTool", + "my-tool", + "my.tool", + "tool123", + "a", + max_length_name.as_str(), // Maximum length + ]; + + for name in valid_names { + let result = validate_tool_name(name); + assert!( + result.is_valid, + "Tool name '{}' should be valid", + name + ); + } + } + + #[test] + fn test_empty_tool_name() { + let result = validate_tool_name(""); + assert!(!result.is_valid); + assert!(result.warnings.contains(&"Tool name cannot be empty".to_string())); + } + + #[test] + fn test_too_long_tool_name() { + let name = "a".repeat(129); + let result = validate_tool_name(&name); + assert!(!result.is_valid); + assert!(result.warnings[0].contains("exceeds maximum length")); + } + + #[test] + fn test_tool_name_with_spaces() { + let result = validate_tool_name("my tool"); + assert!(!result.is_valid); + assert!(result + .warnings + .iter() + .any(|w| w.contains("contains spaces"))); + } + + #[test] + fn test_tool_name_with_commas() { + let result = validate_tool_name("my,tool"); + assert!(!result.is_valid); + assert!(result + .warnings + .iter() + .any(|w| w.contains("contains commas"))); + } + + #[test] + fn test_tool_name_starting_with_dash() { + let result = validate_tool_name("-tool"); + assert!(result.is_valid); // Still valid, but has warning + assert!(result + .warnings + .iter() + .any(|w| w.contains("starts or ends with a dash"))); + } + + #[test] + fn test_tool_name_ending_with_dot() { + let result = validate_tool_name("tool."); + assert!(result.is_valid); // Still valid, but has warning + assert!(result + .warnings + .iter() + .any(|w| w.contains("starts or ends with a dot"))); + } + + #[test] + fn test_tool_name_with_invalid_characters() { + let result = validate_tool_name("my@tool"); + assert!(!result.is_valid); + assert!(result + .warnings + .iter() + .any(|w| w.contains("contains invalid characters"))); + } + + #[test] + fn test_tool_name_all_special_characters_allowed() { + let valid_chars = vec!['_', '-', '.']; + for ch in valid_chars { + let name = format!("tool{}", ch); + let result = validate_tool_name(&name); + assert!( + result.is_valid, + "Tool name with character '{}' should be valid", + ch + ); + } + } + + #[test] + fn test_minimum_length() { + let result = validate_tool_name("a"); + assert!(result.is_valid); + } + + #[test] + fn test_maximum_length() { + let name = "a".repeat(128); + let result = validate_tool_name(&name); + assert!(result.is_valid); + } +} + From 0e2702624c9593f086bb70b1e615948511512911 Mon Sep 17 00:00:00 2001 From: tanish111 Date: Tue, 18 Nov 2025 21:12:10 +0530 Subject: [PATCH 2/6] fix(doctests): correct import paths in tool_name_validation Update doctest examples to use the correct module path rmcp::handler::server::tool_name_validation instead of rmcp::model::tool_name_validation. Signed-off-by: tanish111 --- crates/rmcp/src/handler/server/router/tool.rs | 4 +- .../handler/server/tool_name_validation.rs | 103 +++++++++--------- 2 files changed, 54 insertions(+), 53 deletions(-) diff --git a/crates/rmcp/src/handler/server/router/tool.rs b/crates/rmcp/src/handler/server/router/tool.rs index 04c0bc0f..cc224afe 100644 --- a/crates/rmcp/src/handler/server/router/tool.rs +++ b/crates/rmcp/src/handler/server/router/tool.rs @@ -5,9 +5,7 @@ use schemars::JsonSchema; use crate::{ handler::server::{ - tool::{ - CallToolHandler, DynCallToolHandler, ToolCallContext, schema_for_type, - }, + tool::{CallToolHandler, DynCallToolHandler, ToolCallContext, schema_for_type}, tool_name_validation::validate_and_warn_tool_name, }, model::{CallToolResult, Tool, ToolAnnotations}, diff --git a/crates/rmcp/src/handler/server/tool_name_validation.rs b/crates/rmcp/src/handler/server/tool_name_validation.rs index c934d153..7bcfbdae 100644 --- a/crates/rmcp/src/handler/server/tool_name_validation.rs +++ b/crates/rmcp/src/handler/server/tool_name_validation.rs @@ -37,7 +37,7 @@ impl ToolNameValidationResult { /// # Examples /// /// ``` -/// use rmcp::model::tool_name_validation::validate_tool_name; +/// use rmcp::handler::server::tool_name_validation::validate_tool_name; /// /// let result = validate_tool_name("my_tool"); /// assert!(result.is_valid); @@ -48,10 +48,7 @@ pub fn validate_tool_name(name: &str) -> ToolNameValidationResult { // Check length if name.is_empty() { - return ToolNameValidationResult::new( - false, - vec!["Tool name cannot be empty".to_string()], - ); + return ToolNameValidationResult::new(false, vec!["Tool name cannot be empty".to_string()]); } if name.len() > 128 { @@ -66,15 +63,11 @@ pub fn validate_tool_name(name: &str) -> ToolNameValidationResult { // Check for specific problematic patterns (these are warnings, not validation failures) if name.contains(' ') { - warnings.push( - "Tool name contains spaces, which may cause parsing issues".to_string(), - ); + warnings.push("Tool name contains spaces, which may cause parsing issues".to_string()); } if name.contains(',') { - warnings.push( - "Tool name contains commas, which may cause parsing issues".to_string(), - ); + warnings.push("Tool name contains commas, which may cause parsing issues".to_string()); } // Check for potentially confusing patterns (leading/trailing dashes, dots, slashes) @@ -94,9 +87,10 @@ pub fn validate_tool_name(name: &str) -> ToolNameValidationResult { // Check for invalid characters let mut invalid_chars = HashSet::new(); - let valid_chars: HashSet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789._-" - .chars() - .collect(); + let valid_chars: HashSet = + "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789._-" + .chars() + .collect(); for ch in name.chars() { if !valid_chars.contains(&ch) { @@ -105,10 +99,8 @@ pub fn validate_tool_name(name: &str) -> ToolNameValidationResult { } if !invalid_chars.is_empty() { - let invalid_chars_list: Vec = invalid_chars - .iter() - .map(|c| format!("\"{}\"", c)) - .collect(); + let invalid_chars_list: Vec = + invalid_chars.iter().map(|c| format!("\"{}\"", c)).collect(); warnings.push(format!( "Tool name contains invalid characters: {}", invalid_chars_list.join(", ") @@ -123,7 +115,7 @@ pub fn validate_tool_name(name: &str) -> ToolNameValidationResult { // Verify the pattern matches (double check with character-by-character validation) // We've already validated characters above, just need to verify length is within bounds - if name.len() < 1 || name.len() > 128 { + if name.is_empty() || name.len() > 128 { return ToolNameValidationResult::new( false, vec!["Tool name length must be between 1 and 128 characters".to_string()], @@ -143,9 +135,9 @@ pub fn validate_tool_name(name: &str) -> ToolNameValidationResult { /// # Examples /// /// ``` -/// use rmcp::model::tool_name_validation::issue_tool_name_warning; +/// use rmcp::handler::server::tool_name_validation::issue_tool_name_warning; /// -/// issue_tool_name_warning("my tool", vec!["Tool name contains spaces".to_string()]); +/// issue_tool_name_warning("my tool", &vec!["Tool name contains spaces".to_string()]); /// ``` pub fn issue_tool_name_warning(name: &str, warnings: &[String]) { if !warnings.is_empty() { @@ -154,7 +146,9 @@ pub fn issue_tool_name_warning(name: &str, warnings: &[String]) { tracing::warn!(" - {}", warning); } tracing::warn!("Tool registration will proceed, but this may cause compatibility issues."); - tracing::warn!("Consider updating the tool name to conform to the MCP tool naming standard."); + tracing::warn!( + "Consider updating the tool name to conform to the MCP tool naming standard." + ); tracing::warn!( "See SEP: Specify Format for Tool Names (https://github.com/modelcontextprotocol/modelcontextprotocol/issues/986) for more details." ); @@ -174,7 +168,7 @@ pub fn issue_tool_name_warning(name: &str, warnings: &[String]) { /// # Examples /// /// ``` -/// use rmcp::model::tool_name_validation::validate_and_warn_tool_name; +/// use rmcp::handler::server::tool_name_validation::validate_and_warn_tool_name; /// /// let is_valid = validate_and_warn_tool_name("my_tool"); /// assert!(is_valid); @@ -206,11 +200,7 @@ mod tests { for name in valid_names { let result = validate_tool_name(name); - assert!( - result.is_valid, - "Tool name '{}' should be valid", - name - ); + assert!(result.is_valid, "Tool name '{}' should be valid", name); } } @@ -218,7 +208,11 @@ mod tests { fn test_empty_tool_name() { let result = validate_tool_name(""); assert!(!result.is_valid); - assert!(result.warnings.contains(&"Tool name cannot be empty".to_string())); + assert!( + result + .warnings + .contains(&"Tool name cannot be empty".to_string()) + ); } #[test] @@ -233,50 +227,60 @@ mod tests { fn test_tool_name_with_spaces() { let result = validate_tool_name("my tool"); assert!(!result.is_valid); - assert!(result - .warnings - .iter() - .any(|w| w.contains("contains spaces"))); + assert!( + result + .warnings + .iter() + .any(|w| w.contains("contains spaces")) + ); } #[test] fn test_tool_name_with_commas() { let result = validate_tool_name("my,tool"); assert!(!result.is_valid); - assert!(result - .warnings - .iter() - .any(|w| w.contains("contains commas"))); + assert!( + result + .warnings + .iter() + .any(|w| w.contains("contains commas")) + ); } #[test] fn test_tool_name_starting_with_dash() { let result = validate_tool_name("-tool"); assert!(result.is_valid); // Still valid, but has warning - assert!(result - .warnings - .iter() - .any(|w| w.contains("starts or ends with a dash"))); + assert!( + result + .warnings + .iter() + .any(|w| w.contains("starts or ends with a dash")) + ); } #[test] fn test_tool_name_ending_with_dot() { let result = validate_tool_name("tool."); assert!(result.is_valid); // Still valid, but has warning - assert!(result - .warnings - .iter() - .any(|w| w.contains("starts or ends with a dot"))); + assert!( + result + .warnings + .iter() + .any(|w| w.contains("starts or ends with a dot")) + ); } #[test] fn test_tool_name_with_invalid_characters() { let result = validate_tool_name("my@tool"); assert!(!result.is_valid); - assert!(result - .warnings - .iter() - .any(|w| w.contains("contains invalid characters"))); + assert!( + result + .warnings + .iter() + .any(|w| w.contains("contains invalid characters")) + ); } #[test] @@ -306,4 +310,3 @@ mod tests { assert!(result.is_valid); } } - From 1888f73e4cb7a8b0a58a6db9a6aebd258623c1d2 Mon Sep 17 00:00:00 2001 From: tanish111 Date: Thu, 20 Nov 2025 00:47:48 +0530 Subject: [PATCH 3/6] fix: only warn when warnings exist Prevent empty warnings array from triggering warning output. Signed-off-by: tanish111 --- crates/rmcp/src/handler/server/tool_name_validation.rs | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/crates/rmcp/src/handler/server/tool_name_validation.rs b/crates/rmcp/src/handler/server/tool_name_validation.rs index 7bcfbdae..a30c4bbc 100644 --- a/crates/rmcp/src/handler/server/tool_name_validation.rs +++ b/crates/rmcp/src/handler/server/tool_name_validation.rs @@ -176,8 +176,9 @@ pub fn issue_tool_name_warning(name: &str, warnings: &[String]) { pub fn validate_and_warn_tool_name(name: &str) -> bool { let result = validate_tool_name(name); - // Always issue warnings for any validation issues (both invalid names and warnings) - issue_tool_name_warning(name, &result.warnings); + if !result.warnings.is_empty() { + issue_tool_name_warning(name, &result.warnings); + } result.is_valid } From 6cc2a52d97840e67679f9ba044aba9967d99cfeb Mon Sep 17 00:00:00 2001 From: tanish111 Date: Thu, 20 Nov 2025 00:55:14 +0530 Subject: [PATCH 4/6] fix: remove internal check Signed-off-by: tanish111 --- .../handler/server/tool_name_validation.rs | 20 ++++++++----------- 1 file changed, 8 insertions(+), 12 deletions(-) diff --git a/crates/rmcp/src/handler/server/tool_name_validation.rs b/crates/rmcp/src/handler/server/tool_name_validation.rs index a30c4bbc..3c44b9d8 100644 --- a/crates/rmcp/src/handler/server/tool_name_validation.rs +++ b/crates/rmcp/src/handler/server/tool_name_validation.rs @@ -140,19 +140,15 @@ pub fn validate_tool_name(name: &str) -> ToolNameValidationResult { /// issue_tool_name_warning("my tool", &vec!["Tool name contains spaces".to_string()]); /// ``` pub fn issue_tool_name_warning(name: &str, warnings: &[String]) { - if !warnings.is_empty() { - tracing::warn!("Tool name validation warning for \"{}\":", name); - for warning in warnings { - tracing::warn!(" - {}", warning); - } - tracing::warn!("Tool registration will proceed, but this may cause compatibility issues."); - tracing::warn!( - "Consider updating the tool name to conform to the MCP tool naming standard." - ); - tracing::warn!( - "See SEP: Specify Format for Tool Names (https://github.com/modelcontextprotocol/modelcontextprotocol/issues/986) for more details." - ); + tracing::warn!("Tool name validation warning for \"{}\":", name); + for warning in warnings { + tracing::warn!(" - {}", warning); } + tracing::warn!("Tool registration will proceed, but this may cause compatibility issues."); + tracing::warn!("Consider updating the tool name to conform to the MCP tool naming standard."); + tracing::warn!( + "See SEP: Specify Format for Tool Names (https://github.com/modelcontextprotocol/modelcontextprotocol/issues/986) for more details." + ); } /// Validates a tool name and issues warnings for non-conforming names. From dc1f3347f035024c03a37690f060e3bf8df072b0 Mon Sep 17 00:00:00 2001 From: tanish111 Date: Thu, 20 Nov 2025 00:59:43 +0530 Subject: [PATCH 5/6] refactor: remove doc comments from validation functions Signed-off-by: tanish111 --- .../handler/server/tool_name_validation.rs | 48 ------------------- 1 file changed, 48 deletions(-) diff --git a/crates/rmcp/src/handler/server/tool_name_validation.rs b/crates/rmcp/src/handler/server/tool_name_validation.rs index 3c44b9d8..7f41e0f7 100644 --- a/crates/rmcp/src/handler/server/tool_name_validation.rs +++ b/crates/rmcp/src/handler/server/tool_name_validation.rs @@ -25,24 +25,6 @@ impl ToolNameValidationResult { } /// Validates a tool name according to the SEP specification. -/// -/// # Arguments -/// -/// * `name` - The tool name to validate -/// -/// # Returns -/// -/// A `ToolNameValidationResult` containing validation result and any warnings -/// -/// # Examples -/// -/// ``` -/// use rmcp::handler::server::tool_name_validation::validate_tool_name; -/// -/// let result = validate_tool_name("my_tool"); -/// assert!(result.is_valid); -/// assert!(result.warnings.is_empty()); -/// ``` pub fn validate_tool_name(name: &str) -> ToolNameValidationResult { let mut warnings = Vec::new(); @@ -126,19 +108,6 @@ pub fn validate_tool_name(name: &str) -> ToolNameValidationResult { } /// Issues warnings for non-conforming tool names. -/// -/// # Arguments -/// -/// * `name` - The tool name that triggered the warnings -/// * `warnings` - Array of warning messages -/// -/// # Examples -/// -/// ``` -/// use rmcp::handler::server::tool_name_validation::issue_tool_name_warning; -/// -/// issue_tool_name_warning("my tool", &vec!["Tool name contains spaces".to_string()]); -/// ``` pub fn issue_tool_name_warning(name: &str, warnings: &[String]) { tracing::warn!("Tool name validation warning for \"{}\":", name); for warning in warnings { @@ -152,23 +121,6 @@ pub fn issue_tool_name_warning(name: &str, warnings: &[String]) { } /// Validates a tool name and issues warnings for non-conforming names. -/// -/// # Arguments -/// -/// * `name` - The tool name to validate -/// -/// # Returns -/// -/// `true` if the name is valid, `false` otherwise -/// -/// # Examples -/// -/// ``` -/// use rmcp::handler::server::tool_name_validation::validate_and_warn_tool_name; -/// -/// let is_valid = validate_and_warn_tool_name("my_tool"); -/// assert!(is_valid); -/// ``` pub fn validate_and_warn_tool_name(name: &str) -> bool { let result = validate_tool_name(name); From c4b409205920aceda9d68ae71a78acd88d6d4f51 Mon Sep 17 00:00:00 2001 From: tanish111 Date: Sat, 22 Nov 2025 12:03:32 +0530 Subject: [PATCH 6/6] refactor: remove doc comments from add_route functions Signed-off-by: tanish111 --- crates/rmcp/src/handler/server/router/tool.rs | 2 -- 1 file changed, 2 deletions(-) diff --git a/crates/rmcp/src/handler/server/router/tool.rs b/crates/rmcp/src/handler/server/router/tool.rs index cc224afe..610c9326 100644 --- a/crates/rmcp/src/handler/server/router/tool.rs +++ b/crates/rmcp/src/handler/server/router/tool.rs @@ -221,8 +221,6 @@ where pub fn add_route(&mut self, item: ToolRoute) { let new_name = &item.attr.name; - // Validate tool name according to SEP specification - // This validates both new routes and updates (when replacing a route with a different name) validate_and_warn_tool_name(new_name); self.map.insert(new_name.clone(), item); }