fix: correct elicitation direction to comply with MCP 2025-06-18

- Remove CreateElicitationRequest from ClientRequest - clients cannot initiate elicitation
- Move elicit methods from client to server - servers now request user input
- Add comprehensive direction tests verifying Server→Client→Server flow
- Maintain CreateElicitationResult in ClientResult for proper responses
- Update handlers to reflect correct message routing
- Add elicitation feature flag for typed schema generation

Fixes elicitation direction to match specification where servers request
interactive user input from clients, not the reverse.

Author: bug-ops

crates/rmcp/Cargo.toml

@@ -79,7 +79,7 @@ default = ["base64", "macros", "server"]
 client = ["dep:tokio-stream"]
 server = ["transport-async-rw", "dep:schemars"]
 macros = ["dep:rmcp-macros", "dep:paste"]
-elicitation = ["client", "schemars"]
+elicitation = ["server", "schemars"]
 
 # reqwest http client
 __reqwest = ["dep:reqwest"]

crates/rmcp/src/handler/server.rs

@@ -66,10 +66,6 @@ impl<H: ServerHandler> Service<RoleServer> for H {
                 .list_tools(request.params, context)
                 .await
                 .map(ServerResult::ListToolsResult),
-            ClientRequest::CreateElicitationRequest(request) => self
-                .create_elicitation(request.params, context)
-                .await
-                .map(ServerResult::CreateElicitationResult),
         }
     }
 
@@ -199,31 +195,6 @@ pub trait ServerHandler: Sized + Send + Sync + 'static {
         std::future::ready(Ok(ListToolsResult::default()))
     }
 
