feat: update mcp-core prompt to match spec, add mcp list/get to mcp-client

crates/mcp-client/examples/stdio_integration.rs

@@ -82,5 +82,16 @@ async fn main() -> Result<(), ClientError> {
  let resource = client.read_resource("memo://insights").await?;
  println!("Resource: {resource:?}\n");
 
+ let prompts = client.list_prompts(None).await?;
+ println!("Prompts: {prompts:?}\n");
+
+ let prompt = client
+ .get_prompt(
+ "example_prompt",
+ serde_json::json!({"message": "hello there!"}),
+ )
+ .await?;
+ println!("Prompt: {prompt:?}\n");
+
  Ok(())
 }

crates/mcp-client/src/client.rs

@@ -1,7 +1,7 @@
 use mcp_core::protocol::{
- CallToolResult, Implementation, InitializeResult, JsonRpcError, JsonRpcMessage,
- JsonRpcNotification, JsonRpcRequest, JsonRpcResponse, ListResourcesResult, ListToolsResult,
- ReadResourceResult, ServerCapabilities, METHOD_NOT_FOUND,
+ CallToolResult, GetPromptResult, Implementation, InitializeResult, JsonRpcError,
+JsonRpcMessage, JsonRpcNotification, JsonRpcRequest, JsonRpcResponse, ListPromptsResult,
+ListResourcesResult, ListToolsResult, ReadResourceResult, ServerCapabilities, METHOD_NOT_FOUND,
 };
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
@@ -93,6 +93,10 @@ pub trait McpClientTrait: Send + Sync {
  async fn list_tools(&self, next_cursor: Option<String>) -> Result<ListToolsResult, Error>;
 
  async fn call_tool(&self, name: &str, arguments: Value) -> Result<CallToolResult, Error>;
+
+ async fn list_prompts(&self, next_cursor: Option<String>) -> Result<ListPromptsResult, Error>;
+
+ async fn get_prompt(&self, name: &str, arguments: Value) -> Result<GetPromptResult, Error>;
 }
 
 /// The MCP client is the interface for MCP operations.
@@ -346,4 +350,42 @@ where
  // https://modelcontextprotocol.io/docs/concepts/tools#error-handling-2
  self.send_request("tools/call", params).await
  }
+
+ async fn list_prompts(&self, next_cursor: Option<String>) -> Result<ListPromptsResult, Error> {
+ if !self.completed_initialization() {
+ return Err(Error::NotInitialized);
+ }
+
+ // If prompts is not supported, return an error
+ if self.server_capabilities.as_ref().unwrap().prompts.is_none() {
+ return Err(Error::RpcError {
+ code: METHOD_NOT_FOUND,
+ message: "Server does not support 'prompts' capability".to_string(),
+ });
+ }
+
+ let payload = next_cursor
+ .map(|cursor| serde_json::json!({"cursor": cursor}))
+ .unwrap_or_else(|| serde_json::json!({}));
+
+ self.send_request("prompts/list", payload).await
+ }
+
+ async fn get_prompt(&self, name: &str, arguments: Value) -> Result<GetPromptResult, Error> {
+ if !self.completed_initialization() {
+ return Err(Error::NotInitialized);
+ }
+
+ // If prompts is not supported, return an error
+ if self.server_capabilities.as_ref().unwrap().prompts.is_none() {
+ return Err(Error::RpcError {
+ code: METHOD_NOT_FOUND,
+ message: "Server does not support 'prompts' capability".to_string(),
+ });
+ }
+
+ let params = serde_json::json!({ "name": name, "arguments": arguments });
+
+ self.send_request("prompts/get", params).await
+ }
 }

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

