feat: add support for advanced JSON Schema types such as anyOf and allOf, oneOf (#16)

* feat: support anyOf, oneOf, allOf types

* feat: support representation of enum values

* cleanup

Author: hashemix

src/schema.rs

@@ -51,13 +51,113 @@ pub fn param_object(object_map: &Map<String, Value>) -> DiscoveryResult<Vec<McpT
 
 /// Determines the parameter type from a schema definition.
 pub fn param_type(type_info: &Map<String, Value>) -> DiscoveryResult<ParamTypes> {
+    // Check for 'enum' keyword
+    if let Some(enum_values) = type_info.get("enum") {
+        let values = enum_values.as_array().ok_or(DiscoveryError::InvalidSchema(
+            "'enum' field must be an array".to_string(),
+        ))?;
+        if values.is_empty() {
+            return Err(DiscoveryError::InvalidSchema(
+                "'enum' array cannot be empty".to_string(),
+            ));
+        }
+        let mut param_types = Vec::new();
+        for value in values {
+            let param_type = match value {
+                Value::String(s) => ParamTypes::Primitive(s.clone()),
+                Value::Number(n) => ParamTypes::Primitive(n.to_string()),
+                Value::Bool(b) => ParamTypes::Primitive(b.to_string()),
+                Value::Null => ParamTypes::Primitive("null".to_string()),
+                _ => {
+                    return Err(DiscoveryError::InvalidSchema(format!(
+                        "Unsupported enum value type: {}",
+                        serde_json::to_string(value).unwrap_or_default()
+                    )))
+                }
+            };
+            param_types.push(param_type);
+        }
+        return Ok(ParamTypes::EnumValues(param_types));
+    }
+
+    // Check for 'const' keyword
+    if let Some(const_value) = type_info.get("const") {
+        return Ok(ParamTypes::Primitive(
+            serde_json::to_string(const_value)
+                .unwrap_or_default()
+                .trim_matches('"')
+                .to_string(),
+        ));
+    }
+
+    if let Some(any_of) = type_info.get("anyOf") {
+        let any_of_array = any_of.as_array().ok_or(DiscoveryError::InvalidSchema(
+            "'anyOf' field must be an array".to_string(),
+        ))?;
+        if any_of_array.is_empty() {
+            return Err(DiscoveryError::InvalidSchema(
+                "'anyOf' array cannot be empty".to_string(),
+            ));
+        }
+        let mut enum_types = Vec::new();
+        for item in any_of_array {
+            let item_map = item.as_object().ok_or(DiscoveryError::InvalidSchema(
+                "Items in 'anyOf' must be objects".to_string(),
+            ))?;
+            enum_types.push(param_type(item_map)?);
+        }
+        return Ok(ParamTypes::Anyof(enum_types));
+    }
+
+    // Check for 'oneOf'
+    if let Some(one_of) = type_info.get("oneOf") {
+        let one_of_array = one_of.as_array().ok_or(DiscoveryError::InvalidSchema(
+            "'oneOf' field must be an array".to_string(),
+        ))?;
+        if one_of_array.is_empty() {
+            return Err(DiscoveryError::InvalidSchema(
+                "'oneOf' array cannot be empty".to_string(),
+            ));
+        }
+        let mut one_of_types = Vec::new();
+        for item in one_of_array {
+            let item_map = item.as_object().ok_or(DiscoveryError::InvalidSchema(
+                "Items in 'oneOf' must be objects".to_string(),
+            ))?;
+            one_of_types.push(param_type(item_map)?);
+        }
+        return Ok(ParamTypes::OneOf(one_of_types));
+    }
+
+    // Check for 'allOf'
+    if let Some(all_of) = type_info.get("allOf") {
+        let all_of_array = all_of.as_array().ok_or(DiscoveryError::InvalidSchema(
+            "'allOf' field must be an array".to_string(),
+        ))?;
+        if all_of_array.is_empty() {
+            return Err(DiscoveryError::InvalidSchema(
+                "'allOf' array cannot be empty".to_string(),
+            ));
+        }
+        let mut all_of_types = Vec::new();
+        for item in all_of_array {
+            let item_map = item.as_object().ok_or(DiscoveryError::InvalidSchema(
+                "Items in 'allOf' must be objects".to_string(),
+            ))?;
+            all_of_types.push(param_type(item_map)?);
+        }
+        return Ok(ParamTypes::AllOf(all_of_types));
+    }
+
+    // other types
     let type_name =
         type_info
             .get("type")
             .and_then(|v| v.as_str())
-            .ok_or(DiscoveryError::InvalidSchema(
-                "Missing or invalid 'type' field".to_string(),
-            ))?;
+            .ok_or(DiscoveryError::InvalidSchema(format!(
+                "Missing or invalid 'type' field: {}",
+                serde_json::to_string(&type_info).unwrap_or_default()
+            )))?;
 
     match type_name {
         "array" => {

src/types/capabilities.rs

@@ -27,6 +27,10 @@ pub enum ParamTypes {
     Primitive(String),
     Object(Vec<McpToolSParams>),
     Array(Vec<ParamTypes>),
+    Anyof(Vec<ParamTypes>),      // anyOf
+    OneOf(Vec<ParamTypes>),      // oneOf
+    AllOf(Vec<ParamTypes>),      // allOf
+    EnumValues(Vec<ParamTypes>), // JSON Schema enum
 }
 
 impl Display for ParamTypes {
@@ -44,6 +48,26 @@ impl Display for ParamTypes {
                 )
             }
             ParamTypes::Array(items) => format!("{} [ ]", items[0]),
+            ParamTypes::Anyof(types) => types
+                .iter()
+                .map(|t| t.to_string())
+                .collect::<Vec<String>>()
+                .join(" | "),
+            ParamTypes::OneOf(types) => types
+                .iter()
+                .map(|t| t.to_string())
+                .collect::<Vec<String>>()
+                .join(" | "),
+            ParamTypes::AllOf(types) => types
+                .iter()
+                .map(|t| t.to_string())
+                .collect::<Vec<String>>()
+                .join(" & "),
+            ParamTypes::EnumValues(types) => types
+                .iter()
+                .map(|t| t.to_string())
+                .collect::<Vec<String>>()
+                .join("|"),
         };
         write!(f, "{}", type_name)
     }