Merge pull request #2 from kalvinnchau/mcp-prompt-spec

Author: alexhancock

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()))?;