@@ -111,13 +111,23 @@ impl SseActor {
  // Attempt to parse the SSE data as a JsonRpcMessage
  match serde_json::from_str::<JsonRpcMessage>(&e.data) {
  Ok(message) => {
- // If it's a response, complete the pending request
- if let JsonRpcMessage::Response(resp) = &message {
- if let Some(id) = &resp.id {
- pending_requests.respond(&id.to_string(), Ok(message)).await;
+ match &message {
+ JsonRpcMessage::Response(response) => {
+ if let Some(id) = &response.id {
+ pending_requests
+ .respond(&id.to_string(), Ok(message))
+ .await;
+ }
  }
+ JsonRpcMessage::Error(error) => {
+ if let Some(id) = &error.id {
+ pending_requests
+ .respond(&id.to_string(), Ok(message))
+ .await;
+ }
+ }
+ _ => {} // TODO: Handle other variants (Request, etc.)
  }
- // If it's something else (notification, etc.), handle as needed
  }
  Err(err) => {
  warn!("Failed to parse SSE message: {err}");

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

@@ -87,10 +87,18 @@ impl StdioActor {
  "Received incoming message"
  );
 
- if let JsonRpcMessage::Response(response) = &message {
- if let Some(id) = &response.id {
- pending_requests.respond(&id.to_string(), Ok(message)).await;
+ match &message {
+ JsonRpcMessage::Response(response) => {
+ if let Some(id) = &response.id {
+ pending_requests.respond(&id.to_string(), Ok(message)).await;
+ }
  }
+ JsonRpcMessage::Error(error) => {
+ if let Some(id) = &error.id {
+ pending_requests.respond(&id.to_string(), Ok(message)).await;
+ }
+ }
+ _ => {} // TODO: Handle other variants (Request, etc.)
  }
  }
  line.clear();

crates/mcp-core/src/prompt.rs

@@ -10,22 +10,28 @@ use serde::{Deserialize, Serialize};
 pub struct Prompt {
  /// The name of the prompt
  pub name: String,
- /// A description of what the prompt does
- pub description: String,
- /// The arguments that can be passed to customize the prompt
- pub arguments: Vec<PromptArgument>,
+ /// Optional description of what the prompt does
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub description: Option<String>,
+ /// Optional arguments that can be passed to customize the prompt
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub arguments: Option<Vec<PromptArgument>>,
 }
 
 impl Prompt {
  /// Create a new prompt with the given name, description and arguments
- pub fn new<N, D>(name: N, description: D, arguments: Vec<PromptArgument>) -> Self
+ pub fn new<N, D>(
+ name: N,
+ description: Option<D>,
+ arguments: Option<Vec<PromptArgument>>,
+ ) -> Self
  where
  N: Into<String>,
  D: Into<String>,
  {
  Prompt {
  name: name.into(),
- description: description.into(),
+ description: description.map(Into::into),
  arguments,
  }
  }
@@ -37,9 +43,11 @@ pub struct PromptArgument {
  /// The name of the argument
  pub name: String,
  /// A description of what the argument is used for
- pub description: String,
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub description: Option<String>,
  /// Whether this argument is required
- pub required: bool,
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub required: Option<bool>,
 }
 
 /// Represents the role of a message sender in a prompt conversation
@@ -151,6 +159,6 @@ pub struct PromptTemplate {
 #[derive(Debug, Serialize, Deserialize)]
 pub struct PromptArgumentTemplate {
  pub name: String,
- pub description: String,
- pub required: bool,
+ pub description: Option<String>,
+ pub required: Option<bool>,
 }

crates/mcp-server/src/main.rs

@@ -1,6 +1,7 @@
 use anyhow::Result;
 use mcp_core::content::Content;
-use mcp_core::handler::ResourceError;
+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};
@@ -61,6 +62,7 @@ impl Router for CounterRouter {
  CapabilitiesBuilder::new()
  .with_tools(false)
  .with_resources(false, false)
+ .with_prompts(false)
  .build()
  }
 
@@ -153,6 +155,37 @@ impl Router for CounterRouter {
  }
  })
  }
+
+ fn list_prompts(&self) -> Vec<Prompt> {
+ vec![Prompt::new(
+ "example_prompt",
+ Some("This is an example prompt that takes one required agrument, message"),
+ Some(vec![PromptArgument {
+ name: "message".to_string(),
+ description: Some("A message to put in the prompt".to_string()),
+ required: Some(true),
+ }]),
+ )]
+ }
+
+ fn get_prompt(
+ &self,
+ prompt_name: &str,
+ ) -> Pin<Box<dyn Future<Output = Result<String, PromptError>> + Send + 'static>> {
+ let prompt_name = prompt_name.to_string();
+ Box::pin(async move {
+ match prompt_name.as_str() {
+ "example_prompt" => {
+ let prompt = "This is an example prompt with your message here: '{message}'";
+ Ok(prompt.to_string())
+ }
+ _ => Err(PromptError::NotFound(format!(
+ "Prompt {} not found",
+ prompt_name
+ ))),
+ }
+ })
+ }
 }
 
 #[tokio::main]

crates/mcp-server/src/router.rs

@@ -97,12 +97,8 @@ pub trait Router: Send + Sync + 'static {
  &self,
  uri: &str,
  ) -> Pin<Box<dyn Future<Output = Result<String, ResourceError>> + Send + 'static>>;
- fn list_prompts(&self) -> Option<Vec<Prompt>> {
- None
- }
- fn get_prompt(&self, _prompt_name: &str) -> Option<PromptFuture> {
- None
- }
+ fn list_prompts(&self) -> Vec<Prompt>;
+ fn get_prompt(&self, prompt_name: &str) -> PromptFuture;
 
  // Helper method to create base response
  fn create_response(&self, id: Option<u64>) -> JsonRpcResponse {
@@ -257,7 +253,7 @@ pub trait Router: Send + Sync + 'static {
  req: JsonRpcRequest,
  ) -> impl Future<Output = Result<JsonRpcResponse, RouterError>> + Send {
  async move {
- let prompts = self.list_prompts().unwrap_or_default();
+ let prompts = self.list_prompts();
 
  let result = ListPromptsResult { prompts };
 
@@ -294,36 +290,36 @@ pub trait Router: Send + Sync + 'static {
  .ok_or_else(|| RouterError::InvalidParams("Missing arguments object".into()))?;
 
  // Fetch the prompt definition first
- let prompt = match self.list_prompts() {
- Some(prompts) => prompts
- .into_iter()
- .find(|p| p.name == prompt_name)
- .ok_or_else(|| {
- RouterError::PromptNotFound(format!("Prompt '{}' not found", prompt_name))
- })?,
- None => return Err(RouterError::PromptNotFound("No prompts available".into())),
- };
+ let prompt = self
+ .list_prompts()
+ .into_iter()
+ .find(|p| p.name == prompt_name)
+ .ok_or_else(|| {
+ RouterError::PromptNotFound(format!("Prompt '{}' not found", prompt_name))
+ })?;
 
  // Validate required arguments
- for arg in &prompt.arguments {
- if arg.required
- && (!arguments.contains_key(&arg.name)
- || arguments
- .get(&arg.name)
- .and_then(Value::as_str)
- .is_none_or(str::is_empty))
- {
- return Err(RouterError::InvalidParams(format!(
- "Missing required argument: '{}'",
- arg.name
- )));
+ if let Some(args) = &prompt.arguments {
+ for arg in args {
+ if arg.required.is_some()
+ && arg.required.unwrap()
+ && (!arguments.contains_key(&arg.name)
+ || arguments
+ .get(&arg.name)
+ .and_then(Value::as_str)
+ .is_none_or(str::is_empty))
+ {
+ return Err(RouterError::InvalidParams(format!(
+ "Missing required argument: '{}'",
+ arg.name
+ )));
+ }
  }
  }
 
  // Now get the prompt content
  let description = self
  .get_prompt(prompt_name)
- .ok_or_else(|| RouterError::PromptNotFound("Prompt not found".into()))?
  .await
  .map_err(|e| RouterError::Internal(e.to_string()))?;
 

crates/mcp-client/examples/stdio_integration.rs

@@ -82,5 +82,16 @@ async fn main() -> Result<(), ClientError> {
  let resource = client.read_resource("memo://insights").await?;
  println!("Resource: {resource:?}\n");
 
+ let prompts = client.list_prompts(None).await?;
+ println!("Prompts: {prompts:?}\n");
+
+ let prompt = client
+ .get_prompt(
+ "example_prompt",
+ serde_json::json!({"message": "hello there!"}),
+ )
+ .await?;
+ println!("Prompt: {prompt:?}\n");
+
  Ok(())
 }

crates/mcp-client/src/client.rs

@@ -1,7 +1,7 @@
 use mcp_core::protocol::{
- CallToolResult, Implementation, InitializeResult, JsonRpcError, JsonRpcMessage,
- JsonRpcNotification, JsonRpcRequest, JsonRpcResponse, ListResourcesResult, ListToolsResult,
- ReadResourceResult, ServerCapabilities, METHOD_NOT_FOUND,
+ CallToolResult, GetPromptResult, Implementation, InitializeResult, JsonRpcError,
+JsonRpcMessage, JsonRpcNotification, JsonRpcRequest, JsonRpcResponse, ListPromptsResult,
+ListResourcesResult, ListToolsResult, ReadResourceResult, ServerCapabilities, METHOD_NOT_FOUND,
 };
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
@@ -93,6 +93,10 @@ pub trait McpClientTrait: Send + Sync {
  async fn list_tools(&self, next_cursor: Option<String>) -> Result<ListToolsResult, Error>;
 
  async fn call_tool(&self, name: &str, arguments: Value) -> Result<CallToolResult, Error>;
+
+ async fn list_prompts(&self, next_cursor: Option<String>) -> Result<ListPromptsResult, Error>;
+
+ async fn get_prompt(&self, name: &str, arguments: Value) -> Result<GetPromptResult, Error>;
 }
 
 /// The MCP client is the interface for MCP operations.
@@ -346,4 +350,42 @@ where
  // https://modelcontextprotocol.io/docs/concepts/tools#error-handling-2
  self.send_request("tools/call", params).await
  }
+
+ async fn list_prompts(&self, next_cursor: Option<String>) -> Result<ListPromptsResult, Error> {
+ if !self.completed_initialization() {
+ return Err(Error::NotInitialized);
+ }
+
+ // If prompts is not supported, return an error
+ if self.server_capabilities.as_ref().unwrap().prompts.is_none() {
+ return Err(Error::RpcError {
+ code: METHOD_NOT_FOUND,
+ message: "Server does not support 'prompts' capability".to_string(),
+ });
+ }
+
+ let payload = next_cursor
+ .map(|cursor| serde_json::json!({"cursor": cursor}))
+ .unwrap_or_else(|| serde_json::json!({}));
+
+ self.send_request("prompts/list", payload).await
+ }
+
+ async fn get_prompt(&self, name: &str, arguments: Value) -> Result<GetPromptResult, Error> {
+ if !self.completed_initialization() {
+ return Err(Error::NotInitialized);
+ }
+
+ // If prompts is not supported, return an error
+ if self.server_capabilities.as_ref().unwrap().prompts.is_none() {
+ return Err(Error::RpcError {
+ code: METHOD_NOT_FOUND,
+ message: "Server does not support 'prompts' capability".to_string(),
+ });
+ }
+
+ let params = serde_json::json!({ "name": name, "arguments": arguments });
+
+ self.send_request("prompts/get", params).await
+ }
 }

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

@@ -111,13 +111,23 @@ impl SseActor {
  // Attempt to parse the SSE data as a JsonRpcMessage
  match serde_json::from_str::<JsonRpcMessage>(&e.data) {
  Ok(message) => {
- // If it's a response, complete the pending request
- if let JsonRpcMessage::Response(resp) = &message {
- if let Some(id) = &resp.id {
- pending_requests.respond(&id.to_string(), Ok(message)).await;
+ match &message {
+ JsonRpcMessage::Response(response) => {
+ if let Some(id) = &response.id {
+ pending_requests
+ .respond(&id.to_string(), Ok(message))
+ .await;
+ }
  }
+ JsonRpcMessage::Error(error) => {
+ if let Some(id) = &error.id {
+ pending_requests
+ .respond(&id.to_string(), Ok(message))
+ .await;
+ }
+ }
+ _ => {} // TODO: Handle other variants (Request, etc.)
  }
- // If it's something else (notification, etc.), handle as needed
  }
  Err(err) => {
  warn!("Failed to parse SSE message: {err}");

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

@@ -87,10 +87,18 @@ impl StdioActor {
  "Received incoming message"
  );
 
- if let JsonRpcMessage::Response(response) = &message {
- if let Some(id) = &response.id {
- pending_requests.respond(&id.to_string(), Ok(message)).await;
+ match &message {
+ JsonRpcMessage::Response(response) => {
+ if let Some(id) = &response.id {
+ pending_requests.respond(&id.to_string(), Ok(message)).await;
+ }
  }
+ JsonRpcMessage::Error(error) => {
+ if let Some(id) = &error.id {
+ pending_requests.respond(&id.to_string(), Ok(message)).await;
+ }
+ }
+ _ => {} // TODO: Handle other variants (Request, etc.)
  }
  }
  line.clear();

crates/mcp-core/src/prompt.rs

@@ -10,22 +10,28 @@ use serde::{Deserialize, Serialize};
 pub struct Prompt {
  /// The name of the prompt
  pub name: String,
- /// A description of what the prompt does
- pub description: String,
- /// The arguments that can be passed to customize the prompt
- pub arguments: Vec<PromptArgument>,
+ /// Optional description of what the prompt does
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub description: Option<String>,
+ /// Optional arguments that can be passed to customize the prompt
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub arguments: Option<Vec<PromptArgument>>,
 }
 
 impl Prompt {
  /// Create a new prompt with the given name, description and arguments
- pub fn new<N, D>(name: N, description: D, arguments: Vec<PromptArgument>) -> Self
+ pub fn new<N, D>(
+ name: N,
+ description: Option<D>,
+ arguments: Option<Vec<PromptArgument>>,
+ ) -> Self
  where
  N: Into<String>,
  D: Into<String>,
  {
  Prompt {
  name: name.into(),
- description: description.into(),
+ description: description.map(Into::into),
  arguments,
  }
  }
@@ -37,9 +43,11 @@ pub struct PromptArgument {
  /// The name of the argument
  pub name: String,
  /// A description of what the argument is used for
- pub description: String,
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub description: Option<String>,
  /// Whether this argument is required
- pub required: bool,
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub required: Option<bool>,
 }
 
 /// Represents the role of a message sender in a prompt conversation
@@ -151,6 +159,6 @@ pub struct PromptTemplate {
 #[derive(Debug, Serialize, Deserialize)]
 pub struct PromptArgumentTemplate {
  pub name: String,
- pub description: String,
- pub required: bool,
+ pub description: Option<String>,
+ pub required: Option<bool>,
 }

crates/mcp-server/src/main.rs

@@ -1,6 +1,7 @@
 use anyhow::Result;
 use mcp_core::content::Content;
-use mcp_core::handler::ResourceError;
+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};
@@ -61,6 +62,7 @@ impl Router for CounterRouter {
  CapabilitiesBuilder::new()
  .with_tools(false)
  .with_resources(false, false)
+ .with_prompts(false)
  .build()
  }
 
@@ -153,6 +155,37 @@ impl Router for CounterRouter {
  }
  })
  }
+
+ fn list_prompts(&self) -> Vec<Prompt> {
+ vec![Prompt::new(
+ "example_prompt",
+ Some("This is an example prompt that takes one required agrument, message"),
+ Some(vec![PromptArgument {
+ name: "message".to_string(),
+ description: Some("A message to put in the prompt".to_string()),
+ required: Some(true),
+ }]),
+ )]
+ }
+
+ fn get_prompt(
+ &self,
+ prompt_name: &str,
+ ) -> Pin<Box<dyn Future<Output = Result<String, PromptError>> + Send + 'static>> {
+ let prompt_name = prompt_name.to_string();
+ Box::pin(async move {
+ match prompt_name.as_str() {
+ "example_prompt" => {
+ let prompt = "This is an example prompt with your message here: '{message}'";
+ Ok(prompt.to_string())
+ }
+ _ => Err(PromptError::NotFound(format!(
+ "Prompt {} not found",
+ prompt_name
+ ))),
+ }
+ })
+ }
 }
 
 #[tokio::main]

crates/mcp-server/src/router.rs

@@ -97,12 +97,8 @@ pub trait Router: Send + Sync + 'static {
  &self,
  uri: &str,
  ) -> Pin<Box<dyn Future<Output = Result<String, ResourceError>> + Send + 'static>>;
- fn list_prompts(&self) -> Option<Vec<Prompt>> {
- None
- }
- fn get_prompt(&self, _prompt_name: &str) -> Option<PromptFuture> {
- None
- }
+ fn list_prompts(&self) -> Vec<Prompt>;
+ fn get_prompt(&self, prompt_name: &str) -> PromptFuture;
 
  // Helper method to create base response
  fn create_response(&self, id: Option<u64>) -> JsonRpcResponse {
@@ -257,7 +253,7 @@ pub trait Router: Send + Sync + 'static {
  req: JsonRpcRequest,
  ) -> impl Future<Output = Result<JsonRpcResponse, RouterError>> + Send {
  async move {
- let prompts = self.list_prompts().unwrap_or_default();
+ let prompts = self.list_prompts();
 
  let result = ListPromptsResult { prompts };
 
@@ -294,36 +290,36 @@ pub trait Router: Send + Sync + 'static {
  .ok_or_else(|| RouterError::InvalidParams("Missing arguments object".into()))?;
 
  // Fetch the prompt definition first
- let prompt = match self.list_prompts() {
- Some(prompts) => prompts
- .into_iter()
- .find(|p| p.name == prompt_name)
- .ok_or_else(|| {
- RouterError::PromptNotFound(format!("Prompt '{}' not found", prompt_name))
- })?,
- None => return Err(RouterError::PromptNotFound("No prompts available".into())),
- };
+ let prompt = self
+ .list_prompts()
+ .into_iter()
+ .find(|p| p.name == prompt_name)
+ .ok_or_else(|| {
+ RouterError::PromptNotFound(format!("Prompt '{}' not found", prompt_name))
+ })?;
 
  // Validate required arguments
- for arg in &prompt.arguments {
- if arg.required
- && (!arguments.contains_key(&arg.name)
- || arguments
- .get(&arg.name)
- .and_then(Value::as_str)
- .is_none_or(str::is_empty))
- {
- return Err(RouterError::InvalidParams(format!(
- "Missing required argument: '{}'",
- arg.name
- )));
+ if let Some(args) = &prompt.arguments {
+ for arg in args {
+ if arg.required.is_some()
+ && arg.required.unwrap()
+ && (!arguments.contains_key(&arg.name)
+ || arguments
+ .get(&arg.name)
+ .and_then(Value::as_str)
+ .is_none_or(str::is_empty))
+ {
+ return Err(RouterError::InvalidParams(format!(
+ "Missing required argument: '{}'",
+ arg.name
+ )));
+ }
  }
  }
 
  // Now get the prompt content
  let description = self
  .get_prompt(prompt_name)
- .ok_or_else(|| RouterError::PromptNotFound("Prompt not found".into()))?
  .await
  .map_err(|e| RouterError::Internal(e.to_string()))?;
 

crates/mcp-client/examples/stdio_integration.rs

@@ -82,5 +82,16 @@ async fn main() -> Result<(), ClientError> {
  let resource = client.read_resource("memo://insights").await?;
  println!("Resource: {resource:?}\n");
 
+ let prompts = client.list_prompts(None).await?;
+ println!("Prompts: {prompts:?}\n");
+
+ let prompt = client
+ .get_prompt(
+ "example_prompt",
+ serde_json::json!({"message": "hello there!"}),
+ )
+ .await?;
+ println!("Prompt: {prompt:?}\n");
+
  Ok(())
 }

crates/mcp-client/src/client.rs

@@ -1,7 +1,7 @@
 use mcp_core::protocol::{
- CallToolResult, Implementation, InitializeResult, JsonRpcError, JsonRpcMessage,
- JsonRpcNotification, JsonRpcRequest, JsonRpcResponse, ListResourcesResult, ListToolsResult,
- ReadResourceResult, ServerCapabilities, METHOD_NOT_FOUND,
+ CallToolResult, GetPromptResult, Implementation, InitializeResult, JsonRpcError,
+JsonRpcMessage, JsonRpcNotification, JsonRpcRequest, JsonRpcResponse, ListPromptsResult,
+ListResourcesResult, ListToolsResult, ReadResourceResult, ServerCapabilities, METHOD_NOT_FOUND,
 };
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
@@ -93,6 +93,10 @@ pub trait McpClientTrait: Send + Sync {
  async fn list_tools(&self, next_cursor: Option<String>) -> Result<ListToolsResult, Error>;
 
  async fn call_tool(&self, name: &str, arguments: Value) -> Result<CallToolResult, Error>;
+
+ async fn list_prompts(&self, next_cursor: Option<String>) -> Result<ListPromptsResult, Error>;
+
+ async fn get_prompt(&self, name: &str, arguments: Value) -> Result<GetPromptResult, Error>;
 }
 
 /// The MCP client is the interface for MCP operations.
@@ -346,4 +350,42 @@ where
  // https://modelcontextprotocol.io/docs/concepts/tools#error-handling-2
  self.send_request("tools/call", params).await
  }
+
+ async fn list_prompts(&self, next_cursor: Option<String>) -> Result<ListPromptsResult, Error> {
+ if !self.completed_initialization() {
+ return Err(Error::NotInitialized);
+ }
+
+ // If prompts is not supported, return an error
+ if self.server_capabilities.as_ref().unwrap().prompts.is_none() {
+ return Err(Error::RpcError {
+ code: METHOD_NOT_FOUND,
+ message: "Server does not support 'prompts' capability".to_string(),
+ });
+ }
+
+ let payload = next_cursor
+ .map(|cursor| serde_json::json!({"cursor": cursor}))
+ .unwrap_or_else(|| serde_json::json!({}));
+
+ self.send_request("prompts/list", payload).await
+ }
+
+ async fn get_prompt(&self, name: &str, arguments: Value) -> Result<GetPromptResult, Error> {
+ if !self.completed_initialization() {
+ return Err(Error::NotInitialized);
+ }
+
+ // If prompts is not supported, return an error
+ if self.server_capabilities.as_ref().unwrap().prompts.is_none() {
+ return Err(Error::RpcError {
+ code: METHOD_NOT_FOUND,
+ message: "Server does not support 'prompts' capability".to_string(),
+ });
+ }
+
+ let params = serde_json::json!({ "name": name, "arguments": arguments });
+
+ self.send_request("prompts/get", params).await
+ }
 }

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

@@ -111,13 +111,23 @@ impl SseActor {
  // Attempt to parse the SSE data as a JsonRpcMessage
  match serde_json::from_str::<JsonRpcMessage>(&e.data) {
  Ok(message) => {
- // If it's a response, complete the pending request
- if let JsonRpcMessage::Response(resp) = &message {
- if let Some(id) = &resp.id {
- pending_requests.respond(&id.to_string(), Ok(message)).await;
+ match &message {
+ JsonRpcMessage::Response(response) => {
+ if let Some(id) = &response.id {
+ pending_requests
+ .respond(&id.to_string(), Ok(message))
+ .await;
+ }
  }
+ JsonRpcMessage::Error(error) => {
+ if let Some(id) = &error.id {
+ pending_requests
+ .respond(&id.to_string(), Ok(message))
+ .await;
+ }
+ }
+ _ => {} // TODO: Handle other variants (Request, etc.)
  }
- // If it's something else (notification, etc.), handle as needed
  }
  Err(err) => {
  warn!("Failed to parse SSE message: {err}");

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

@@ -87,10 +87,18 @@ impl StdioActor {
  "Received incoming message"
  );
 
- if let JsonRpcMessage::Response(response) = &message {
- if let Some(id) = &response.id {
- pending_requests.respond(&id.to_string(), Ok(message)).await;
+ match &message {
+ JsonRpcMessage::Response(response) => {
+ if let Some(id) = &response.id {
+ pending_requests.respond(&id.to_string(), Ok(message)).await;
+ }
  }
+ JsonRpcMessage::Error(error) => {
+ if let Some(id) = &error.id {
+ pending_requests.respond(&id.to_string(), Ok(message)).await;
+ }
+ }
+ _ => {} // TODO: Handle other variants (Request, etc.)
  }
  }
  line.clear();

crates/mcp-core/src/prompt.rs

@@ -10,22 +10,28 @@ use serde::{Deserialize, Serialize};
 pub struct Prompt {
  /// The name of the prompt
  pub name: String,
- /// A description of what the prompt does
- pub description: String,
- /// The arguments that can be passed to customize the prompt
- pub arguments: Vec<PromptArgument>,
+ /// Optional description of what the prompt does
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub description: Option<String>,
+ /// Optional arguments that can be passed to customize the prompt
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub arguments: Option<Vec<PromptArgument>>,
 }
 
 impl Prompt {
  /// Create a new prompt with the given name, description and arguments
- pub fn new<N, D>(name: N, description: D, arguments: Vec<PromptArgument>) -> Self
+ pub fn new<N, D>(
+ name: N,
+ description: Option<D>,
+ arguments: Option<Vec<PromptArgument>>,
+ ) -> Self
  where
  N: Into<String>,
  D: Into<String>,
  {
  Prompt {
  name: name.into(),
- description: description.into(),
+ description: description.map(Into::into),
  arguments,
  }
  }
@@ -37,9 +43,11 @@ pub struct PromptArgument {
  /// The name of the argument
  pub name: String,
  /// A description of what the argument is used for
- pub description: String,
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub description: Option<String>,
  /// Whether this argument is required
- pub required: bool,
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub required: Option<bool>,
 }
 
 /// Represents the role of a message sender in a prompt conversation
@@ -151,6 +159,6 @@ pub struct PromptTemplate {
 #[derive(Debug, Serialize, Deserialize)]
 pub struct PromptArgumentTemplate {
  pub name: String,
- pub description: String,
- pub required: bool,
+ pub description: Option<String>,
+ pub required: Option<bool>,
 }

crates/mcp-server/src/main.rs

@@ -1,6 +1,7 @@
 use anyhow::Result;
 use mcp_core::content::Content;
-use mcp_core::handler::ResourceError;
+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};
@@ -61,6 +62,7 @@ impl Router for CounterRouter {
  CapabilitiesBuilder::new()
  .with_tools(false)
  .with_resources(false, false)
+ .with_prompts(false)
  .build()
  }
 
@@ -153,6 +155,37 @@ impl Router for CounterRouter {
  }
  })
  }
+
+ fn list_prompts(&self) -> Vec<Prompt> {
+ vec![Prompt::new(
+ "example_prompt",
+ Some("This is an example prompt that takes one required agrument, message"),
+ Some(vec![PromptArgument {
+ name: "message".to_string(),
+ description: Some("A message to put in the prompt".to_string()),
+ required: Some(true),
+ }]),
+ )]
+ }
+
+ fn get_prompt(
+ &self,
+ prompt_name: &str,
+ ) -> Pin<Box<dyn Future<Output = Result<String, PromptError>> + Send + 'static>> {
+ let prompt_name = prompt_name.to_string();
+ Box::pin(async move {
+ match prompt_name.as_str() {
+ "example_prompt" => {
+ let prompt = "This is an example prompt with your message here: '{message}'";
+ Ok(prompt.to_string())
+ }
+ _ => Err(PromptError::NotFound(format!(
+ "Prompt {} not found",
+ prompt_name
+ ))),
+ }
+ })
+ }
 }
 
 #[tokio::main]

crates/mcp-server/src/router.rs

@@ -97,12 +97,8 @@ pub trait Router: Send + Sync + 'static {
  &self,
  uri: &str,
  ) -> Pin<Box<dyn Future<Output = Result<String, ResourceError>> + Send + 'static>>;
- fn list_prompts(&self) -> Option<Vec<Prompt>> {
- None
- }
- fn get_prompt(&self, _prompt_name: &str) -> Option<PromptFuture> {
- None
- }
+ fn list_prompts(&self) -> Vec<Prompt>;
+ fn get_prompt(&self, prompt_name: &str) -> PromptFuture;
 
  // Helper method to create base response
  fn create_response(&self, id: Option<u64>) -> JsonRpcResponse {
@@ -257,7 +253,7 @@ pub trait Router: Send + Sync + 'static {
  req: JsonRpcRequest,
  ) -> impl Future<Output = Result<JsonRpcResponse, RouterError>> + Send {
  async move {
- let prompts = self.list_prompts().unwrap_or_default();
+ let prompts = self.list_prompts();
 
  let result = ListPromptsResult { prompts };
 
@@ -294,36 +290,36 @@ pub trait Router: Send + Sync + 'static {
  .ok_or_else(|| RouterError::InvalidParams("Missing arguments object".into()))?;
 
  // Fetch the prompt definition first
- let prompt = match self.list_prompts() {
- Some(prompts) => prompts
- .into_iter()
- .find(|p| p.name == prompt_name)
- .ok_or_else(|| {
- RouterError::PromptNotFound(format!("Prompt '{}' not found", prompt_name))
- })?,
- None => return Err(RouterError::PromptNotFound("No prompts available".into())),
- };
+ let prompt = self
+ .list_prompts()
+ .into_iter()
+ .find(|p| p.name == prompt_name)
+ .ok_or_else(|| {
+ RouterError::PromptNotFound(format!("Prompt '{}' not found", prompt_name))
+ })?;
 
  // Validate required arguments
- for arg in &prompt.arguments {
- if arg.required
- && (!arguments.contains_key(&arg.name)
- || arguments
- .get(&arg.name)
- .and_then(Value::as_str)
- .is_none_or(str::is_empty))
- {
- return Err(RouterError::InvalidParams(format!(
- "Missing required argument: '{}'",
- arg.name
- )));
+ if let Some(args) = &prompt.arguments {
+ for arg in args {
+ if arg.required.is_some()
+ && arg.required.unwrap()
+ && (!arguments.contains_key(&arg.name)
+ || arguments
+ .get(&arg.name)
+ .and_then(Value::as_str)
+ .is_none_or(str::is_empty))
+ {
+ return Err(RouterError::InvalidParams(format!(
+ "Missing required argument: '{}'",
+ arg.name
+ )));
+ }
  }
  }
 
  // Now get the prompt content
  let description = self
  .get_prompt(prompt_name)
- .ok_or_else(|| RouterError::PromptNotFound("Prompt not found".into()))?
  .await
  .map_err(|e| RouterError::Internal(e.to_string()))?;
 

crates/mcp-client/examples/stdio_integration.rs

@@ -82,5 +82,16 @@ async fn main() -> Result<(), ClientError> {
  let resource = client.read_resource("memo://insights").await?;
  println!("Resource: {resource:?}\n");
 
+ let prompts = client.list_prompts(None).await?;
+ println!("Prompts: {prompts:?}\n");
+
+ let prompt = client
+ .get_prompt(
+ "example_prompt",
+ serde_json::json!({"message": "hello there!"}),
+ )
+ .await?;
+ println!("Prompt: {prompt:?}\n");
+
  Ok(())
 }

crates/mcp-client/src/client.rs

@@ -1,7 +1,7 @@
 use mcp_core::protocol::{
- CallToolResult, Implementation, InitializeResult, JsonRpcError, JsonRpcMessage,
- JsonRpcNotification, JsonRpcRequest, JsonRpcResponse, ListResourcesResult, ListToolsResult,
- ReadResourceResult, ServerCapabilities, METHOD_NOT_FOUND,
+ CallToolResult, GetPromptResult, Implementation, InitializeResult, JsonRpcError,
+JsonRpcMessage, JsonRpcNotification, JsonRpcRequest, JsonRpcResponse, ListPromptsResult,
+ListResourcesResult, ListToolsResult, ReadResourceResult, ServerCapabilities, METHOD_NOT_FOUND,
 };
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
@@ -93,6 +93,10 @@ pub trait McpClientTrait: Send + Sync {
  async fn list_tools(&self, next_cursor: Option<String>) -> Result<ListToolsResult, Error>;
 
  async fn call_tool(&self, name: &str, arguments: Value) -> Result<CallToolResult, Error>;
+
+ async fn list_prompts(&self, next_cursor: Option<String>) -> Result<ListPromptsResult, Error>;
+
+ async fn get_prompt(&self, name: &str, arguments: Value) -> Result<GetPromptResult, Error>;
 }
 
 /// The MCP client is the interface for MCP operations.
@@ -346,4 +350,42 @@ where
  // https://modelcontextprotocol.io/docs/concepts/tools#error-handling-2
  self.send_request("tools/call", params).await
  }
+
+ async fn list_prompts(&self, next_cursor: Option<String>) -> Result<ListPromptsResult, Error> {
+ if !self.completed_initialization() {
+ return Err(Error::NotInitialized);
+ }
+
+ // If prompts is not supported, return an error
+ if self.server_capabilities.as_ref().unwrap().prompts.is_none() {
+ return Err(Error::RpcError {
+ code: METHOD_NOT_FOUND,
+ message: "Server does not support 'prompts' capability".to_string(),
+ });
+ }
+
+ let payload = next_cursor
+ .map(|cursor| serde_json::json!({"cursor": cursor}))
+ .unwrap_or_else(|| serde_json::json!({}));
+
+ self.send_request("prompts/list", payload).await
+ }
+
+ async fn get_prompt(&self, name: &str, arguments: Value) -> Result<GetPromptResult, Error> {
+ if !self.completed_initialization() {
+ return Err(Error::NotInitialized);
+ }
+
+ // If prompts is not supported, return an error
+ if self.server_capabilities.as_ref().unwrap().prompts.is_none() {
+ return Err(Error::RpcError {
+ code: METHOD_NOT_FOUND,
+ message: "Server does not support 'prompts' capability".to_string(),
+ });
+ }
+
+ let params = serde_json::json!({ "name": name, "arguments": arguments });
+
+ self.send_request("prompts/get", params).await
+ }
 }

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

@@ -111,13 +111,23 @@ impl SseActor {
  // Attempt to parse the SSE data as a JsonRpcMessage
  match serde_json::from_str::<JsonRpcMessage>(&e.data) {
  Ok(message) => {
- // If it's a response, complete the pending request
- if let JsonRpcMessage::Response(resp) = &message {
- if let Some(id) = &resp.id {
- pending_requests.respond(&id.to_string(), Ok(message)).await;
+ match &message {
+ JsonRpcMessage::Response(response) => {
+ if let Some(id) = &response.id {
+ pending_requests
+ .respond(&id.to_string(), Ok(message))
+ .await;
+ }
  }
+ JsonRpcMessage::Error(error) => {
+ if let Some(id) = &error.id {
+ pending_requests
+ .respond(&id.to_string(), Ok(message))
+ .await;
+ }
+ }
+ _ => {} // TODO: Handle other variants (Request, etc.)
  }
- // If it's something else (notification, etc.), handle as needed
  }
  Err(err) => {
  warn!("Failed to parse SSE message: {err}");

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

@@ -87,10 +87,18 @@ impl StdioActor {
  "Received incoming message"
  );
 
- if let JsonRpcMessage::Response(response) = &message {
- if let Some(id) = &response.id {
- pending_requests.respond(&id.to_string(), Ok(message)).await;
+ match &message {
+ JsonRpcMessage::Response(response) => {
+ if let Some(id) = &response.id {
+ pending_requests.respond(&id.to_string(), Ok(message)).await;
+ }
  }
+ JsonRpcMessage::Error(error) => {
+ if let Some(id) = &error.id {
+ pending_requests.respond(&id.to_string(), Ok(message)).await;
+ }
+ }
+ _ => {} // TODO: Handle other variants (Request, etc.)
  }
  }
  line.clear();

crates/mcp-core/src/prompt.rs

@@ -10,22 +10,28 @@ use serde::{Deserialize, Serialize};
 pub struct Prompt {
  /// The name of the prompt
  pub name: String,
- /// A description of what the prompt does
- pub description: String,
- /// The arguments that can be passed to customize the prompt
- pub arguments: Vec<PromptArgument>,
+ /// Optional description of what the prompt does
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub description: Option<String>,
+ /// Optional arguments that can be passed to customize the prompt
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub arguments: Option<Vec<PromptArgument>>,
 }
 
 impl Prompt {
  /// Create a new prompt with the given name, description and arguments
- pub fn new<N, D>(name: N, description: D, arguments: Vec<PromptArgument>) -> Self
+ pub fn new<N, D>(
+ name: N,
+ description: Option<D>,
+ arguments: Option<Vec<PromptArgument>>,
+ ) -> Self
  where
  N: Into<String>,
  D: Into<String>,
  {
  Prompt {
  name: name.into(),
- description: description.into(),
+ description: description.map(Into::into),
  arguments,
  }
  }
@@ -37,9 +43,11 @@ pub struct PromptArgument {
  /// The name of the argument
  pub name: String,
  /// A description of what the argument is used for
- pub description: String,
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub description: Option<String>,
  /// Whether this argument is required
- pub required: bool,
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub required: Option<bool>,
 }
 
 /// Represents the role of a message sender in a prompt conversation
@@ -151,6 +159,6 @@ pub struct PromptTemplate {
 #[derive(Debug, Serialize, Deserialize)]
 pub struct PromptArgumentTemplate {
  pub name: String,
- pub description: String,
- pub required: bool,
+ pub description: Option<String>,
+ pub required: Option<bool>,
 }

crates/mcp-server/src/main.rs

@@ -1,6 +1,7 @@
 use anyhow::Result;
 use mcp_core::content::Content;
-use mcp_core::handler::ResourceError;
+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};
@@ -61,6 +62,7 @@ impl Router for CounterRouter {
  CapabilitiesBuilder::new()
  .with_tools(false)
  .with_resources(false, false)
+ .with_prompts(false)
  .build()
  }
 
@@ -153,6 +155,37 @@ impl Router for CounterRouter {
  }
  })
  }
+
+ fn list_prompts(&self) -> Vec<Prompt> {
+ vec![Prompt::new(
+ "example_prompt",
+ Some("This is an example prompt that takes one required agrument, message"),
+ Some(vec![PromptArgument {
+ name: "message".to_string(),
+ description: Some("A message to put in the prompt".to_string()),
+ required: Some(true),
+ }]),
+ )]
+ }
+
+ fn get_prompt(
+ &self,
+ prompt_name: &str,
+ ) -> Pin<Box<dyn Future<Output = Result<String, PromptError>> + Send + 'static>> {
+ let prompt_name = prompt_name.to_string();
+ Box::pin(async move {
+ match prompt_name.as_str() {
+ "example_prompt" => {
+ let prompt = "This is an example prompt with your message here: '{message}'";
+ Ok(prompt.to_string())
+ }
+ _ => Err(PromptError::NotFound(format!(
+ "Prompt {} not found",
+ prompt_name
+ ))),
+ }
+ })
+ }
 }
 
 #[tokio::main]

crates/mcp-server/src/router.rs

@@ -97,12 +97,8 @@ pub trait Router: Send + Sync + 'static {
  &self,
  uri: &str,
  ) -> Pin<Box<dyn Future<Output = Result<String, ResourceError>> + Send + 'static>>;
- fn list_prompts(&self) -> Option<Vec<Prompt>> {
- None
- }
- fn get_prompt(&self, _prompt_name: &str) -> Option<PromptFuture> {
- None
- }
+ fn list_prompts(&self) -> Vec<Prompt>;
+ fn get_prompt(&self, prompt_name: &str) -> PromptFuture;
 
  // Helper method to create base response
  fn create_response(&self, id: Option<u64>) -> JsonRpcResponse {
@@ -257,7 +253,7 @@ pub trait Router: Send + Sync + 'static {
  req: JsonRpcRequest,
  ) -> impl Future<Output = Result<JsonRpcResponse, RouterError>> + Send {
  async move {
- let prompts = self.list_prompts().unwrap_or_default();
+ let prompts = self.list_prompts();
 
  let result = ListPromptsResult { prompts };
 
@@ -294,36 +290,36 @@ pub trait Router: Send + Sync + 'static {
  .ok_or_else(|| RouterError::InvalidParams("Missing arguments object".into()))?;
 
  // Fetch the prompt definition first
- let prompt = match self.list_prompts() {
- Some(prompts) => prompts
- .into_iter()
- .find(|p| p.name == prompt_name)
- .ok_or_else(|| {
- RouterError::PromptNotFound(format!("Prompt '{}' not found", prompt_name))
- })?,
- None => return Err(RouterError::PromptNotFound("No prompts available".into())),
- };
+ let prompt = self
+ .list_prompts()
+ .into_iter()
+ .find(|p| p.name == prompt_name)
+ .ok_or_else(|| {
+ RouterError::PromptNotFound(format!("Prompt '{}' not found", prompt_name))
+ })?;
 
  // Validate required arguments
- for arg in &prompt.arguments {
- if arg.required
- && (!arguments.contains_key(&arg.name)
- || arguments
- .get(&arg.name)
- .and_then(Value::as_str)
- .is_none_or(str::is_empty))
- {
- return Err(RouterError::InvalidParams(format!(
- "Missing required argument: '{}'",
- arg.name
- )));
+ if let Some(args) = &prompt.arguments {
+ for arg in args {
+ if arg.required.is_some()
+ && arg.required.unwrap()
+ && (!arguments.contains_key(&arg.name)
+ || arguments
+ .get(&arg.name)
+ .and_then(Value::as_str)
+ .is_none_or(str::is_empty))
+ {
+ return Err(RouterError::InvalidParams(format!(
+ "Missing required argument: '{}'",
+ arg.name
+ )));
+ }
  }
  }
 
  // Now get the prompt content
  let description = self
  .get_prompt(prompt_name)
- .ok_or_else(|| RouterError::PromptNotFound("Prompt not found".into()))?
  .await
  .map_err(|e| RouterError::Internal(e.to_string()))?;
 

crates/mcp-client/examples/stdio_integration.rs

@@ -82,5 +82,16 @@ async fn main() -> Result<(), ClientError> {
  let resource = client.read_resource("memo://insights").await?;
  println!("Resource: {resource:?}\n");
 
+ let prompts = client.list_prompts(None).await?;
+ println!("Prompts: {prompts:?}\n");
+
+ let prompt = client
+ .get_prompt(
+ "example_prompt",
+ serde_json::json!({"message": "hello there!"}),
+ )
+ .await?;
+ println!("Prompt: {prompt:?}\n");
+
  Ok(())
 }

crates/mcp-client/src/client.rs

@@ -1,7 +1,7 @@
 use mcp_core::protocol::{
- CallToolResult, Implementation, InitializeResult, JsonRpcError, JsonRpcMessage,
- JsonRpcNotification, JsonRpcRequest, JsonRpcResponse, ListResourcesResult, ListToolsResult,
- ReadResourceResult, ServerCapabilities, METHOD_NOT_FOUND,
+ CallToolResult, GetPromptResult, Implementation, InitializeResult, JsonRpcError,
+JsonRpcMessage, JsonRpcNotification, JsonRpcRequest, JsonRpcResponse, ListPromptsResult,
+ListResourcesResult, ListToolsResult, ReadResourceResult, ServerCapabilities, METHOD_NOT_FOUND,
 };
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
@@ -93,6 +93,10 @@ pub trait McpClientTrait: Send + Sync {
  async fn list_tools(&self, next_cursor: Option<String>) -> Result<ListToolsResult, Error>;
 
  async fn call_tool(&self, name: &str, arguments: Value) -> Result<CallToolResult, Error>;
+
+ async fn list_prompts(&self, next_cursor: Option<String>) -> Result<ListPromptsResult, Error>;
+
+ async fn get_prompt(&self, name: &str, arguments: Value) -> Result<GetPromptResult, Error>;
 }
 
 /// The MCP client is the interface for MCP operations.
@@ -346,4 +350,42 @@ where
  // https://modelcontextprotocol.io/docs/concepts/tools#error-handling-2
  self.send_request("tools/call", params).await
  }
+
+ async fn list_prompts(&self, next_cursor: Option<String>) -> Result<ListPromptsResult, Error> {
+ if !self.completed_initialization() {
+ return Err(Error::NotInitialized);
+ }
+
+ // If prompts is not supported, return an error
+ if self.server_capabilities.as_ref().unwrap().prompts.is_none() {
+ return Err(Error::RpcError {
+ code: METHOD_NOT_FOUND,
+ message: "Server does not support 'prompts' capability".to_string(),
+ });
+ }
+
+ let payload = next_cursor
+ .map(|cursor| serde_json::json!({"cursor": cursor}))
+ .unwrap_or_else(|| serde_json::json!({}));
+
+ self.send_request("prompts/list", payload).await
+ }
+
+ async fn get_prompt(&self, name: &str, arguments: Value) -> Result<GetPromptResult, Error> {
+ if !self.completed_initialization() {
+ return Err(Error::NotInitialized);
+ }
+
+ // If prompts is not supported, return an error
+ if self.server_capabilities.as_ref().unwrap().prompts.is_none() {
+ return Err(Error::RpcError {
+ code: METHOD_NOT_FOUND,
+ message: "Server does not support 'prompts' capability".to_string(),
+ });
+ }
+
+ let params = serde_json::json!({ "name": name, "arguments": arguments });
+
+ self.send_request("prompts/get", params).await
+ }
 }

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

@@ -111,13 +111,23 @@ impl SseActor {
  // Attempt to parse the SSE data as a JsonRpcMessage
  match serde_json::from_str::<JsonRpcMessage>(&e.data) {
  Ok(message) => {
- // If it's a response, complete the pending request
- if let JsonRpcMessage::Response(resp) = &message {
- if let Some(id) = &resp.id {
- pending_requests.respond(&id.to_string(), Ok(message)).await;
+ match &message {
+ JsonRpcMessage::Response(response) => {
+ if let Some(id) = &response.id {
+ pending_requests
+ .respond(&id.to_string(), Ok(message))
+ .await;
+ }
  }
+ JsonRpcMessage::Error(error) => {
+ if let Some(id) = &error.id {
+ pending_requests
+ .respond(&id.to_string(), Ok(message))
+ .await;
+ }
+ }
+ _ => {} // TODO: Handle other variants (Request, etc.)
  }
- // If it's something else (notification, etc.), handle as needed
  }
  Err(err) => {
  warn!("Failed to parse SSE message: {err}");

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

@@ -87,10 +87,18 @@ impl StdioActor {
  "Received incoming message"
  );
 
- if let JsonRpcMessage::Response(response) = &message {
- if let Some(id) = &response.id {
- pending_requests.respond(&id.to_string(), Ok(message)).await;
+ match &message {
+ JsonRpcMessage::Response(response) => {
+ if let Some(id) = &response.id {
+ pending_requests.respond(&id.to_string(), Ok(message)).await;
+ }
  }
+ JsonRpcMessage::Error(error) => {
+ if let Some(id) = &error.id {
+ pending_requests.respond(&id.to_string(), Ok(message)).await;
+ }
+ }
+ _ => {} // TODO: Handle other variants (Request, etc.)
  }
  }
  line.clear();

crates/mcp-core/src/prompt.rs

@@ -10,22 +10,28 @@ use serde::{Deserialize, Serialize};
 pub struct Prompt {
  /// The name of the prompt
  pub name: String,
- /// A description of what the prompt does
- pub description: String,
- /// The arguments that can be passed to customize the prompt
- pub arguments: Vec<PromptArgument>,
+ /// Optional description of what the prompt does
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub description: Option<String>,
+ /// Optional arguments that can be passed to customize the prompt
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub arguments: Option<Vec<PromptArgument>>,
 }
 
 impl Prompt {
  /// Create a new prompt with the given name, description and arguments
- pub fn new<N, D>(name: N, description: D, arguments: Vec<PromptArgument>) -> Self
+ pub fn new<N, D>(
+ name: N,
+ description: Option<D>,
+ arguments: Option<Vec<PromptArgument>>,
+ ) -> Self
  where
  N: Into<String>,
  D: Into<String>,
  {
  Prompt {
  name: name.into(),
- description: description.into(),
+ description: description.map(Into::into),
  arguments,
  }
  }
@@ -37,9 +43,11 @@ pub struct PromptArgument {
  /// The name of the argument
  pub name: String,
  /// A description of what the argument is used for
- pub description: String,
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub description: Option<String>,
  /// Whether this argument is required
- pub required: bool,
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub required: Option<bool>,
 }
 
 /// Represents the role of a message sender in a prompt conversation
@@ -151,6 +159,6 @@ pub struct PromptTemplate {
 #[derive(Debug, Serialize, Deserialize)]
 pub struct PromptArgumentTemplate {
  pub name: String,
- pub description: String,
- pub required: bool,
+ pub description: Option<String>,
+ pub required: Option<bool>,
 }

crates/mcp-server/src/main.rs

@@ -1,6 +1,7 @@
 use anyhow::Result;
 use mcp_core::content::Content;
-use mcp_core::handler::ResourceError;
+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};
@@ -61,6 +62,7 @@ impl Router for CounterRouter {
  CapabilitiesBuilder::new()
  .with_tools(false)
  .with_resources(false, false)
+ .with_prompts(false)
  .build()
  }
 
@@ -153,6 +155,37 @@ impl Router for CounterRouter {
  }
  })
  }
+
+ fn list_prompts(&self) -> Vec<Prompt> {
+ vec![Prompt::new(
+ "example_prompt",
+ Some("This is an example prompt that takes one required agrument, message"),
+ Some(vec![PromptArgument {
+ name: "message".to_string(),
+ description: Some("A message to put in the prompt".to_string()),
+ required: Some(true),
+ }]),
+ )]
+ }
+
+ fn get_prompt(
+ &self,
+ prompt_name: &str,
+ ) -> Pin<Box<dyn Future<Output = Result<String, PromptError>> + Send + 'static>> {
+ let prompt_name = prompt_name.to_string();
+ Box::pin(async move {
+ match prompt_name.as_str() {
+ "example_prompt" => {
+ let prompt = "This is an example prompt with your message here: '{message}'";
+ Ok(prompt.to_string())
+ }
+ _ => Err(PromptError::NotFound(format!(
+ "Prompt {} not found",
+ prompt_name
+ ))),
+ }
+ })
+ }
 }
 
 #[tokio::main]

crates/mcp-server/src/router.rs

@@ -97,12 +97,8 @@ pub trait Router: Send + Sync + 'static {
  &self,
  uri: &str,
  ) -> Pin<Box<dyn Future<Output = Result<String, ResourceError>> + Send + 'static>>;
- fn list_prompts(&self) -> Option<Vec<Prompt>> {
- None
- }
- fn get_prompt(&self, _prompt_name: &str) -> Option<PromptFuture> {
- None
- }
+ fn list_prompts(&self) -> Vec<Prompt>;
+ fn get_prompt(&self, prompt_name: &str) -> PromptFuture;
 
  // Helper method to create base response
  fn create_response(&self, id: Option<u64>) -> JsonRpcResponse {
@@ -257,7 +253,7 @@ pub trait Router: Send + Sync + 'static {
  req: JsonRpcRequest,
  ) -> impl Future<Output = Result<JsonRpcResponse, RouterError>> + Send {
  async move {
- let prompts = self.list_prompts().unwrap_or_default();
+ let prompts = self.list_prompts();
 
  let result = ListPromptsResult { prompts };
 
@@ -294,36 +290,36 @@ pub trait Router: Send + Sync + 'static {
  .ok_or_else(|| RouterError::InvalidParams("Missing arguments object".into()))?;
 
  // Fetch the prompt definition first
- let prompt = match self.list_prompts() {
- Some(prompts) => prompts
- .into_iter()
- .find(|p| p.name == prompt_name)
- .ok_or_else(|| {
- RouterError::PromptNotFound(format!("Prompt '{}' not found", prompt_name))
- })?,
- None => return Err(RouterError::PromptNotFound("No prompts available".into())),
- };
+ let prompt = self
+ .list_prompts()
+ .into_iter()
+ .find(|p| p.name == prompt_name)
+ .ok_or_else(|| {
+ RouterError::PromptNotFound(format!("Prompt '{}' not found", prompt_name))
+ })?;
 
  // Validate required arguments
- for arg in &prompt.arguments {
- if arg.required
- && (!arguments.contains_key(&arg.name)
- || arguments
- .get(&arg.name)
- .and_then(Value::as_str)
- .is_none_or(str::is_empty))
- {
- return Err(RouterError::InvalidParams(format!(
- "Missing required argument: '{}'",
- arg.name
- )));
+ if let Some(args) = &prompt.arguments {
+ for arg in args {
+ if arg.required.is_some()
+ && arg.required.unwrap()
+ && (!arguments.contains_key(&arg.name)
+ || arguments
+ .get(&arg.name)
+ .and_then(Value::as_str)
+ .is_none_or(str::is_empty))
+ {
+ return Err(RouterError::InvalidParams(format!(
+ "Missing required argument: '{}'",
+ arg.name
+ )));
+ }
  }
  }
 
  // Now get the prompt content
  let description = self
  .get_prompt(prompt_name)
- .ok_or_else(|| RouterError::PromptNotFound("Prompt not found".into()))?
  .await
  .map_err(|e| RouterError::Internal(e.to_string()))?;
 

crates/mcp-client/examples/stdio_integration.rs

@@ -82,5 +82,16 @@ async fn main() -> Result<(), ClientError> {
  let resource = client.read_resource("memo://insights").await?;
  println!("Resource: {resource:?}\n");
 
+ let prompts = client.list_prompts(None).await?;
+ println!("Prompts: {prompts:?}\n");
+
+ let prompt = client
+ .get_prompt(
+ "example_prompt",
+ serde_json::json!({"message": "hello there!"}),
+ )
+ .await?;
+ println!("Prompt: {prompt:?}\n");
+
  Ok(())
 }

crates/mcp-client/src/client.rs

@@ -1,7 +1,7 @@
 use mcp_core::protocol::{
- CallToolResult, Implementation, InitializeResult, JsonRpcError, JsonRpcMessage,
- JsonRpcNotification, JsonRpcRequest, JsonRpcResponse, ListResourcesResult, ListToolsResult,
- ReadResourceResult, ServerCapabilities, METHOD_NOT_FOUND,
+ CallToolResult, GetPromptResult, Implementation, InitializeResult, JsonRpcError,
+JsonRpcMessage, JsonRpcNotification, JsonRpcRequest, JsonRpcResponse, ListPromptsResult,
+ListResourcesResult, ListToolsResult, ReadResourceResult, ServerCapabilities, METHOD_NOT_FOUND,
 };
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
@@ -93,6 +93,10 @@ pub trait McpClientTrait: Send + Sync {
  async fn list_tools(&self, next_cursor: Option<String>) -> Result<ListToolsResult, Error>;
 
  async fn call_tool(&self, name: &str, arguments: Value) -> Result<CallToolResult, Error>;
+
+ async fn list_prompts(&self, next_cursor: Option<String>) -> Result<ListPromptsResult, Error>;
+
+ async fn get_prompt(&self, name: &str, arguments: Value) -> Result<GetPromptResult, Error>;
 }
 
 /// The MCP client is the interface for MCP operations.
@@ -346,4 +350,42 @@ where
  // https://modelcontextprotocol.io/docs/concepts/tools#error-handling-2
  self.send_request("tools/call", params).await
  }
+
+ async fn list_prompts(&self, next_cursor: Option<String>) -> Result<ListPromptsResult, Error> {
+ if !self.completed_initialization() {
+ return Err(Error::NotInitialized);
+ }
+
+ // If prompts is not supported, return an error
+ if self.server_capabilities.as_ref().unwrap().prompts.is_none() {
+ return Err(Error::RpcError {
+ code: METHOD_NOT_FOUND,
+ message: "Server does not support 'prompts' capability".to_string(),
+ });
+ }
+
+ let payload = next_cursor
+ .map(|cursor| serde_json::json!({"cursor": cursor}))
+ .unwrap_or_else(|| serde_json::json!({}));
+
+ self.send_request("prompts/list", payload).await
+ }
+
+ async fn get_prompt(&self, name: &str, arguments: Value) -> Result<GetPromptResult, Error> {
+ if !self.completed_initialization() {
+ return Err(Error::NotInitialized);
+ }
+
+ // If prompts is not supported, return an error
+ if self.server_capabilities.as_ref().unwrap().prompts.is_none() {
+ return Err(Error::RpcError {
+ code: METHOD_NOT_FOUND,
+ message: "Server does not support 'prompts' capability".to_string(),
+ });
+ }
+
+ let params = serde_json::json!({ "name": name, "arguments": arguments });
+
+ self.send_request("prompts/get", params).await
+ }
 }

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

@@ -111,13 +111,23 @@ impl SseActor {
  // Attempt to parse the SSE data as a JsonRpcMessage
  match serde_json::from_str::<JsonRpcMessage>(&e.data) {
  Ok(message) => {
- // If it's a response, complete the pending request
- if let JsonRpcMessage::Response(resp) = &message {
- if let Some(id) = &resp.id {
- pending_requests.respond(&id.to_string(), Ok(message)).await;
+ match &message {
+ JsonRpcMessage::Response(response) => {
+ if let Some(id) = &response.id {
+ pending_requests
+ .respond(&id.to_string(), Ok(message))
+ .await;
+ }
  }
+ JsonRpcMessage::Error(error) => {
+ if let Some(id) = &error.id {
+ pending_requests
+ .respond(&id.to_string(), Ok(message))
+ .await;
+ }
+ }
+ _ => {} // TODO: Handle other variants (Request, etc.)
  }
- // If it's something else (notification, etc.), handle as needed
  }
  Err(err) => {
  warn!("Failed to parse SSE message: {err}");

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

@@ -87,10 +87,18 @@ impl StdioActor {
  "Received incoming message"
  );
 
- if let JsonRpcMessage::Response(response) = &message {
- if let Some(id) = &response.id {
- pending_requests.respond(&id.to_string(), Ok(message)).await;
+ match &message {
+ JsonRpcMessage::Response(response) => {
+ if let Some(id) = &response.id {
+ pending_requests.respond(&id.to_string(), Ok(message)).await;
+ }
  }
+ JsonRpcMessage::Error(error) => {
+ if let Some(id) = &error.id {
+ pending_requests.respond(&id.to_string(), Ok(message)).await;
+ }
+ }
+ _ => {} // TODO: Handle other variants (Request, etc.)
  }
  }
  line.clear();

crates/mcp-core/src/prompt.rs

@@ -10,22 +10,28 @@ use serde::{Deserialize, Serialize};
 pub struct Prompt {
  /// The name of the prompt
  pub name: String,
- /// A description of what the prompt does
- pub description: String,
- /// The arguments that can be passed to customize the prompt
- pub arguments: Vec<PromptArgument>,
+ /// Optional description of what the prompt does
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub description: Option<String>,
+ /// Optional arguments that can be passed to customize the prompt
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub arguments: Option<Vec<PromptArgument>>,
 }
 
 impl Prompt {
  /// Create a new prompt with the given name, description and arguments
- pub fn new<N, D>(name: N, description: D, arguments: Vec<PromptArgument>) -> Self
+ pub fn new<N, D>(
+ name: N,
+ description: Option<D>,
+ arguments: Option<Vec<PromptArgument>>,
+ ) -> Self
  where
  N: Into<String>,
  D: Into<String>,
  {
  Prompt {
  name: name.into(),
- description: description.into(),
+ description: description.map(Into::into),
  arguments,
  }
  }
@@ -37,9 +43,11 @@ pub struct PromptArgument {
  /// The name of the argument
  pub name: String,
  /// A description of what the argument is used for
- pub description: String,
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub description: Option<String>,
  /// Whether this argument is required
- pub required: bool,
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub required: Option<bool>,
 }
 
 /// Represents the role of a message sender in a prompt conversation
@@ -151,6 +159,6 @@ pub struct PromptTemplate {
 #[derive(Debug, Serialize, Deserialize)]
 pub struct PromptArgumentTemplate {
  pub name: String,
- pub description: String,
- pub required: bool,
+ pub description: Option<String>,
+ pub required: Option<bool>,
 }

crates/mcp-server/src/main.rs

@@ -1,6 +1,7 @@
 use anyhow::Result;
 use mcp_core::content::Content;
-use mcp_core::handler::ResourceError;
+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};
@@ -61,6 +62,7 @@ impl Router for CounterRouter {
  CapabilitiesBuilder::new()
  .with_tools(false)
  .with_resources(false, false)
+ .with_prompts(false)
  .build()
  }
 
@@ -153,6 +155,37 @@ impl Router for CounterRouter {
  }
  })
  }
+
+ fn list_prompts(&self) -> Vec<Prompt> {
+ vec![Prompt::new(
+ "example_prompt",
+ Some("This is an example prompt that takes one required agrument, message"),
+ Some(vec![PromptArgument {
+ name: "message".to_string(),
+ description: Some("A message to put in the prompt".to_string()),
+ required: Some(true),
+ }]),
+ )]
+ }
+
+ fn get_prompt(
+ &self,
+ prompt_name: &str,
+ ) -> Pin<Box<dyn Future<Output = Result<String, PromptError>> + Send + 'static>> {
+ let prompt_name = prompt_name.to_string();
+ Box::pin(async move {
+ match prompt_name.as_str() {
+ "example_prompt" => {
+ let prompt = "This is an example prompt with your message here: '{message}'";
+ Ok(prompt.to_string())
+ }
+ _ => Err(PromptError::NotFound(format!(
+ "Prompt {} not found",
+ prompt_name
+ ))),
+ }
+ })
+ }
 }
 
 #[tokio::main]

crates/mcp-server/src/router.rs

@@ -97,12 +97,8 @@ pub trait Router: Send + Sync + 'static {
  &self,
  uri: &str,
  ) -> Pin<Box<dyn Future<Output = Result<String, ResourceError>> + Send + 'static>>;
- fn list_prompts(&self) -> Option<Vec<Prompt>> {
- None
- }
- fn get_prompt(&self, _prompt_name: &str) -> Option<PromptFuture> {
- None
- }
+ fn list_prompts(&self) -> Vec<Prompt>;
+ fn get_prompt(&self, prompt_name: &str) -> PromptFuture;
 
  // Helper method to create base response
  fn create_response(&self, id: Option<u64>) -> JsonRpcResponse {
@@ -257,7 +253,7 @@ pub trait Router: Send + Sync + 'static {
  req: JsonRpcRequest,
  ) -> impl Future<Output = Result<JsonRpcResponse, RouterError>> + Send {
  async move {
- let prompts = self.list_prompts().unwrap_or_default();
+ let prompts = self.list_prompts();
 
  let result = ListPromptsResult { prompts };
 
@@ -294,36 +290,36 @@ pub trait Router: Send + Sync + 'static {
  .ok_or_else(|| RouterError::InvalidParams("Missing arguments object".into()))?;
 
  // Fetch the prompt definition first
- let prompt = match self.list_prompts() {
- Some(prompts) => prompts
- .into_iter()
- .find(|p| p.name == prompt_name)
- .ok_or_else(|| {
- RouterError::PromptNotFound(format!("Prompt '{}' not found", prompt_name))
- })?,
- None => return Err(RouterError::PromptNotFound("No prompts available".into())),
- };
+ let prompt = self
+ .list_prompts()
+ .into_iter()
+ .find(|p| p.name == prompt_name)
+ .ok_or_else(|| {
+ RouterError::PromptNotFound(format!("Prompt '{}' not found", prompt_name))
+ })?;
 
  // Validate required arguments
- for arg in &prompt.arguments {
- if arg.required
- && (!arguments.contains_key(&arg.name)
- || arguments
- .get(&arg.name)
- .and_then(Value::as_str)
- .is_none_or(str::is_empty))
- {
- return Err(RouterError::InvalidParams(format!(
- "Missing required argument: '{}'",
- arg.name
- )));
+ if let Some(args) = &prompt.arguments {
+ for arg in args {
+ if arg.required.is_some()
+ && arg.required.unwrap()
+ && (!arguments.contains_key(&arg.name)
+ || arguments
+ .get(&arg.name)
+ .and_then(Value::as_str)
+ .is_none_or(str::is_empty))
+ {
+ return Err(RouterError::InvalidParams(format!(
+ "Missing required argument: '{}'",
+ arg.name
+ )));
+ }
  }
  }
 
  // Now get the prompt content
  let description = self
  .get_prompt(prompt_name)
- .ok_or_else(|| RouterError::PromptNotFound("Prompt not found".into()))?
  .await
  .map_err(|e| RouterError::Internal(e.to_string()))?;
 

crates/mcp-client/examples/stdio_integration.rs

@@ -82,5 +82,16 @@ async fn main() -> Result<(), ClientError> {
  let resource = client.read_resource("memo://insights").await?;
  println!("Resource: {resource:?}\n");
 
+ let prompts = client.list_prompts(None).await?;
+ println!("Prompts: {prompts:?}\n");
+
+ let prompt = client
+ .get_prompt(
+ "example_prompt",
+ serde_json::json!({"message": "hello there!"}),
+ )
+ .await?;
+ println!("Prompt: {prompt:?}\n");
+
  Ok(())
 }

crates/mcp-client/src/client.rs

@@ -1,7 +1,7 @@
 use mcp_core::protocol::{
- CallToolResult, Implementation, InitializeResult, JsonRpcError, JsonRpcMessage,
- JsonRpcNotification, JsonRpcRequest, JsonRpcResponse, ListResourcesResult, ListToolsResult,
- ReadResourceResult, ServerCapabilities, METHOD_NOT_FOUND,
+ CallToolResult, GetPromptResult, Implementation, InitializeResult, JsonRpcError,
+JsonRpcMessage, JsonRpcNotification, JsonRpcRequest, JsonRpcResponse, ListPromptsResult,
+ListResourcesResult, ListToolsResult, ReadResourceResult, ServerCapabilities, METHOD_NOT_FOUND,
 };
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
@@ -93,6 +93,10 @@ pub trait McpClientTrait: Send + Sync {
  async fn list_tools(&self, next_cursor: Option<String>) -> Result<ListToolsResult, Error>;
 
  async fn call_tool(&self, name: &str, arguments: Value) -> Result<CallToolResult, Error>;
+
+ async fn list_prompts(&self, next_cursor: Option<String>) -> Result<ListPromptsResult, Error>;
+
+ async fn get_prompt(&self, name: &str, arguments: Value) -> Result<GetPromptResult, Error>;
 }
 
 /// The MCP client is the interface for MCP operations.
@@ -346,4 +350,42 @@ where
  // https://modelcontextprotocol.io/docs/concepts/tools#error-handling-2
  self.send_request("tools/call", params).await
  }
+
+ async fn list_prompts(&self, next_cursor: Option<String>) -> Result<ListPromptsResult, Error> {
+ if !self.completed_initialization() {
+ return Err(Error::NotInitialized);
+ }
+
+ // If prompts is not supported, return an error
+ if self.server_capabilities.as_ref().unwrap().prompts.is_none() {
+ return Err(Error::RpcError {
+ code: METHOD_NOT_FOUND,
+ message: "Server does not support 'prompts' capability".to_string(),
+ });
+ }
+
+ let payload = next_cursor
+ .map(|cursor| serde_json::json!({"cursor": cursor}))
+ .unwrap_or_else(|| serde_json::json!({}));
+
+ self.send_request("prompts/list", payload).await
+ }
+
+ async fn get_prompt(&self, name: &str, arguments: Value) -> Result<GetPromptResult, Error> {
+ if !self.completed_initialization() {
+ return Err(Error::NotInitialized);
+ }
+
+ // If prompts is not supported, return an error
+ if self.server_capabilities.as_ref().unwrap().prompts.is_none() {
+ return Err(Error::RpcError {
+ code: METHOD_NOT_FOUND,
+ message: "Server does not support 'prompts' capability".to_string(),
+ });
+ }
+
+ let params = serde_json::json!({ "name": name, "arguments": arguments });
+
+ self.send_request("prompts/get", params).await
+ }
 }

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

@@ -111,13 +111,23 @@ impl SseActor {
  // Attempt to parse the SSE data as a JsonRpcMessage
  match serde_json::from_str::<JsonRpcMessage>(&e.data) {
  Ok(message) => {
- // If it's a response, complete the pending request
- if let JsonRpcMessage::Response(resp) = &message {
- if let Some(id) = &resp.id {
- pending_requests.respond(&id.to_string(), Ok(message)).await;
+ match &message {
+ JsonRpcMessage::Response(response) => {
+ if let Some(id) = &response.id {
+ pending_requests
+ .respond(&id.to_string(), Ok(message))
+ .await;
+ }
  }
+ JsonRpcMessage::Error(error) => {
+ if let Some(id) = &error.id {
+ pending_requests
+ .respond(&id.to_string(), Ok(message))
+ .await;
+ }
+ }
+ _ => {} // TODO: Handle other variants (Request, etc.)
  }
- // If it's something else (notification, etc.), handle as needed
  }
  Err(err) => {
  warn!("Failed to parse SSE message: {err}");

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

@@ -87,10 +87,18 @@ impl StdioActor {
  "Received incoming message"
  );
 
- if let JsonRpcMessage::Response(response) = &message {
- if let Some(id) = &response.id {
- pending_requests.respond(&id.to_string(), Ok(message)).await;
+ match &message {
+ JsonRpcMessage::Response(response) => {
+ if let Some(id) = &response.id {
+ pending_requests.respond(&id.to_string(), Ok(message)).await;
+ }
  }
+ JsonRpcMessage::Error(error) => {
+ if let Some(id) = &error.id {
+ pending_requests.respond(&id.to_string(), Ok(message)).await;
+ }
+ }
+ _ => {} // TODO: Handle other variants (Request, etc.)
  }
  }
  line.clear();

crates/mcp-core/src/prompt.rs

@@ -10,22 +10,28 @@ use serde::{Deserialize, Serialize};
 pub struct Prompt {
  /// The name of the prompt
  pub name: String,
- /// A description of what the prompt does
- pub description: String,
- /// The arguments that can be passed to customize the prompt
- pub arguments: Vec<PromptArgument>,
+ /// Optional description of what the prompt does
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub description: Option<String>,
+ /// Optional arguments that can be passed to customize the prompt
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub arguments: Option<Vec<PromptArgument>>,
 }
 
 impl Prompt {
  /// Create a new prompt with the given name, description and arguments
- pub fn new<N, D>(name: N, description: D, arguments: Vec<PromptArgument>) -> Self
+ pub fn new<N, D>(
+ name: N,
+ description: Option<D>,
+ arguments: Option<Vec<PromptArgument>>,
+ ) -> Self
  where
  N: Into<String>,
  D: Into<String>,
  {
  Prompt {
  name: name.into(),
- description: description.into(),
+ description: description.map(Into::into),
  arguments,
  }
  }
@@ -37,9 +43,11 @@ pub struct PromptArgument {
  /// The name of the argument
  pub name: String,
  /// A description of what the argument is used for
- pub description: String,
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub description: Option<String>,
  /// Whether this argument is required
- pub required: bool,
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub required: Option<bool>,
 }
 
 /// Represents the role of a message sender in a prompt conversation
@@ -151,6 +159,6 @@ pub struct PromptTemplate {
 #[derive(Debug, Serialize, Deserialize)]
 pub struct PromptArgumentTemplate {
  pub name: String,
- pub description: String,
- pub required: bool,
+ pub description: Option<String>,
+ pub required: Option<bool>,
 }

crates/mcp-server/src/main.rs

@@ -1,6 +1,7 @@
 use anyhow::Result;
 use mcp_core::content::Content;
-use mcp_core::handler::ResourceError;
+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};
@@ -61,6 +62,7 @@ impl Router for CounterRouter {
  CapabilitiesBuilder::new()
  .with_tools(false)
  .with_resources(false, false)
+ .with_prompts(false)
  .build()
  }
 
@@ -153,6 +155,37 @@ impl Router for CounterRouter {
  }
  })
  }
+
+ fn list_prompts(&self) -> Vec<Prompt> {
+ vec![Prompt::new(
+ "example_prompt",
+ Some("This is an example prompt that takes one required agrument, message"),
+ Some(vec![PromptArgument {
+ name: "message".to_string(),
+ description: Some("A message to put in the prompt".to_string()),
+ required: Some(true),
+ }]),
+ )]
+ }
+
+ fn get_prompt(
+ &self,
+ prompt_name: &str,
+ ) -> Pin<Box<dyn Future<Output = Result<String, PromptError>> + Send + 'static>> {
+ let prompt_name = prompt_name.to_string();
+ Box::pin(async move {
+ match prompt_name.as_str() {
+ "example_prompt" => {
+ let prompt = "This is an example prompt with your message here: '{message}'";
+ Ok(prompt.to_string())
+ }
+ _ => Err(PromptError::NotFound(format!(
+ "Prompt {} not found",
+ prompt_name
+ ))),
+ }
+ })
+ }
 }
 
 #[tokio::main]

crates/mcp-server/src/router.rs

@@ -97,12 +97,8 @@ pub trait Router: Send + Sync + 'static {
  &self,
  uri: &str,
  ) -> Pin<Box<dyn Future<Output = Result<String, ResourceError>> + Send + 'static>>;
- fn list_prompts(&self) -> Option<Vec<Prompt>> {
- None
- }
- fn get_prompt(&self, _prompt_name: &str) -> Option<PromptFuture> {
- None
- }
+ fn list_prompts(&self) -> Vec<Prompt>;
+ fn get_prompt(&self, prompt_name: &str) -> PromptFuture;
 
  // Helper method to create base response
  fn create_response(&self, id: Option<u64>) -> JsonRpcResponse {
@@ -257,7 +253,7 @@ pub trait Router: Send + Sync + 'static {
  req: JsonRpcRequest,
  ) -> impl Future<Output = Result<JsonRpcResponse, RouterError>> + Send {
  async move {
- let prompts = self.list_prompts().unwrap_or_default();
+ let prompts = self.list_prompts();
 
  let result = ListPromptsResult { prompts };
 
@@ -294,36 +290,36 @@ pub trait Router: Send + Sync + 'static {
  .ok_or_else(|| RouterError::InvalidParams("Missing arguments object".into()))?;
 
  // Fetch the prompt definition first
- let prompt = match self.list_prompts() {
- Some(prompts) => prompts
- .into_iter()
- .find(|p| p.name == prompt_name)
- .ok_or_else(|| {
- RouterError::PromptNotFound(format!("Prompt '{}' not found", prompt_name))
- })?,
- None => return Err(RouterError::PromptNotFound("No prompts available".into())),
- };
+ let prompt = self
+ .list_prompts()
+ .into_iter()
+ .find(|p| p.name == prompt_name)
+ .ok_or_else(|| {
+ RouterError::PromptNotFound(format!("Prompt '{}' not found", prompt_name))
+ })?;
 
  // Validate required arguments
- for arg in &prompt.arguments {
- if arg.required
- && (!arguments.contains_key(&arg.name)
- || arguments
- .get(&arg.name)
- .and_then(Value::as_str)
- .is_none_or(str::is_empty))
- {
- return Err(RouterError::InvalidParams(format!(
- "Missing required argument: '{}'",
- arg.name
- )));
+ if let Some(args) = &prompt.arguments {
+ for arg in args {
+ if arg.required.is_some()
+ && arg.required.unwrap()
+ && (!arguments.contains_key(&arg.name)
+ || arguments
+ .get(&arg.name)
+ .and_then(Value::as_str)
+ .is_none_or(str::is_empty))
+ {
+ return Err(RouterError::InvalidParams(format!(
+ "Missing required argument: '{}'",
+ arg.name
+ )));
+ }
  }
  }
 
  // Now get the prompt content
  let description = self
  .get_prompt(prompt_name)
- .ok_or_else(|| RouterError::PromptNotFound("Prompt not found".into()))?
  .await
  .map_err(|e| RouterError::Internal(e.to_string()))?;
 

crates/mcp-client/examples/stdio_integration.rs

@@ -82,5 +82,16 @@ async fn main() -> Result<(), ClientError> {
  let resource = client.read_resource("memo://insights").await?;
  println!("Resource: {resource:?}\n");
 
+ let prompts = client.list_prompts(None).await?;
+ println!("Prompts: {prompts:?}\n");
+
+ let prompt = client
+ .get_prompt(
+ "example_prompt",
+ serde_json::json!({"message": "hello there!"}),
+ )
+ .await?;
+ println!("Prompt: {prompt:?}\n");
+
  Ok(())
 }

crates/mcp-client/src/client.rs

@@ -1,7 +1,7 @@
 use mcp_core::protocol::{
- CallToolResult, Implementation, InitializeResult, JsonRpcError, JsonRpcMessage,
- JsonRpcNotification, JsonRpcRequest, JsonRpcResponse, ListResourcesResult, ListToolsResult,
- ReadResourceResult, ServerCapabilities, METHOD_NOT_FOUND,
+ CallToolResult, GetPromptResult, Implementation, InitializeResult, JsonRpcError,
+JsonRpcMessage, JsonRpcNotification, JsonRpcRequest, JsonRpcResponse, ListPromptsResult,
+ListResourcesResult, ListToolsResult, ReadResourceResult, ServerCapabilities, METHOD_NOT_FOUND,
 };
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
@@ -93,6 +93,10 @@ pub trait McpClientTrait: Send + Sync {
  async fn list_tools(&self, next_cursor: Option<String>) -> Result<ListToolsResult, Error>;
 
  async fn call_tool(&self, name: &str, arguments: Value) -> Result<CallToolResult, Error>;
+
+ async fn list_prompts(&self, next_cursor: Option<String>) -> Result<ListPromptsResult, Error>;
+
+ async fn get_prompt(&self, name: &str, arguments: Value) -> Result<GetPromptResult, Error>;
 }
 
 /// The MCP client is the interface for MCP operations.
@@ -346,4 +350,42 @@ where
  // https://modelcontextprotocol.io/docs/concepts/tools#error-handling-2
  self.send_request("tools/call", params).await
  }
+
+ async fn list_prompts(&self, next_cursor: Option<String>) -> Result<ListPromptsResult, Error> {
+ if !self.completed_initialization() {
+ return Err(Error::NotInitialized);
+ }
+
+ // If prompts is not supported, return an error
+ if self.server_capabilities.as_ref().unwrap().prompts.is_none() {
+ return Err(Error::RpcError {
+ code: METHOD_NOT_FOUND,
+ message: "Server does not support 'prompts' capability".to_string(),
+ });
+ }
+
+ let payload = next_cursor
+ .map(|cursor| serde_json::json!({"cursor": cursor}))
+ .unwrap_or_else(|| serde_json::json!({}));
+
+ self.send_request("prompts/list", payload).await
+ }
+
+ async fn get_prompt(&self, name: &str, arguments: Value) -> Result<GetPromptResult, Error> {
+ if !self.completed_initialization() {
+ return Err(Error::NotInitialized);
+ }
+
+ // If prompts is not supported, return an error
+ if self.server_capabilities.as_ref().unwrap().prompts.is_none() {
+ return Err(Error::RpcError {
+ code: METHOD_NOT_FOUND,
+ message: "Server does not support 'prompts' capability".to_string(),
+ });
+ }
+
+ let params = serde_json::json!({ "name": name, "arguments": arguments });
+
+ self.send_request("prompts/get", params).await
+ }
 }

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

@@ -111,13 +111,23 @@ impl SseActor {
  // Attempt to parse the SSE data as a JsonRpcMessage
  match serde_json::from_str::<JsonRpcMessage>(&e.data) {
  Ok(message) => {
- // If it's a response, complete the pending request
- if let JsonRpcMessage::Response(resp) = &message {
- if let Some(id) = &resp.id {
- pending_requests.respond(&id.to_string(), Ok(message)).await;
+ match &message {
+ JsonRpcMessage::Response(response) => {
+ if let Some(id) = &response.id {
+ pending_requests
+ .respond(&id.to_string(), Ok(message))
+ .await;
+ }
  }
+ JsonRpcMessage::Error(error) => {
+ if let Some(id) = &error.id {
+ pending_requests
+ .respond(&id.to_string(), Ok(message))
+ .await;
+ }
+ }
+ _ => {} // TODO: Handle other variants (Request, etc.)
  }
- // If it's something else (notification, etc.), handle as needed
  }
  Err(err) => {
  warn!("Failed to parse SSE message: {err}");

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

@@ -87,10 +87,18 @@ impl StdioActor {
  "Received incoming message"
  );
 
- if let JsonRpcMessage::Response(response) = &message {
- if let Some(id) = &response.id {
- pending_requests.respond(&id.to_string(), Ok(message)).await;
+ match &message {
+ JsonRpcMessage::Response(response) => {
+ if let Some(id) = &response.id {
+ pending_requests.respond(&id.to_string(), Ok(message)).await;
+ }
  }
+ JsonRpcMessage::Error(error) => {
+ if let Some(id) = &error.id {
+ pending_requests.respond(&id.to_string(), Ok(message)).await;
+ }
+ }
+ _ => {} // TODO: Handle other variants (Request, etc.)
  }
  }
  line.clear();

crates/mcp-core/src/prompt.rs

@@ -10,22 +10,28 @@ use serde::{Deserialize, Serialize};
 pub struct Prompt {
  /// The name of the prompt
  pub name: String,
- /// A description of what the prompt does
- pub description: String,
- /// The arguments that can be passed to customize the prompt
- pub arguments: Vec<PromptArgument>,
+ /// Optional description of what the prompt does
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub description: Option<String>,
+ /// Optional arguments that can be passed to customize the prompt
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub arguments: Option<Vec<PromptArgument>>,
 }
 
 impl Prompt {
  /// Create a new prompt with the given name, description and arguments
- pub fn new<N, D>(name: N, description: D, arguments: Vec<PromptArgument>) -> Self
+ pub fn new<N, D>(
+ name: N,
+ description: Option<D>,
+ arguments: Option<Vec<PromptArgument>>,
+ ) -> Self
  where
  N: Into<String>,
  D: Into<String>,
  {
  Prompt {
  name: name.into(),
- description: description.into(),
+ description: description.map(Into::into),
  arguments,
  }
  }
@@ -37,9 +43,11 @@ pub struct PromptArgument {
  /// The name of the argument
  pub name: String,
  /// A description of what the argument is used for
- pub description: String,
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub description: Option<String>,
  /// Whether this argument is required
- pub required: bool,
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub required: Option<bool>,
 }
 
 /// Represents the role of a message sender in a prompt conversation
@@ -151,6 +159,6 @@ pub struct PromptTemplate {
 #[derive(Debug, Serialize, Deserialize)]
 pub struct PromptArgumentTemplate {
  pub name: String,
- pub description: String,
- pub required: bool,
+ pub description: Option<String>,
+ pub required: Option<bool>,
 }

crates/mcp-server/src/main.rs

@@ -1,6 +1,7 @@
 use anyhow::Result;
 use mcp_core::content::Content;
-use mcp_core::handler::ResourceError;
+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};
@@ -61,6 +62,7 @@ impl Router for CounterRouter {
  CapabilitiesBuilder::new()
  .with_tools(false)
  .with_resources(false, false)
+ .with_prompts(false)
  .build()
  }
 
@@ -153,6 +155,37 @@ impl Router for CounterRouter {
  }
  })
  }
+
+ fn list_prompts(&self) -> Vec<Prompt> {
+ vec![Prompt::new(
+ "example_prompt",
+ Some("This is an example prompt that takes one required agrument, message"),
+ Some(vec![PromptArgument {
+ name: "message".to_string(),
+ description: Some("A message to put in the prompt".to_string()),
+ required: Some(true),
+ }]),
+ )]
+ }
+
+ fn get_prompt(
+ &self,
+ prompt_name: &str,
+ ) -> Pin<Box<dyn Future<Output = Result<String, PromptError>> + Send + 'static>> {
+ let prompt_name = prompt_name.to_string();
+ Box::pin(async move {
+ match prompt_name.as_str() {
+ "example_prompt" => {
+ let prompt = "This is an example prompt with your message here: '{message}'";
+ Ok(prompt.to_string())
+ }
+ _ => Err(PromptError::NotFound(format!(
+ "Prompt {} not found",
+ prompt_name
+ ))),
+ }
+ })
+ }
 }
 
 #[tokio::main]

crates/mcp-server/src/router.rs

@@ -97,12 +97,8 @@ pub trait Router: Send + Sync + 'static {
  &self,
  uri: &str,
  ) -> Pin<Box<dyn Future<Output = Result<String, ResourceError>> + Send + 'static>>;
- fn list_prompts(&self) -> Option<Vec<Prompt>> {
- None
- }
- fn get_prompt(&self, _prompt_name: &str) -> Option<PromptFuture> {
- None
- }
+ fn list_prompts(&self) -> Vec<Prompt>;
+ fn get_prompt(&self, prompt_name: &str) -> PromptFuture;
 
  // Helper method to create base response
  fn create_response(&self, id: Option<u64>) -> JsonRpcResponse {
@@ -257,7 +253,7 @@ pub trait Router: Send + Sync + 'static {
  req: JsonRpcRequest,
  ) -> impl Future<Output = Result<JsonRpcResponse, RouterError>> + Send {
  async move {
- let prompts = self.list_prompts().unwrap_or_default();
+ let prompts = self.list_prompts();
 
  let result = ListPromptsResult { prompts };
 
@@ -294,36 +290,36 @@ pub trait Router: Send + Sync + 'static {
  .ok_or_else(|| RouterError::InvalidParams("Missing arguments object".into()))?;
 
  // Fetch the prompt definition first
- let prompt = match self.list_prompts() {
- Some(prompts) => prompts
- .into_iter()
- .find(|p| p.name == prompt_name)
- .ok_or_else(|| {
- RouterError::PromptNotFound(format!("Prompt '{}' not found", prompt_name))
- })?,
- None => return Err(RouterError::PromptNotFound("No prompts available".into())),
- };
+ let prompt = self
+ .list_prompts()
+ .into_iter()
+ .find(|p| p.name == prompt_name)
+ .ok_or_else(|| {
+ RouterError::PromptNotFound(format!("Prompt '{}' not found", prompt_name))
+ })?;
 
  // Validate required arguments
- for arg in &prompt.arguments {
- if arg.required
- && (!arguments.contains_key(&arg.name)
- || arguments
- .get(&arg.name)
- .and_then(Value::as_str)
- .is_none_or(str::is_empty))
- {
- return Err(RouterError::InvalidParams(format!(
- "Missing required argument: '{}'",
- arg.name
- )));
+ if let Some(args) = &prompt.arguments {
+ for arg in args {
+ if arg.required.is_some()
+ && arg.required.unwrap()
+ && (!arguments.contains_key(&arg.name)
+ || arguments
+ .get(&arg.name)
+ .and_then(Value::as_str)
+ .is_none_or(str::is_empty))
+ {
+ return Err(RouterError::InvalidParams(format!(
+ "Missing required argument: '{}'",
+ arg.name
+ )));
+ }
  }
  }
 
  // Now get the prompt content
  let description = self
  .get_prompt(prompt_name)
- .ok_or_else(|| RouterError::PromptNotFound("Prompt not found".into()))?
  .await
  .map_err(|e| RouterError::Internal(e.to_string()))?;