fix(rmcp): tolerate empty cacheScope instead of silently dropping the whole result

ListToolsResult/ReadResourceResult.cache_scope: Option<CacheScope> had no
custom deserializer, unlike the sibling ttl_ms field, which already
tolerates out-of-range input via deserialize_ttl_ms. A server sending
cacheScope: "" (SEP-2549 only permits "public"/"private"/absent) failed
deserialization of the whole result - and because ServerResult is
#[serde(untagged)], that failure doesn't surface as an error. It falls
through variant-by-variant to CustomResult (the catch-all), so callers
silently lose typed access to .tools/.contents instead of getting a clear
error or a usable result.

Add deserialize_cache_scope, mirroring the existing deserialize_ttl_ms
normalize-don't-error pattern: "" and null are treated as absent,
everything else delegates to CacheScope's normal deserialization, so a
genuinely invalid value (e.g. "PUBLIC") still errors - it just no longer
takes the whole result down with it.

Add a regression test covering both direct ListToolsResult deserialization
and the full ServerResult untagged path, asserting the tool list survives
instead of degrading to CustomResult.

Signed-off-by: Wahib El Khadiri <wahibelkhadiri06@gmail.com>

Author: WAHIB-EL-KHADIRI

crates/rmcp/src/model.rs

@@ -1660,6 +1660,27 @@ where
     Ok(value.map(|ttl_ms| ttl_ms.max(0) as u64))
 }
 
+/// Normalize a `cacheScope` value during deserialization.
+///
+/// Per SEP-2549, `cacheScope` MUST be `"public"`, `"private"`, or absent; some
+/// servers instead send `""`. Because `ServerResult` is `#[serde(untagged)]`,
+/// letting that value hard-error here would silently fall through to
+/// `CustomResult` and drop the entire (otherwise valid) result. Treat an empty
+/// string the same as an absent field rather than erroring.
+fn deserialize_cache_scope<'de, D>(deserializer: D) -> Result<Option<CacheScope>, D::Error>
+where
+    D: serde::Deserializer<'de>,
+{
+    let value = Option::<Value>::deserialize(deserializer)?;
+    match value {
+        None | Some(Value::Null) => Ok(None),
+        Some(Value::String(s)) if s.is_empty() => Ok(None),
+        Some(value) => CacheScope::deserialize(value)
+            .map(Some)
+            .map_err(serde::de::Error::custom),
+    }
+}
+
 macro_rules! paginated_result {
     ($t:ident {
         $i_item: ident: $t_item: ty
@@ -1697,7 +1718,11 @@ macro_rules! paginated_result {
             /// Scope describing who may cache this result (SEP-2549).
             /// Required by spec version 2026-07-28, but optional here to maintain compatibility
             /// with older spec versions.
-            #[serde(default, skip_serializing_if = "Option::is_none")]
+            #[serde(
+                default,
+                deserialize_with = "deserialize_cache_scope",
+                skip_serializing_if = "Option::is_none"
+            )]
             pub cache_scope: Option<CacheScope>,
             pub $i_item: $t_item,
         }
@@ -1847,7 +1872,11 @@ pub struct ReadResourceResult {
     /// Scope describing who may cache this result (SEP-2549).
     /// Required by spec version 2026-07-28, but optional here to maintain compatibility
     /// with older spec versions.
-    #[serde(default, skip_serializing_if = "Option::is_none")]
+    #[serde(
+        default,
+        deserialize_with = "deserialize_cache_scope",
+        skip_serializing_if = "Option::is_none"
+    )]
     pub cache_scope: Option<CacheScope>,
     /// The actual content of the resource
     pub contents: Vec<ResourceContents>,

crates/rmcp/tests/test_cache_hints.rs

@@ -1,6 +1,31 @@
-use rmcp::model::{CacheScope, ListToolsResult, ReadResourceResult, ResourceContents};
+use rmcp::model::{CacheScope, ListToolsResult, ReadResourceResult, ResourceContents, ServerResult};
 use serde_json::json;
 
+#[test]
+fn repro_empty_cache_scope_drops_every_tool_via_untagged_fallthrough() {
+    let payload = json!({
+        "tools": [{ "name": "search", "inputSchema": { "type": "object" } }],
+        "cacheScope": ""
+    });
+
+    let direct = serde_json::from_value::<ListToolsResult>(payload.clone());
+    assert!(
+        direct.is_ok(),
+        "ListToolsResult itself must accept an empty cacheScope, got {direct:?}"
+    );
+    assert_eq!(direct.unwrap().tools.len(), 1);
+
+    let via_server_result: ServerResult =
+        serde_json::from_value(payload).expect("ServerResult must deserialize this payload");
+    match via_server_result {
+        ServerResult::ListToolsResult(r) => assert_eq!(r.tools.len(), 1),
+        other => panic!(
+            "expected ListToolsResult, got {other:?} \
+             (untagged fallthrough silently reinterpreted a valid tools/list result)"
+        ),
+    }
+}
+
 #[test]
 fn paginated_results_serialize_cache_hints_as_top_level_fields() {
     let result = ListToolsResult::with_all_items(Vec::new())