refactor(rmcpk-core): migrates model and errors into rmcp-core

Author: Hendler

Cargo.toml

@@ -1,10 +1,11 @@
 
 
 [workspace]
-members = ["crates/rmcp", "crates/rmcp-macros", "examples/*"]
+members = ["crates/rmcp","crates/rmcp-core", "crates/rmcp-macros", "examples/*"]
 resolver = "2"
 
 [workspace.dependencies]
+rmcp-core = { version = "0.1.5", path = "./crates/rmcp-core" }
 rmcp = { version = "0.1.5", path = "./crates/rmcp" }
 rmcp-macros = { version = "0.1.5", path = "./crates/rmcp-macros" }
 

crates/rmcp-core/Cargo.toml

@@ -0,0 +1,49 @@
+[package]
+name = "rmcp-core"
+license = { workspace = true }
+version = { workspace = true }
+edition = { workspace = true }
+repository = { workspace = true }
+homepage = { workspace = true }
+readme = { workspace = true }
+description = "Rust SDK for Model Context Protocol"
+documentation = "https://docs.rs/rmcp"
+
+[package.metadata.docs.rs]
+all-features = true
+
+[dependencies]
+serde = { version = "1.0", features = ["derive", "rc"] }
+serde_json = "1.0"
+thiserror = "2"
+chrono = { version = "0.4.38", features = ["serde"] }
+tokio = { version = "1", features = ["sync", "macros", "rt", "time"] }
+futures = "0.3"
+tracing = { version = "0.1" }
+tokio-util = { version = "0.7" }
+pin-project-lite = "0.2"
+paste = { version = "1", optional = true }
+# for auto generate schema
+schemars = { version = "0.8", optional = true }
+
+# for image encoding
+base64 = { version = "0.22", optional = true }
+ 
+# macro
+rmcp-macros = { version = "0.1", workspace = true, optional = true }
+
+[features]
+default = ["base64", "macros"]
+macros = ["dep:rmcp-macros", "dep:paste"]
+schemars = ["dep:schemars"]
+
+[dev-dependencies]
+tokio = { version = "1", features = ["full"] }
+
+anyhow = "1.0"
+tracing-subscriber = { version = "0.3", features = [
+    "env-filter",
+    "std",
+    "fmt",
+] }
+async-trait = "0.1"

crates/rmcp/src/error.rs renamed to crates/rmcp-core/src/error.rs

@@ -0,0 +1,9 @@
+mod error;
+pub use error::Error;
+
+pub mod model;
+pub use model::*;
+#[cfg(feature = "macros")]
+pub use paste;
+#[cfg(feature = "macros")]
+pub use rmcp_macros::tool;

crates/rmcp-core/src/lib.rs

@@ -45,7 +45,7 @@ macro_rules! object {
     };
 }
 #[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Copy, Eq)]
-#[cfg_attr(feature = "server", derive(schemars::JsonSchema))]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct EmptyObject {}
 
 pub trait ConstString: Default {
@@ -1040,6 +1040,36 @@ impl From<CancelledNotification> for ClientNotification {
     }
 }
 
