fix: rename core to spec

Cargo.toml

@@ -3,12 +3,12 @@ members = ["crates/*"]
 resolver = "2"
 
 [workspace.dependencies]
-mcp-core = { path = "./crates/mcp-core" }
-mcp-macros = { path = "./crates/mcp-macros" }
+mcp-spec = { path = "./crates/mcp-spec", version = "0.1.0" }
+mcp-macros = { path = "./crates/mcp-macros", version = "0.1.0" }
 
 [workspace.package]
 edition = "2021"
-version = "1.0.7"
+version = "0.1.0"
 authors = ["Block <[email protected]>"]
 license = "MIT"
 repository = "https://github.com/modelcontextprotocol/rust-sdk/"

crates/mcp-client/Cargo.toml

@@ -7,7 +7,7 @@ repository.workspace = true
 description = "Client SDK for the Model Context Protocol"
 
 [dependencies]
-mcp-core = { workspace = true }
+mcp-spec = { workspace = true }
 tokio = { version = "1", features = ["full"] }
 reqwest = { version = "0.11", default-features = false, features = ["json", "stream", "rustls-tls"] }
 eventsource-client = "0.12.0"

crates/mcp-client/src/client.rs

@@ -1,4 +1,4 @@
-use mcp_core::protocol::{
+use mcp_spec::protocol::{
     CallToolResult, GetPromptResult, Implementation, InitializeResult, JsonRpcError,
     JsonRpcMessage, JsonRpcNotification, JsonRpcRequest, JsonRpcResponse, ListPromptsResult,
     ListResourcesResult, ListToolsResult, ReadResourceResult, ServerCapabilities, METHOD_NOT_FOUND,

crates/mcp-client/src/service.rs

@@ -1,5 +1,5 @@
 use futures::future::BoxFuture;
-use mcp_core::protocol::JsonRpcMessage;
+use mcp_spec::protocol::JsonRpcMessage;
 use std::sync::Arc;
 use std::task::{Context, Poll};
 use tower::{timeout::Timeout, Service, ServiceBuilder};

crates/mcp-client/src/transport/mod.rs

@@ -1,5 +1,5 @@
 use async_trait::async_trait;
-use mcp_core::protocol::JsonRpcMessage;
+use mcp_spec::protocol::JsonRpcMessage;
 use std::collections::HashMap;
 use thiserror::Error;
 use tokio::sync::{mpsc, oneshot, RwLock};

crates/mcp-client/src/transport/sse.rs

@@ -2,7 +2,7 @@ use crate::transport::{Error, PendingRequests, TransportMessage};
 use async_trait::async_trait;
 use eventsource_client::{Client, SSE};
 use futures::TryStreamExt;
-use mcp_core::protocol::{JsonRpcMessage, JsonRpcRequest};
+use mcp_spec::protocol::{JsonRpcMessage, JsonRpcRequest};
 use reqwest::Client as HttpClient;
 use std::collections::HashMap;
 use std::sync::Arc;

crates/mcp-client/src/transport/stdio.rs

@@ -3,7 +3,7 @@ use std::sync::Arc;
 use tokio::process::{Child, ChildStderr, ChildStdin, ChildStdout, Command};
 
 use async_trait::async_trait;
-use mcp_core::protocol::JsonRpcMessage;
+use mcp_spec::protocol::JsonRpcMessage;
 use tokio::io::{AsyncBufReadExt, AsyncReadExt, AsyncWriteExt, BufReader};
 use tokio::sync::{mpsc, Mutex};
 

crates/mcp-macros/Cargo.toml

@@ -1,7 +1,10 @@
 [package]
 name = "mcp-macros"
+license.workspace = true
 version.workspace = true
 edition.workspace = true
+repository.workspace = true
+description = "Macros for Model Context Protocol SDK"
 
 [lib]
 proc-macro = true
@@ -12,7 +15,7 @@ quote = "1.0"
 proc-macro2 = "1.0"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
-mcp-core = { path = "../mcp-core" }
+mcp-spec = { workspace = true }
 async-trait = "0.1"
 schemars = "0.8"
 convert_case = "0.6.0"

crates/mcp-macros/examples/calculator.rs

@@ -1,5 +1,5 @@
-use mcp_core::handler::{ToolError, ToolHandler};
 use mcp_macros::tool;
+use mcp_spec::handler::{ToolError, ToolHandler};
 
 #[tokio::main]
 async fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {

crates/mcp-macros/src/lib.rs

@@ -120,7 +120,7 @@ pub fn tool(args: TokenStream, input: TokenStream) -> TokenStream {
         struct #struct_name;
 
         #[async_trait::async_trait]
-        impl mcp_core::handler::ToolHandler for #struct_name {
+        impl mcp_spec::handler::ToolHandler for #struct_name {
             fn name(&self) -> &'static str {
                 #tool_name
             }
@@ -130,17 +130,17 @@ pub fn tool(args: TokenStream, input: TokenStream) -> TokenStream {
             }
 
             fn schema(&self) -> serde_json::Value {
-                mcp_core::handler::generate_schema::<#params_struct_name>()
+                mcp_spec::handler::generate_schema::<#params_struct_name>()
                     .expect("Failed to generate schema")
             }
 
-            async fn call(&self, params: serde_json::Value) -> Result<serde_json::Value, mcp_core::handler::ToolError> {
+            async fn call(&self, params: serde_json::Value) -> Result<serde_json::Value, mcp_spec::handler::ToolError> {
                 let params: #params_struct_name = serde_json::from_value(params)
-                    .map_err(|e| mcp_core::handler::ToolError::InvalidParameters(e.to_string()))?;
+                    .map_err(|e| mcp_spec::handler::ToolError::InvalidParameters(e.to_string()))?;
 
                 // Extract parameters and call the function
                 let result = #fn_name(#(params.#param_names,)*).await
-                    .map_err(|e| mcp_core::handler::ToolError::ExecutionError(e.to_string()))?;
+                    .map_err(|e| mcp_spec::handler::ToolError::ExecutionError(e.to_string()))?;
 
                 Ok(serde_json::to_value(result).expect("should serialize"))
 

crates/mcp-server/Cargo.toml

@@ -9,7 +9,7 @@ description = "Server SDK for the Model Context Protocol"
 [dependencies]
 anyhow = "1.0.94"
 thiserror = "1.0"
-mcp-core = { workspace = true }
+mcp-spec = { workspace = true }
 mcp-macros = { workspace = true }
 serde = { version = "1.0.216", features = ["derive"] }
 serde_json = "1.0.133"

crates/mcp-server/src/errors.rs

@@ -56,9 +56,9 @@ pub enum RouterError {
     PromptNotFound(String),
 }
 
-impl From<RouterError> for mcp_core::protocol::ErrorData {
+impl From<RouterError> for mcp_spec::protocol::ErrorData {
     fn from(err: RouterError) -> Self {
-        use mcp_core::protocol::*;
+        use mcp_spec::protocol::*;
         match err {
             RouterError::MethodNotFound(msg) => ErrorData {
                 code: METHOD_NOT_FOUND,
@@ -94,10 +94,10 @@ impl From<RouterError> for mcp_core::protocol::ErrorData {
     }
 }
 
-impl From<mcp_core::handler::ResourceError> for RouterError {
-    fn from(err: mcp_core::handler::ResourceError) -> Self {
+impl From<mcp_spec::handler::ResourceError> for RouterError {
+    fn from(err: mcp_spec::handler::ResourceError) -> Self {
         match err {
-            mcp_core::handler::ResourceError::NotFound(msg) => RouterError::ResourceNotFound(msg),
+            mcp_spec::handler::ResourceError::NotFound(msg) => RouterError::ResourceNotFound(msg),
             _ => RouterError::Internal("Unknown resource error".to_string()),
         }
     }

crates/mcp-server/src/lib.rs

@@ -4,7 +4,7 @@ use std::{
 };
 
 use futures::{Future, Stream};
-use mcp_core::protocol::{JsonRpcError, JsonRpcMessage, JsonRpcRequest, JsonRpcResponse};
+use mcp_spec::protocol::{JsonRpcError, JsonRpcMessage, JsonRpcRequest, JsonRpcResponse};
 use pin_project::pin_project;
 use tokio::io::{AsyncBufReadExt, AsyncRead, AsyncWrite, AsyncWriteExt, BufReader};
 use tower_service::Service;
@@ -169,8 +169,8 @@ where
                                         jsonrpc: "2.0".to_string(),
                                         id,
                                         result: None,
-                                        error: Some(mcp_core::protocol::ErrorData {
-                                            code: mcp_core::protocol::INTERNAL_ERROR,
+                                        error: Some(mcp_spec::protocol::ErrorData {
+                                            code: mcp_spec::protocol::INTERNAL_ERROR,
                                             message: error_msg,
                                             data: None,
                                         }),
@@ -208,19 +208,19 @@ where
                     // Convert transport error to JSON-RPC error response
                     let error = match e {
                         TransportError::Json(_) | TransportError::InvalidMessage(_) => {
-                            mcp_core::protocol::ErrorData {
-                                code: mcp_core::protocol::PARSE_ERROR,
+                            mcp_spec::protocol::ErrorData {
+                                code: mcp_spec::protocol::PARSE_ERROR,
                                 message: e.to_string(),
                                 data: None,
                             }
                         }
-                        TransportError::Protocol(_) => mcp_core::protocol::ErrorData {
-                            code: mcp_core::protocol::INVALID_REQUEST,
+                        TransportError::Protocol(_) => mcp_spec::protocol::ErrorData {
+                            code: mcp_spec::protocol::INVALID_REQUEST,
                             message: e.to_string(),
                             data: None,
                         },
-                        _ => mcp_core::protocol::ErrorData {
-                            code: mcp_core::protocol::INTERNAL_ERROR,
+                        _ => mcp_spec::protocol::ErrorData {
+                            code: mcp_spec::protocol::INTERNAL_ERROR,
                             message: e.to_string(),
                             data: None,
                         },

crates/mcp-server/src/main.rs

@@ -1,10 +1,10 @@
 use anyhow::Result;
-use mcp_core::content::Content;
-use mcp_core::handler::{PromptError, ResourceError};
-use mcp_core::prompt::{Prompt, PromptArgument};
-use mcp_core::{handler::ToolError, protocol::ServerCapabilities, resource::Resource, tool::Tool};
 use mcp_server::router::{CapabilitiesBuilder, RouterService};
 use mcp_server::{ByteTransport, Router, Server};
+use mcp_spec::content::Content;
+use mcp_spec::handler::{PromptError, ResourceError};
+use mcp_spec::prompt::{Prompt, PromptArgument};
+use mcp_spec::{handler::ToolError, protocol::ServerCapabilities, resource::Resource, tool::Tool};
 use serde_json::Value;
 use std::{future::Future, pin::Pin, sync::Arc};
 use tokio::{

crates/mcp-server/src/router.rs

@@ -6,7 +6,7 @@ use std::{
 
 type PromptFuture = Pin<Box<dyn Future<Output = Result<String, PromptError>> + Send + 'static>>;
 
-use mcp_core::{
+use mcp_spec::{
     content::Content,
     handler::{PromptError, ResourceError, ToolError},
     prompt::{Prompt, PromptMessage, PromptMessageRole},
@@ -86,13 +86,13 @@ pub trait Router: Send + Sync + 'static {
     // in the protocol, instructions are optional but we make it required
     fn instructions(&self) -> String;
     fn capabilities(&self) -> ServerCapabilities;
-    fn list_tools(&self) -> Vec<mcp_core::tool::Tool>;
+    fn list_tools(&self) -> Vec<mcp_spec::tool::Tool>;
     fn call_tool(
         &self,
         tool_name: &str,
         arguments: Value,
     ) -> Pin<Box<dyn Future<Output = Result<Vec<Content>, ToolError>> + Send + 'static>>;
-    fn list_resources(&self) -> Vec<mcp_core::resource::Resource>;
+    fn list_resources(&self) -> Vec<mcp_spec::resource::Resource>;
     fn read_resource(
         &self,
         uri: &str,

crates/mcp-core/Cargo.toml → crates/mcp-spec/Cargo.toml

@@ -1,5 +1,5 @@
 [package]
-name = "mcp-core"
+name = "mcp-spec"
 license.workspace = true
 version.workspace = true
 edition.workspace = true