feat: add conversion methods to ElicitationSchema

Add from_json_schema() and from_type() methods to ElicitationSchema
for easier type-to-schema conversion. This addresses feedback about
improving ergonomics when working with generated schemas.

Also make all struct fields public for better flexibility.

Author: ByteBaker

crates/rmcp/src/model/elicitation_schema.rs

@@ -72,27 +72,27 @@ pub enum PrimitiveSchema {
 pub struct StringSchema {
     /// Type discriminator
     #[serde(rename = "type")]
-    type_: StringTypeConst,
+    pub type_: StringTypeConst,
 
     /// Optional title for the schema
     #[serde(skip_serializing_if = "Option::is_none")]
-    title: Option<Cow<'static, str>>,
+    pub title: Option<Cow<'static, str>>,
 
     /// Human-readable description
     #[serde(skip_serializing_if = "Option::is_none")]
-    description: Option<Cow<'static, str>>,
+    pub description: Option<Cow<'static, str>>,
 
     /// Minimum string length
     #[serde(skip_serializing_if = "Option::is_none")]
-    min_length: Option<u32>,
+    pub min_length: Option<u32>,
 
     /// Maximum string length
     #[serde(skip_serializing_if = "Option::is_none")]
-    max_length: Option<u32>,
+    pub max_length: Option<u32>,
 
     /// String format - limited to: "email", "uri", "date", "date-time"
     #[serde(skip_serializing_if = "Option::is_none")]
-    format: Option<Cow<'static, str>>,
+    pub format: Option<Cow<'static, str>>,
 }
 
 impl Default for StringSchema {
@@ -209,7 +209,7 @@ impl StringSchema {
 pub struct NumberSchema {
     /// Type discriminator
     #[serde(rename = "type")]
-    type_: NumberTypeConst,
+    pub type_: NumberTypeConst,
 
     /// Optional title for the schema
     #[serde(skip_serializing_if = "Option::is_none")]
@@ -303,7 +303,7 @@ impl NumberSchema {
 pub struct IntegerSchema {
     /// Type discriminator
     #[serde(rename = "type")]
-    type_: IntegerTypeConst,
+    pub type_: IntegerTypeConst,
 
     /// Optional title for the schema
     #[serde(skip_serializing_if = "Option::is_none")]
@@ -394,7 +394,7 @@ impl IntegerSchema {
 pub struct BooleanSchema {
     /// Type discriminator
     #[serde(rename = "type")]
-    type_: BooleanTypeConst,
+    pub type_: BooleanTypeConst,
 
     /// Optional title for the schema
     #[serde(skip_serializing_if = "Option::is_none")]
@@ -459,23 +459,23 @@ impl BooleanSchema {
 pub struct EnumSchema {
     /// Type discriminator (always "string" for enums)
     #[serde(rename = "type")]
-    type_: StringTypeConst,
+    pub type_: StringTypeConst,
 
     /// Allowed enum values (string values only per MCP spec)
     #[serde(rename = "enum")]
-    enum_values: Vec<String>,
+    pub enum_values: Vec<String>,
 
     /// Optional human-readable names for each enum value
     #[serde(skip_serializing_if = "Option::is_none")]
-    enum_names: Option<Vec<String>>,
+    pub enum_names: Option<Vec<String>>,
 
     /// Optional title for the schema
     #[serde(skip_serializing_if = "Option::is_none")]
-    title: Option<Cow<'static, str>>,
+    pub title: Option<Cow<'static, str>>,
 
     /// Human-readable description
     #[serde(skip_serializing_if = "Option::is_none")]
-    description: Option<Cow<'static, str>>,
+    pub description: Option<Cow<'static, str>>,
 }
 
 impl EnumSchema {
@@ -535,7 +535,7 @@ impl EnumSchema {
 pub struct ElicitationSchema {
     /// Always "object" for elicitation schemas
     #[serde(rename = "type")]
-    type_: ObjectTypeConst,
+    pub type_: ObjectTypeConst,
 
     /// Optional title for the schema
     #[serde(skip_serializing_if = "Option::is_none")]
@@ -565,6 +565,74 @@ impl ElicitationSchema {
         }
     }
 
+    /// Convert from a JSON Schema object (typically generated by schemars)
+    ///
+    /// This allows converting from JsonObject to ElicitationSchema, which is useful
+    /// when working with automatically generated schemas from types.
+    ///
+    /// # Example
+    ///
+    /// ```rust,ignore
+    /// use rmcp::model::*;
+    ///
+    /// let json_schema = schema_for_type::<MyType>();
+    /// let elicitation_schema = ElicitationSchema::from_json_schema(json_schema)?;
+    /// ```
+    ///
+    /// # Errors
+    ///
+    /// Returns a [`serde_json::Error`] if the JSON object cannot be deserialized
+    /// into a valid ElicitationSchema.
+    pub fn from_json_schema(schema: crate::model::JsonObject) -> Result<Self, serde_json::Error> {
+        serde_json::from_value(serde_json::Value::Object(schema))
+    }
+
+    /// Generate an ElicitationSchema from a Rust type that implements JsonSchema
+    ///
+    /// This is a convenience method that combines schema generation and conversion.
+    /// It uses the same schema generation settings as the rest of the MCP SDK.
+    ///
+    /// # Example
+    ///
+    /// ```rust,ignore
+    /// use rmcp::model::*;
+    /// use schemars::JsonSchema;
+    /// use serde::{Deserialize, Serialize};
+    ///
+    /// #[derive(JsonSchema, Serialize, Deserialize)]
+    /// struct UserInput {
+    ///     name: String,
+    ///     age: u32,
+    /// }
+    ///
+    /// let schema = ElicitationSchema::from_type::<UserInput>()?;
+    /// ```
+    ///
+    /// # Errors
+    ///
+    /// Returns a [`serde_json::Error`] if the generated schema cannot be converted
+    /// to a valid ElicitationSchema.
+    #[cfg(feature = "schemars")]
+    pub fn from_type<T>() -> Result<Self, serde_json::Error>
+    where
+        T: schemars::JsonSchema,
+    {
+        use crate::schemars::generate::SchemaSettings;
+
+        let mut settings = SchemaSettings::draft07();
+        settings.transforms = vec![Box::new(schemars::transform::AddNullable::default())];
+        let generator = settings.into_generator();
+        let schema = generator.into_root_schema_for::<T>();
+        let object = serde_json::to_value(schema).expect("failed to serialize schema");
+        match object {
+            serde_json::Value::Object(object) => Self::from_json_schema(object),
+            _ => panic!(
+                "Schema serialization produced non-object value: expected JSON object but got {:?}",
+                object
+            ),
+        }
+    }
+
     /// Set the required fields
     pub fn with_required(mut self, required: Vec<String>) -> Self {
         self.required = Some(required);
@@ -609,10 +677,10 @@ impl ElicitationSchema {
 /// ```
 #[derive(Debug, Default)]
 pub struct ElicitationSchemaBuilder {
-    properties: BTreeMap<String, PrimitiveSchema>,
-    required: Vec<String>,
-    title: Option<Cow<'static, str>>,
-    description: Option<Cow<'static, str>>,
+    pub properties: BTreeMap<String, PrimitiveSchema>,
+    pub required: Vec<String>,
+    pub title: Option<Cow<'static, str>>,
+    pub description: Option<Cow<'static, str>>,
 }
 
 impl ElicitationSchemaBuilder {

crates/rmcp/src/service/server.rs

@@ -677,20 +677,16 @@ impl Peer<RoleServer> {
         }
 
         // Generate schema automatically from type
-        let schema_json = crate::handler::server::tool::schema_for_type::<T>();
-
-        // Convert JsonObject to ElicitationSchema
-        let schema: crate::model::ElicitationSchema =
-            serde_json::from_value(serde_json::Value::Object(schema_json)).map_err(|e| {
-                ElicitationError::Service(ServiceError::McpError(crate::ErrorData::invalid_params(
-                    format!(
-                        "Invalid schema for type {}: {}",
-                        std::any::type_name::<T>(),
-                        e
-                    ),
-                    None,
-                )))
-            })?;
+        let schema = crate::model::ElicitationSchema::from_type::<T>().map_err(|e| {
+            ElicitationError::Service(ServiceError::McpError(crate::ErrorData::invalid_params(
+                format!(
+                    "Invalid schema for type {}: {}",
+                    std::any::type_name::<T>(),
+                    e
+                ),
+                None,
+            )))
+        })?;
 
         let response = self
             .create_elicitation_with_timeout(