+pub trait IntoCallToolResult {
+    fn into_call_tool_result(self) -> Result<CallToolResult, crate::Error>;
+}
+impl IntoCallToolResult for () {
+    fn into_call_tool_result(self) -> Result<CallToolResult, crate::Error> {
+        Ok(CallToolResult::success(vec![]))
+    }
+}
+
+impl<T: IntoContents> IntoCallToolResult for T {
+    fn into_call_tool_result(self) -> Result<CallToolResult, crate::Error> {
+        Ok(CallToolResult::success(self.into_contents()))
+    }
+}
+
+impl IntoCallToolResult for Result<CallToolResult, crate::Error> {
+    fn into_call_tool_result(self) -> Result<CallToolResult, crate::Error> {
+        self
+    }
+}
+
+impl<T: IntoContents, E: IntoContents> IntoCallToolResult for Result<T, E> {
+    fn into_call_tool_result(self) -> Result<CallToolResult, crate::Error> {
+        match self {
+            Ok(value) => Ok(CallToolResult::success(value.into_contents())),
+            Err(error) => Ok(CallToolResult::error(error.into_contents())),
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use serde_json::json;

crates/rmcp/src/model.rs renamed to crates/rmcp-core/src/model.rs

@@ -38,7 +38,7 @@ pub struct RootsCapabilities {
 ///
 /// # Builder
 /// ```rust
-/// # use rmcp::model::ClientCapabilities;
+/// # use rmcp_core::model::ClientCapabilities;
 /// let cap = ClientCapabilities::builder()
 ///     .enable_experimental()
 ///     .enable_roots()
@@ -58,7 +58,7 @@ pub struct ClientCapabilities {
 ///
 /// ## Builder
 /// ```rust
-/// # use rmcp::model::ServerCapabilities;
+/// # use rmcp_core::model::ServerCapabilities;
 /// let cap = ServerCapabilities::builder()
 ///     .enable_logging()
 ///     .enable_experimental()

crates/rmcp/src/model/annotated.rs renamed to crates/rmcp-core/src/model/annotated.rs

@@ -61,7 +61,7 @@ impl Extensions {
     /// # Example
     ///
     /// ```
-    /// # use rmcp::model::Extensions;
+    /// # use rmcp_core::model::Extensions;
     /// let mut ext = Extensions::new();
     /// assert!(ext.insert(5i32).is_none());
     /// assert!(ext.insert(4u8).is_none());
@@ -79,7 +79,7 @@ impl Extensions {
     /// # Example
     ///
     /// ```
-    /// # use rmcp::model::Extensions;
+    /// # use rmcp_core::model::Extensions;
     /// let mut ext = Extensions::new();
     /// assert!(ext.get::<i32>().is_none());
     /// ext.insert(5i32);
@@ -98,7 +98,7 @@ impl Extensions {
     /// # Example
     ///
     /// ```
-    /// # use rmcp::model::Extensions;
+    /// # use rmcp_core::model::Extensions;
     /// let mut ext = Extensions::new();
     /// ext.insert(String::from("Hello"));
     /// ext.get_mut::<String>().unwrap().push_str(" World");
@@ -118,7 +118,7 @@ impl Extensions {
     /// # Example
     ///
     /// ```
-    /// # use rmcp::model::Extensions;
+    /// # use rmcp_core::model::Extensions;
     /// let mut ext = Extensions::new();
     /// *ext.get_or_insert(1i32) += 2;
     ///
@@ -134,7 +134,7 @@ impl Extensions {
     /// # Example
     ///
     /// ```
-    /// # use rmcp::model::Extensions;
+    /// # use rmcp_core::model::Extensions;
     /// let mut ext = Extensions::new();
     /// *ext.get_or_insert_with(|| 1i32) += 2;
     ///
@@ -158,7 +158,7 @@ impl Extensions {
     /// # Example
     ///
     /// ```
-    /// # use rmcp::model::Extensions;
+    /// # use rmcp_core::model::Extensions;
     /// let mut ext = Extensions::new();
     /// *ext.get_or_insert_default::<i32>() += 2;
     ///
@@ -175,7 +175,7 @@ impl Extensions {
     /// # Example
     ///
     /// ```
-    /// # use rmcp::model::Extensions;
+    /// # use rmcp_core::model::Extensions;
     /// let mut ext = Extensions::new();
     /// ext.insert(5i32);
     /// assert_eq!(ext.remove::<i32>(), Some(5i32));
@@ -193,7 +193,7 @@ impl Extensions {
     /// # Example
     ///
     /// ```
-    /// # use rmcp::model::Extensions;
+    /// # use rmcp_core::model::Extensions;
     /// let mut ext = Extensions::new();
     /// ext.insert(5i32);
     /// ext.clear();
@@ -212,7 +212,7 @@ impl Extensions {
     /// # Example
     ///
     /// ```
-    /// # use rmcp::model::Extensions;
+    /// # use rmcp_core::model::Extensions;
     /// let mut ext = Extensions::new();
     /// assert!(ext.is_empty());
     /// ext.insert(5i32);
@@ -228,7 +228,7 @@ impl Extensions {
     /// # Example
     ///
     /// ```
-    /// # use rmcp::model::Extensions;
+    /// # use rmcp_core::model::Extensions;
     /// let mut ext = Extensions::new();
     /// assert_eq!(ext.len(), 0);
     /// ext.insert(5i32);
@@ -247,7 +247,7 @@ impl Extensions {
     /// # Example
     ///
     /// ```
-    /// # use rmcp::model::Extensions;
+    /// # use rmcp_core::model::Extensions;
     /// let mut ext_a = Extensions::new();
     /// ext_a.insert(8u8);
     /// ext_a.insert(16u16);

crates/rmcp/src/model/capabilities.rs renamed to crates/rmcp-core/src/model/capabilities.rs

@@ -27,7 +27,7 @@ paste = { version = "1", optional = true }
 schemars = { version = "0.8", optional = true }
 
 # for image encoding
-base64 = { version = "0.21", optional = true }
+base64 = { version = "0.22", optional = true }
 
 # for SSE client
 reqwest = { version = "0.12", default-features = false, features = [
@@ -52,11 +52,12 @@ tokio-stream = { version = "0.1", optional = true }
 
 # macro
 rmcp-macros = { version = "0.1", workspace = true, optional = true }
+rmcp-core = { version = "0.1", workspace = true, optional = true, features = ["schemars"] }
 
 [features]
-default = ["base64", "macros", "server"]
-client = []
-server = ["transport-async-rw", "dep:schemars"]
+default = ["base64", "macros", "server", "dep:rmcp-core"]
+client = ["dep:rmcp-core"]
+server = ["transport-async-rw", "dep:schemars", "dep:rmcp-core"]
 macros = ["dep:rmcp-macros", "dep:paste"]
 transport-sse = ["dep:reqwest", "dep:sse-stream", "dep:url"]
 transport-async-rw = ["tokio/io-util", "tokio-util/codec"]

crates/rmcp/src/model/content.rs renamed to crates/rmcp-core/src/model/content.rs

@@ -1,5 +1,5 @@
 use crate::{
-    error::Error as McpError,
+    Error as McpError,
     model::*,
     service::{Peer, RequestContext, RoleClient, Service, ServiceRole},
 };

crates/rmcp/src/model/extension.rs renamed to crates/rmcp-core/src/model/extension.rs

@@ -1,5 +1,5 @@
 use crate::{
-    error::Error as McpError,
+    Error as McpError,
     model::*,
     service::{Peer, RequestContext, RoleServer, Service, ServiceRole},
 };

crates/rmcp/src/model/meta.rs renamed to crates/rmcp-core/src/model/meta.rs

@@ -9,7 +9,7 @@ use tokio_util::sync::CancellationToken;
 
 use crate::{
     RoleServer,
-    model::{CallToolRequestParam, CallToolResult, ConstString, IntoContents, JsonObject},
+    model::{CallToolRequestParam, CallToolResult, ConstString, IntoCallToolResult, JsonObject},
     service::RequestContext,
 };
 /// A shortcut for generating a JSON schema for a type.
@@ -86,30 +86,6 @@ pub trait FromToolCallContextPart<'a, S>: Sized {
     ) -> Result<(Self, ToolCallContext<'a, S>), crate::Error>;
 }
 
-pub trait IntoCallToolResult {
-    fn into_call_tool_result(self) -> Result<CallToolResult, crate::Error>;
-}
-impl IntoCallToolResult for () {
-    fn into_call_tool_result(self) -> Result<CallToolResult, crate::Error> {
-        Ok(CallToolResult::success(vec![]))
-    }
-}
-
-impl<T: IntoContents> IntoCallToolResult for T {
-    fn into_call_tool_result(self) -> Result<CallToolResult, crate::Error> {
-        Ok(CallToolResult::success(self.into_contents()))
-    }
-}
-
-impl<T: IntoContents, E: IntoContents> IntoCallToolResult for Result<T, E> {
-    fn into_call_tool_result(self) -> Result<CallToolResult, crate::Error> {
-        match self {
-            Ok(value) => Ok(CallToolResult::success(value.into_contents())),
-            Err(error) => Ok(CallToolResult::error(error.into_contents())),
-        }
-    }
-}
-
 pin_project_lite::pin_project! {
     #[project = IntoCallToolResultFutProj]
     pub enum IntoCallToolResultFut<F, R> {
@@ -145,12 +121,6 @@ where
     }
 }
 
-impl IntoCallToolResult for Result<CallToolResult, crate::Error> {
-    fn into_call_tool_result(self) -> Result<CallToolResult, crate::Error> {
-        self
-    }
-}
-
 pub trait CallToolHandler<'a, S, A> {
     type Fut: Future<Output = Result<CallToolResult, crate::Error>> + Send + 'a;
     fn call(self, context: ToolCallContext<'a, S>) -> Self::Fut;

crates/rmcp/src/model/prompt.rs renamed to crates/rmcp-core/src/model/prompt.rs

@@ -1,8 +1,6 @@
-mod error;
-pub use error::Error;
+pub use rmcp_core::{Error, model};
 
 /// Basic data types in MCP specification
-pub mod model;
 #[cfg(any(feature = "client", feature = "server"))]
 pub mod service;
 #[cfg(feature = "client")]

crates/rmcp/src/model/resource.rs renamed to crates/rmcp-core/src/model/resource.rs

@@ -2,7 +2,7 @@ use futures::future::BoxFuture;
 use thiserror::Error;
 
 use crate::{
-    error::Error as McpError,
+    Error as McpError,
     model::{
         CancelledNotification, CancelledNotificationParam, Extensions, GetExtensions, GetMeta,
         JsonRpcBatchRequestItem, JsonRpcBatchResponseItem, JsonRpcError, JsonRpcMessage,

crates/rmcp/src/model/serde_impl.rs renamed to crates/rmcp-core/src/model/serde_impl.rs

@@ -1,6 +1,6 @@
 use rmcp::{
     ServerHandler,
-    model::{ServerCapabilities, ServerInfo},
+    model::{IntoCallToolResult, ServerCapabilities, ServerInfo},
     schemars, tool,
 };
 #[derive(Debug, serde::Deserialize, schemars::JsonSchema)]

crates/rmcp/src/model/tool.rs renamed to crates/rmcp-core/src/model/tool.rs

@@ -1,6 +1,11 @@
 use std::sync::Arc;
 
-use rmcp::{ServerHandler, handler::server::tool::ToolCallContext, tool};
+use rmcp::{
+    ServerHandler,
+    handler::server::tool::ToolCallContext,
+    model::IntoCallToolResult,
+    tool,
+};
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 

crates/rmcp/Cargo.toml

@@ -1,5 +1,3 @@
-
-
 [package]
 name = "mcp-client-examples"
 version = "0.1.5"
@@ -13,12 +11,13 @@ rmcp = { path = "../../crates/rmcp", features = [
     "transport-child-process",
     "tower"
 ] }
+rmcp-core = { path = "../../crates/rmcp-core", features = ["macros"] }
 tokio = { version = "1", features = ["full"] }
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 tracing = "0.1"
 tracing-subscriber = { version = "0.3", features = ["env-filter"] }
-rand = "0.8"
+rand = "0.9"
 futures = "0.3"
 anyhow = "1.0"
 

crates/rmcp/src/handler/client.rs

@@ -2,9 +2,9 @@ use anyhow::Result;
 use rmcp::{
     ServiceExt,
     model::{CallToolRequestParam, GetPromptRequestParam, ReadResourceRequestParam},
-    object,
     transport::TokioChildProcess,
 };
+use rmcp_core::object;
 use tokio::process::Command;
 use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};