Changed naming to adhere to official Rust API guidelines.

Author: virtualritz

crates/rust-mcp-macros/README.md

@@ -5,7 +5,7 @@ A procedural macro, part of the [rust-mcp-sdk](https://github.com/rust-mcp-stack
 The `mcp_tool` macro generates an implementation for the annotated struct that includes:
 
 - A `tool_name()` method returning the tool's name as a string.
-- A `get_tool()` method returning a `rust_mcp_schema::Tool` instance with the tool's name,
+- A `tool()` method returning a `rust_mcp_schema::Tool` instance with the tool's name,
   description, and input schema derived from the struct's fields.
 
 ## Attributes
@@ -32,7 +32,7 @@ fn main() {
 
     assert_eq!(WriteFileTool::tool_name(), "write_file");
 
-    let tool: rust_mcp_schema::Tool = WriteFileTool::get_tool();
+    let tool: rust_mcp_schema::Tool = WriteFileTool::tool();
     assert_eq!(tool.name, "write_file");
     assert_eq!( tool.description.unwrap(),"Create a new file or completely overwrite an existing file with new content.");
 

crates/rust-mcp-macros/src/lib.rs

@@ -19,12 +19,12 @@ use utils::{is_option, renamed_field, type_to_json_schema};
 /// * `name` - An optional string representing the tool's name.
 /// * `description` - An optional string describing the tool.
 ///
-struct MCPToolMacroAttributes {
+struct McpToolMacroAttributes {
     name: Option<String>,
     description: Option<String>,
 }
 
-impl Parse for MCPToolMacroAttributes {
+impl Parse for McpToolMacroAttributes {
     /// Parses the macro attributes from a `ParseStream`.
     ///
     /// This implementation extracts `name` and `description` from the attribute input,
@@ -96,7 +96,7 @@ impl Parse for MCPToolMacroAttributes {
 ///
 /// The `mcp_tool` macro generates an implementation for the annotated struct that includes:
 /// - A `tool_name()` method returning the tool's name as a string.
-/// - A `get_tool()` method returning a `rust_mcp_schema::Tool` instance with the tool's name,
+/// - A `tool()` method returning a `rust_mcp_schema::Tool` instance with the tool's name,
 ///   description, and input schema derived from the struct's fields.
 ///
 /// # Attributes
@@ -116,7 +116,7 @@ impl Parse for MCPToolMacroAttributes {
 /// }
 ///
 /// assert_eq!(ExampleTool::tool_name() , "example_tool");
-/// let tool : rust_mcp_schema::Tool = ExampleTool::get_tool();
+/// let tool : rust_mcp_schema::Tool = ExampleTool::tool();
 /// assert_eq!(tool.name , "example_tool");
 /// assert_eq!(tool.description.unwrap() , "An example tool");
 ///
@@ -131,7 +131,7 @@ pub fn mcp_tool(attributes: TokenStream, input: TokenStream) -> TokenStream {
     let input = parse_macro_input!(input as DeriveInput); // Parse the input as a function
     let input_ident = &input.ident;
 
-    let macro_attributes = parse_macro_input!(attributes as MCPToolMacroAttributes);
+    let macro_attributes = parse_macro_input!(attributes as McpToolMacroAttributes);
 
     let tool_name = macro_attributes.name.unwrap_or_default();
     let tool_description = macro_attributes.description.unwrap_or_default();
@@ -147,7 +147,7 @@ pub fn mcp_tool(attributes: TokenStream, input: TokenStream) -> TokenStream {
             ///
             /// The tool includes the name, description, and input schema derived from
             /// the struct's attributes.
-            pub fn get_tool()-> rust_mcp_schema::Tool
+            pub fn tool()-> rust_mcp_schema::Tool
             {
                 let json_schema = &#input_ident::json_schema();
 

crates/rust-mcp-macros/src/utils.rs

@@ -28,7 +28,7 @@ pub fn is_vec(ty: &Type) -> bool {
 
 // Extract the inner type from Vec<T> or Option<T>
 #[allow(unused)]
-pub fn get_inner_type(ty: &Type) -> Option<&Type> {
+pub fn inner_type(ty: &Type) -> Option<&Type> {
     if let Type::Path(type_path) = ty {
         if type_path.path.segments.len() == 1 {
             let segment = &type_path.path.segments[0];
@@ -46,7 +46,7 @@ pub fn get_inner_type(ty: &Type) -> Option<&Type> {
     None
 }
 
-fn get_doc_comment(attrs: &[Attribute]) -> Option<String> {
+fn doc_comment(attrs: &[Attribute]) -> Option<String> {
     let mut docs = Vec::new();
     for attr in attrs {
         if attr.path().is_ident("doc") {
@@ -86,7 +86,7 @@ pub fn type_to_json_schema(ty: &Type, attrs: &[Attribute]) -> proc_macro2::Token
     let number_types = [
         "i8", "i16", "i32", "i64", "i128", "u8", "u16", "u32", "u64", "u128", "f32", "f64",
     ];
-    let doc_comment = get_doc_comment(attrs);
+    let doc_comment = doc_comment(attrs);
     let description = doc_comment.as_ref().map(|desc| {
         quote! {
             map.insert("description".to_string(), serde_json::Value::String(#desc.to_string()));

crates/rust-mcp-sdk/README.md

@@ -4,10 +4,10 @@
 
 # Rust MCP SDK
 
-A high-performance, asynchronous toolkit for building MCP servers and clients.  
+A high-performance, asynchronous toolkit for building MCP servers and clients.
 Focus on your app's logic while **rust-mcp-sdk** takes care of the rest!
 
-**rust-mcp-sdk** provides the necessary components for developing both servers and clients in the MCP ecosystem.  
+**rust-mcp-sdk** provides the necessary components for developing both servers and clients in the MCP ecosystem.
 Leveraging the [rust-mcp-schema](https://github.com/rust-mcp-stack/rust-mcp-schema) crate for type safe MCP schema objects and MCP type utilities simplifies the process of building robust and reliable MCP servers and clients, ensuring consistency and minimizing errors in data handling and message processing.
 
 **⚠️WARNING**: This project only supports Standard Input/Output (stdio) transport at this time, with support for SSE (Server-Sent Events) transport still in progress and not yet available. Project is currently under development and should be used at your own risk.
@@ -70,18 +70,18 @@ pub struct MyServerHandler;
 #[async_trait]
 impl ServerHandler for MyServerHandler {
     // Handle ListToolsRequest, return list of available tools as ListToolsResult
-    async fn handle_list_tools_request(&self, request: ListToolsRequest, runtime: &dyn MCPServer) -> Result<ListToolsResult, JsonrpcErrorError> {
+    async fn handle_list_tools_request(&self, request: ListToolsRequest, runtime: &dyn McpServer) -> Result<ListToolsResult, JsonrpcErrorError> {
 
         Ok(ListToolsResult {
-            tools: vec![SayHelloTool::get_tool()],
+            tools: vec![SayHelloTool::tool()],
             meta: None,
             next_cursor: None,
         })
 
     }
 
     /// Handles requests to call a specific tool.
-    async fn handle_call_tool_request( &self, request: CallToolRequest, runtime: &dyn MCPServer, ) -> Result<CallToolResult, CallToolError> {
+    async fn handle_call_tool_request( &self, request: CallToolRequest, runtime: &dyn McpServer, ) -> Result<CallToolResult, CallToolError> {
 
         if request.tool_name() == SayHelloTool::tool_name() {
             Ok(CallToolResult::text_content(
@@ -153,7 +153,7 @@ async fn main() -> SdkResult<()> {
     // STEP 7: use client methods to communicate with the MCP Server as you wish
 
     // Retrieve and display the list of tools available on the server
-    let server_version = client.get_server_version().unwrap();
+    let server_version = client.server_version().unwrap();
     let tools = client.list_tools(None).await?.tools;
 
     println!("List of tools for {}@{}", server_version.name, server_version.version);
@@ -195,10 +195,10 @@ If you are looking for a step-by-step tutorial on how to get started with `rust-
 
 [rust-mcp-sdk](https://github.com/rust-mcp-stack/rust-mcp-sdk) provides two type of handler traits that you can chose from:
 
-- **mcp_server_handler**: This is the recommended trait for your MCP project, offering a default implementation for all types of MCP messages. It includes predefined implementations within the trait, such as handling initialization or responding to ping requests, so you only need to override and customize the handler functions relevant to your specific needs.  
+- **mcp_server_handler**: This is the recommended trait for your MCP project, offering a default implementation for all types of MCP messages. It includes predefined implementations within the trait, such as handling initialization or responding to ping requests, so you only need to override and customize the handler functions relevant to your specific needs.
   Refer to [examples/hello-world-mcp-server/src/handler.rs](https://github.com/rust-mcp-stack/rust-mcp-sdk/tree/main/examples/hello-world-mcp-server/src/handler.rs) for an example.
 
-- **mcp_server_handler_core**: If you need more control over MCP messages, consider using `mcp_server_handler_core`. It offers three primary methods to manage the three MCP message types: `request`, `notification`, and `error`. While still providing type-safe objects in these methods, it allows you to determine how to handle each message based on its type and parameters.  
+- **mcp_server_handler_core**: If you need more control over MCP messages, consider using `mcp_server_handler_core`. It offers three primary methods to manage the three MCP message types: `request`, `notification`, and `error`. While still providing type-safe objects in these methods, it allows you to determine how to handle each message based on its type and parameters.
   Refer to [examples/hello-world-mcp-server-core/src/handler.rs](https://github.com/rust-mcp-stack/rust-mcp-sdk/tree/main/examples/hello-world-mcp-server-core/src/handler.rs) for an example.
 
 ---
@@ -209,8 +209,8 @@ If you are looking for a step-by-step tutorial on how to get started with `rust-
 
 ### Choosing Between `mcp_client_handler` and `mcp_client_handler_core`
 
-The same principles outlined above apply to the client-side handlers, `mcp_client_handler` and `mcp_client_handler_core`.  
-Use `client_runtime::create_client()` or `client_runtime_core::create_client()` , respectively.  
+The same principles outlined above apply to the client-side handlers, `mcp_client_handler` and `mcp_client_handler_core`.
+Use `client_runtime::create_client()` or `client_runtime_core::create_client()` , respectively.
 Check out the corresponding examples at: [examples/simple-mcp-client](https://github.com/rust-mcp-stack/rust-mcp-sdk/tree/main/examples/simple-mcp-client) and [examples/simple-mcp-client-core](https://github.com/rust-mcp-stack/rust-mcp-sdk/tree/main/examples/simple-mcp-client-core).
 
 ## License

crates/rust-mcp-sdk/src/error.rs

@@ -2,10 +2,10 @@ use rust_mcp_schema::JsonrpcErrorError;
 use rust_mcp_transport::error::TransportError;
 use thiserror::Error;
 
-pub type SdkResult<T> = core::result::Result<T, MCPSdkError>;
+pub type SdkResult<T> = core::result::Result<T, McpSdkError>;
 
 #[derive(Debug, Error)]
-pub enum MCPSdkError {
+pub enum McpSdkError {
     #[error("{0}")]
     JsonrpcErrorError(#[from] JsonrpcErrorError),
     #[error("{0}")]
@@ -15,7 +15,7 @@ pub enum MCPSdkError {
     #[error("{0}")]
     AnyErrorStatic(Box<(dyn std::error::Error + Send + Sync + 'static)>),
     #[error("{0}")]
-    AnyError(Box<(dyn std::error::Error + Send + Sync + 'static)>),
+    AnyError(Box<(dyn std::error::Error + Send + Sync)>),
     #[error("{0}")]
     SdkError(#[from] rust_mcp_schema::schema_utils::SdkError),
 }

crates/rust-mcp-sdk/src/mcp_handlers/mcp_client_handler.rs

@@ -7,7 +7,7 @@ use rust_mcp_schema::{
 };
 use serde_json::Value;
 
-use crate::mcp_traits::mcp_client::MCPClient;
+use crate::mcp_traits::mcp_client::McpClient;
 
 /// Defines the `ClientHandler` trait for handling Model Context Protocol (MCP) operations on a client.
 /// This trait provides default implementations for request and notification handlers in an MCP client,
@@ -21,15 +21,15 @@ pub trait ClientHandler: Send + Sync + 'static {
     async fn handle_ping_request(
         &self,
         request: PingRequest,
-        runtime: &dyn MCPClient,
+        runtime: &dyn McpClient,
     ) -> std::result::Result<Result, JsonrpcErrorError> {
         Ok(Result::default())
     }
 
     async fn handle_create_message_request(
         &self,
         request: CreateMessageRequest,
-        runtime: &dyn MCPClient,
+        runtime: &dyn McpClient,
     ) -> std::result::Result<CreateMessageResult, JsonrpcErrorError> {
         runtime.assert_client_request_capabilities(request.method())?;
         Err(JsonrpcErrorError::method_not_found().with_message(format!(
@@ -41,7 +41,7 @@ pub trait ClientHandler: Send + Sync + 'static {
     async fn handle_list_roots_request(
         &self,
         request: ListRootsRequest,
-        runtime: &dyn MCPClient,
+        runtime: &dyn McpClient,
     ) -> std::result::Result<ListRootsResult, JsonrpcErrorError> {
         runtime.assert_client_request_capabilities(request.method())?;
         Err(JsonrpcErrorError::method_not_found().with_message(format!(
@@ -53,7 +53,7 @@ pub trait ClientHandler: Send + Sync + 'static {
     async fn handle_custom_request(
         &self,
         request: Value,
-        runtime: &dyn MCPClient,
+        runtime: &dyn McpClient,
     ) -> std::result::Result<ListRootsResult, JsonrpcErrorError> {
         Err(JsonrpcErrorError::method_not_found()
             .with_message("No handler is implemented for custom requests.".to_string()))
@@ -66,63 +66,63 @@ pub trait ClientHandler: Send + Sync + 'static {
     async fn handle_cancelled_notification(
         &self,
         notification: CancelledNotification,
-        runtime: &dyn MCPClient,
+        runtime: &dyn McpClient,
     ) -> std::result::Result<(), JsonrpcErrorError> {
         Ok(())
     }
 
     async fn handle_progress_notification(
         &self,
         notification: ProgressNotification,
-        runtime: &dyn MCPClient,
+        runtime: &dyn McpClient,
     ) -> std::result::Result<(), JsonrpcErrorError> {
         Ok(())
     }
 
     async fn handle_resource_list_changed_notification(
         &self,
         notification: ResourceListChangedNotification,
-        runtime: &dyn MCPClient,
+        runtime: &dyn McpClient,
     ) -> std::result::Result<(), JsonrpcErrorError> {
         Ok(())
     }
 
     async fn handle_resource_updated_notification(
         &self,
         notification: ResourceUpdatedNotification,
-        runtime: &dyn MCPClient,
+        runtime: &dyn McpClient,
     ) -> std::result::Result<(), JsonrpcErrorError> {
         Ok(())
     }
 
     async fn handle_prompt_list_changed_notification(
         &self,
         notification: PromptListChangedNotification,
-        runtime: &dyn MCPClient,
+        runtime: &dyn McpClient,
     ) -> std::result::Result<(), JsonrpcErrorError> {
         Ok(())
     }
 
     async fn handle_tool_list_changed_notification(
         &self,
         notification: ToolListChangedNotification,
-        runtime: &dyn MCPClient,
+        runtime: &dyn McpClient,
     ) -> std::result::Result<(), JsonrpcErrorError> {
         Ok(())
     }
 
     async fn handle_logging_message_notification(
         &self,
         notification: LoggingMessageNotification,
-        runtime: &dyn MCPClient,
+        runtime: &dyn McpClient,
     ) -> std::result::Result<(), JsonrpcErrorError> {
         Ok(())
     }
 
     async fn handle_custom_notification(
         &self,
         notification: Value,
-        runtime: &dyn MCPClient,
+        runtime: &dyn McpClient,
     ) -> std::result::Result<(), JsonrpcErrorError> {
         Ok(())
     }
@@ -133,15 +133,15 @@ pub trait ClientHandler: Send + Sync + 'static {
     async fn handle_error(
         &self,
         error: JsonrpcErrorError,
-        runtime: &dyn MCPClient,
+        runtime: &dyn McpClient,
     ) -> std::result::Result<(), JsonrpcErrorError> {
         Ok(())
     }
 
     async fn handle_process_error(
         &self,
         error_message: String,
-        runtime: &dyn MCPClient,
+        runtime: &dyn McpClient,
     ) -> std::result::Result<(), JsonrpcErrorError> {
         if !runtime.is_shut_down().await {
             eprintln!("Process error: {}", error_message);

crates/rust-mcp-sdk/src/mcp_handlers/mcp_client_handler_core.rs

@@ -2,7 +2,7 @@ use async_trait::async_trait;
 use rust_mcp_schema::schema_utils::*;
 use rust_mcp_schema::*;
 
-use crate::mcp_traits::mcp_client::MCPClient;
+use crate::mcp_traits::mcp_client::McpClient;
 
 /// Defines the `ClientHandlerCore` trait for handling Model Context Protocol (MCP) client operations.
 /// Unlike `ClientHandler`, this trait offers no default implementations, providing full control over MCP message handling
@@ -19,7 +19,7 @@ pub trait ClientHandlerCore: Send + Sync + 'static {
     async fn handle_request(
         &self,
         request: RequestFromServer,
-        runtime: &dyn MCPClient,
+        runtime: &dyn McpClient,
     ) -> std::result::Result<ResultFromClient, JsonrpcErrorError>;
 
     /// Asynchronously handles an incoming notification from the server.
@@ -29,7 +29,7 @@ pub trait ClientHandlerCore: Send + Sync + 'static {
     async fn handle_notification(
         &self,
         notification: NotificationFromServer,
-        runtime: &dyn MCPClient,
+        runtime: &dyn McpClient,
     ) -> std::result::Result<(), JsonrpcErrorError>;
 
     /// Asynchronously handles an error received from the server.
@@ -39,13 +39,13 @@ pub trait ClientHandlerCore: Send + Sync + 'static {
     async fn handle_error(
         &self,
         error: JsonrpcErrorError,
-        runtime: &dyn MCPClient,
+        runtime: &dyn McpClient,
     ) -> std::result::Result<(), JsonrpcErrorError>;
 
     async fn handle_process_error(
         &self,
         error_message: String,
-        runtime: &dyn MCPClient,
+        runtime: &dyn McpClient,
     ) -> std::result::Result<(), JsonrpcErrorError> {
         if !runtime.is_shut_down().await {
             eprintln!("Process error: {}", error_message);