-    /// Handle an elicitation request to gather interactive user input.
-    ///
-    /// This method is typically implemented by server applications that need to
-    /// request information from users during tool execution. The default implementation
-    /// declines all elicitation requests.
-    ///
-    /// # Arguments
-    /// * `request` - The elicitation request parameters containing the message and schema
-    /// * `context` - The request context for this elicitation
-    ///
-    /// # Returns
-    /// A result containing the user's response (accept/decline/cancel) and optional data
-    fn create_elicitation(
-        &self,
-        request: CreateElicitationRequestParam,
-        context: RequestContext<RoleServer>,
-    ) -> impl Future<Output = Result<CreateElicitationResult, McpError>> + Send + '_ {
-        // Default implementation declines all elicitation requests
-        let _ = (request, context);
-        std::future::ready(Ok(CreateElicitationResult {
-            action: ElicitationAction::Decline,
-            content: None,
-        }))
-    }
-
     fn on_cancelled(
         &self,
         notification: CancelledNotificationParam,

crates/rmcp/src/model.rs

@@ -1374,8 +1374,7 @@ ts_union!(
     | SubscribeRequest
     | UnsubscribeRequest
     | CallToolRequest
-    | ListToolsRequest
-    | CreateElicitationRequest;
+    | ListToolsRequest;
 );
 
 ts_union!(

crates/rmcp/src/model/meta.rs

@@ -66,7 +66,6 @@ variant_extension! {
         UnsubscribeRequest
         CallToolRequest
         ListToolsRequest
-        CreateElicitationRequest
     }
 }
 

crates/rmcp/src/service/client.rs

@@ -8,7 +8,6 @@ use crate::{
         CallToolRequest, CallToolRequestParam, CallToolResult, CancelledNotification,
         CancelledNotificationParam, ClientInfo, ClientJsonRpcMessage, ClientNotification,
         ClientRequest, ClientResult, CompleteRequest, CompleteRequestParam, CompleteResult,
-        CreateElicitationRequest, CreateElicitationRequestParam, CreateElicitationResult,
         GetPromptRequest, GetPromptRequestParam, GetPromptResult, InitializeRequest,
         InitializedNotification, JsonRpcResponse, ListPromptsRequest, ListPromptsResult,
         ListResourceTemplatesRequest, ListResourceTemplatesResult, ListResourcesRequest,
@@ -22,28 +21,6 @@ use crate::{
     transport::DynamicTransportError,
 };
 
-/// Errors that can occur during typed elicitation operations
-#[derive(Error, Debug)]
-pub enum ElicitationError {
-    /// The elicitation request failed at the service level
-    #[error("Service error: {0}")]
-    Service(#[from] ServiceError),
-    
-    /// User declined to provide input or cancelled the request  
-    #[error("User declined or cancelled the request")]
-    UserDeclined,
-    
-    /// The response data could not be parsed into the requested type
-    #[error("Failed to parse response data: {error}\nReceived data: {data}")]
-    ParseError {
-        error: serde_json::Error,
-        data: serde_json::Value,
-    },
-    
-    /// No response content was provided by the user
-    #[error("No response content provided")]
-    NoContent,
-}
 
 /// It represents the error that may occur when serving the client.
 ///
@@ -329,7 +306,6 @@ impl Peer<RoleClient> {
     method!(peer_req unsubscribe UnsubscribeRequest(UnsubscribeRequestParam));
     method!(peer_req call_tool CallToolRequest(CallToolRequestParam) => CallToolResult);
     method!(peer_req list_tools ListToolsRequest(PaginatedRequestParam)? => ListToolsResult);
-    method!(peer_req create_elicitation CreateElicitationRequest(CreateElicitationRequestParam) => CreateElicitationResult);
 
     method!(peer_not notify_cancelled CancelledNotification(CancelledNotificationParam));
     method!(peer_not notify_progress ProgressNotification(ProgressNotificationParam));
@@ -416,158 +392,4 @@ impl Peer<RoleClient> {
         Ok(resource_templates)
     }
 
-    // =============================================================================
-    // ELICITATION CONVENIENCE METHODS
-    // =============================================================================
-
-    /// Request structured data from the user using a custom JSON schema.
-    ///
-    /// This is the most flexible elicitation method, allowing you to request
-    /// any kind of structured input using JSON Schema validation.
-    ///
-    /// # Arguments
-    /// * `message` - The prompt message for the user
-    /// * `schema` - JSON Schema defining the expected data structure
-    ///
-    /// # Returns
-    /// * `Ok(Some(data))` if user provided valid data
-    /// * `Ok(None)` if user declined or cancelled
-    ///
-    /// # Example
-    /// ```rust,no_run
-    /// # use rmcp::*;
-    /// # use serde_json::json;
-    /// # async fn example(peer: Peer<RoleClient>) -> Result<(), ServiceError> {
-    /// let schema = json!({
-    ///     "type": "object",
-    ///     "properties": {
-    ///         "name": {"type": "string"},
-    ///         "email": {"type": "string", "format": "email"},
-    ///         "age": {"type": "integer", "minimum": 0}
-    ///     },
-    ///     "required": ["name", "email"]
-    /// });
-    ///
-    /// let user_data = peer.elicit_structured_input(
-    ///     "Please provide your contact information:",
-    ///     schema.as_object().unwrap()
-    /// ).await?;
-    ///
-    /// if let Some(data) = user_data {
-    ///     println!("Received user data: {}", data);
-    /// }
-    /// # Ok(())
-    /// # }
-    /// ```
-    pub async fn elicit_structured_input(
-        &self,
-        message: impl Into<String>,
-        schema: &crate::model::JsonObject,
-    ) -> Result<Option<serde_json::Value>, ServiceError> {
-        let response = self
-            .create_elicitation(CreateElicitationRequestParam {
-                message: message.into(),
-                requested_schema: schema.clone(),
-            })
-            .await?;
-
-        match response.action {
-            crate::model::ElicitationAction::Accept => Ok(response.content),
-            _ => Ok(None),
-        }
-    }
-
-    /// Request typed data from the user with automatic schema generation.
-    ///
-    /// This method automatically generates the JSON schema from the Rust type using `schemars`,
-    /// eliminating the need to manually create schemas. The response is automatically parsed
-    /// into the requested type.
-    ///
-    /// **Requires the `elicitation` feature to be enabled.**
-    ///
-    /// # Type Requirements
-    /// The type `T` must implement:
-    /// - `schemars::JsonSchema` - for automatic schema generation
-    /// - `serde::Deserialize` - for parsing the response
-    ///
-    /// # Arguments
-    /// * `message` - The prompt message for the user
-    ///
-    /// # Returns
-    /// * `Ok(Some(data))` if user provided valid data that matches type T
-    /// * `Err(ElicitationError::UserDeclined)` if user declined or cancelled the request
-    /// * `Err(ElicitationError::ParseError { .. })` if response data couldn't be parsed into type T
-    /// * `Err(ElicitationError::NoContent)` if no response content was provided
-    /// * `Err(ElicitationError::Service(_))` if the underlying service call failed
-    ///
-    /// # Example
-    ///
-    /// Add to your `Cargo.toml`:
-    /// ```toml
-    /// [dependencies]
-    /// rmcp = { version = "0.3", features = ["elicitation"] }
-    /// serde = { version = "1.0", features = ["derive"] }
-    /// schemars = "1.0"
-    /// ```
-    ///
-    /// ```rust,no_run
-    /// # use rmcp::*;
-    /// # use serde::{Deserialize, Serialize};
-    /// # use schemars::JsonSchema;
-    /// #
-    /// #[derive(Debug, Serialize, Deserialize, JsonSchema)]
-    /// struct UserProfile {
-    ///     #[schemars(description = "Full name")]
-    ///     name: String,
-    ///     #[schemars(description = "Email address")]
-    ///     email: String,
-    ///     #[schemars(description = "Age")]
-    ///     age: u8,
-    /// }
-    ///
-    /// # async fn example(peer: Peer<RoleClient>) -> Result<(), Box<dyn std::error::Error>> {
-    /// match peer.elicit::<UserProfile>("Please enter your profile information").await {
-    ///     Ok(Some(profile)) => {
-    ///         println!("Name: {}, Email: {}, Age: {}", profile.name, profile.email, profile.age);
-    ///     }
-    ///     Err(ElicitationError::UserDeclined) => {
-    ///         println!("User declined to provide information");
-    ///     }
-    ///     Err(ElicitationError::ParseError { error, data }) => {
-    ///         println!("Failed to parse response: {}\nData: {}", error, data);
-    ///     }
-    ///     Err(e) => return Err(e.into()),
-    /// }
-    /// # Ok(())
-    /// # }
-    /// ```
-    #[cfg(feature = "schemars")]
-    pub async fn elicit<T>(&self, message: impl Into<String>) -> Result<Option<T>, ElicitationError>
-    where
-        T: schemars::JsonSchema + for<'de> serde::Deserialize<'de>,
-    {
-        // Generate schema automatically from type
-        let schema = crate::handler::server::tool::schema_for_type::<T>();
-
-        let response = self
-            .create_elicitation(CreateElicitationRequestParam {
-                message: message.into(),
-                requested_schema: schema,
-            })
-            .await?;
-
-        match response.action {
-            crate::model::ElicitationAction::Accept => {
-                if let Some(value) = response.content {
-                    match serde_json::from_value::<T>(value.clone()) {
-                        Ok(parsed) => Ok(Some(parsed)),
-                        Err(error) => Err(ElicitationError::ParseError { error, data: value }),
-                    }
-                } else {
-                    Err(ElicitationError::NoContent)
-                }
-            }
-            _ => Err(ElicitationError::UserDeclined),
-        }
-    }
 }