fix: address metadata review feedback

Author: DaleSeo

crates/rmcp/src/model/meta.rs

@@ -259,10 +259,12 @@ pub struct MetaObject(pub JsonObject);
 
 /// Deprecated alias for [`MetaObject`].
 ///
-/// Note: request and notification metadata now have dedicated types; use
-/// [`RequestMetaObject`] or [`NotificationMetaObject`] where those are expected.
+/// This is a re-export rather than a type alias so the `Meta(...)` tuple
+/// constructor keeps working. Request and notification metadata now have
+/// dedicated types; use [`RequestMetaObject`] or [`NotificationMetaObject`]
+/// where those are expected.
 #[deprecated(note = "Use MetaObject (or RequestMetaObject / NotificationMetaObject)")]
-pub type Meta = MetaObject;
+pub use self::MetaObject as Meta;
 
 impl MetaObject {
     /// Reserved `_meta` key for the W3C Trace Context `traceparent` value (SEP-414).
@@ -390,14 +392,15 @@ impl schemars::JsonSchema for MetaObject {
 ///
 /// In addition to arbitrary extension keys, requests reserve:
 /// - `progressToken` for progress tracking
-/// - `io.modelcontextprotocol/protocolVersion` (SEP-1319)
-/// - `io.modelcontextprotocol/clientInfo` (SEP-1319)
-/// - `io.modelcontextprotocol/clientCapabilities` (SEP-1319)
-/// - `io.modelcontextprotocol/logLevel` (SEP-1319)
+/// - `io.modelcontextprotocol/protocolVersion` (SEP-2575)
+/// - `io.modelcontextprotocol/clientInfo` (SEP-2575)
+/// - `io.modelcontextprotocol/clientCapabilities` (SEP-2575)
+/// - `io.modelcontextprotocol/logLevel` (SEP-2575)
 ///
 /// The 2026-07-28 draft schema marks the protocol-version, client-info, and
 /// client-capabilities keys as required; earlier protocol versions do not know
-/// them. All keys therefore stay optional at runtime — use
+/// them. All keys therefore stay optional at runtime and in the generated
+/// (version-shared) JSON schema — use
 /// [`RequestMetaObject::missing_required_keys`] to validate a request against
 /// the negotiated protocol version.
 ///
@@ -496,8 +499,12 @@ impl RequestMetaObject {
             .insert_serialized(Self::META_KEY_LOG_LEVEL, log_level);
     }
 
-    /// Return the [`Self::DRAFT_REQUIRED_KEYS`] absent from this map, if
-    /// `protocol_version` requires them.
+    /// Return the [`Self::DRAFT_REQUIRED_KEYS`] whose values are absent or
+    /// invalid in this map, if `protocol_version` requires them.
+    ///
+    /// A key counts as missing when it is not present *or* when its value does
+    /// not decode into the expected type (e.g. a numeric `protocolVersion` or
+    /// a string `clientInfo`), matching what the typed accessors return.
     ///
     /// Protocol versions before 2026-07-28 have no required request metadata,
     /// so this always returns an empty list for them.
@@ -513,7 +520,7 @@ impl RequestMetaObject {
     ///     meta.missing_required_keys(&ProtocolVersion::V_2025_11_25)
     ///         .is_empty()
     /// );
-    /// // The 2026-07-28 draft requires the SEP-1319 keys.
+    /// // The 2026-07-28 draft requires the SEP-2575 keys.
     /// assert_eq!(
     ///     meta.missing_required_keys(&ProtocolVersion::V_2026_07_28),
     ///     RequestMetaObject::DRAFT_REQUIRED_KEYS.to_vec(),
@@ -523,10 +530,17 @@ impl RequestMetaObject {
         if protocol_version.as_str() < ProtocolVersion::V_2026_07_28.as_str() {
             return Vec::new();
         }
-        Self::DRAFT_REQUIRED_KEYS
-            .into_iter()
-            .filter(|key| !self.0.0.contains_key(*key))
-            .collect()
+        let mut missing = Vec::new();
+        if self.protocol_version().is_none() {
+            missing.push(Self::META_KEY_PROTOCOL_VERSION);
+        }
+        if self.client_info().is_none() {
+            missing.push(Self::META_KEY_CLIENT_INFO);
+        }
+        if self.client_capabilities().is_none() {
+            missing.push(Self::META_KEY_CLIENT_CAPABILITIES);
+        }
+        missing
     }
 
     /// Insert every entry of `other`, overwriting existing keys on conflict.
@@ -572,6 +586,11 @@ impl schemars::JsonSchema for RequestMetaObject {
         let client_info = generator.subschema_for::<Implementation>();
         let client_capabilities = generator.subschema_for::<ClientCapabilities>();
         let log_level = generator.subschema_for::<LoggingLevel>();
+        // rmcp generates one schema shared by every supported protocol
+        // version, so the keys the 2026-07-28 draft marks as required are left
+        // optional here: a 2025-11-25 request whose `_meta` only carries
+        // `progressToken` is valid. Draft-strict validation is available at
+        // runtime via [`RequestMetaObject::missing_required_keys`].
         schemars::json_schema!({
             "description": "Metadata reserved by MCP on requests. Extension keys are also allowed.",
             "type": "object",
@@ -584,11 +603,6 @@ impl schemars::JsonSchema for RequestMetaObject {
                 "io.modelcontextprotocol/clientCapabilities": client_capabilities,
                 "io.modelcontextprotocol/logLevel": log_level,
             },
-            "required": [
-                "io.modelcontextprotocol/protocolVersion",
-                "io.modelcontextprotocol/clientInfo",
-                "io.modelcontextprotocol/clientCapabilities",
-            ],
             "additionalProperties": true,
         })
     }
@@ -831,6 +845,20 @@ mod tests {
             );
         }
 
+        #[test]
+        fn treats_malformed_values_as_missing() {
+            let meta: RequestMetaObject = serde_json::from_value(serde_json::json!({
+                "io.modelcontextprotocol/protocolVersion": 123,
+                "io.modelcontextprotocol/clientInfo": "not an implementation",
+                "io.modelcontextprotocol/clientCapabilities": null,
+            }))
+            .unwrap();
+            assert_eq!(
+                meta.missing_required_keys(&ProtocolVersion::V_2026_07_28),
+                RequestMetaObject::DRAFT_REQUIRED_KEYS.to_vec()
+            );
+        }
+
         #[test]
         fn is_empty_when_draft_keys_are_present() {
             let mut meta = RequestMetaObject::new();

crates/rmcp/src/model/serde_impl.rs

@@ -3,7 +3,7 @@ use std::borrow::Cow;
 use serde::{Deserialize, Serialize};
 
 use super::{
-    CustomNotification, CustomRequest, Extensions, JsonObject, Notification,
+    CustomNotification, CustomRequest, Extensions, JsonObject, MetaObject, Notification,
     NotificationMetaObject, NotificationNoParam, Request, RequestMetaObject, RequestNoParam,
     RequestOptionalParam,
 };
@@ -85,18 +85,39 @@ struct ProxyNoParam<M> {
     method: M,
 }
 
+/// Combine the message-specific `_meta` map with a legacy [`MetaObject`]
+/// extension (inserted through the deprecated `Meta` name), so pre-3.x code
+/// does not silently lose metadata on the wire. On key conflicts the
+/// message-specific map wins.
+fn merge_legacy_meta<'a>(
+    typed: Option<&'a JsonObject>,
+    extensions: &'a Extensions,
+) -> Option<Cow<'a, JsonObject>> {
+    let legacy = extensions.get::<MetaObject>().map(|meta| &meta.0);
+    match (typed, legacy) {
+        (Some(typed), None) => Some(Cow::Borrowed(typed)),
+        (None, Some(legacy)) => Some(Cow::Borrowed(legacy)),
+        (Some(typed), Some(legacy)) => {
+            let mut merged = legacy.clone();
+            merged.extend(typed.clone());
+            Some(Cow::Owned(merged))
+        }
+        (None, None) => None,
+    }
+}
+
 /// Borrow the request `_meta` map from extensions, if any.
 fn request_meta(extensions: &Extensions) -> Option<Cow<'_, JsonObject>> {
-    extensions
-        .get::<RequestMetaObject>()
-        .map(|meta| Cow::Borrowed(&meta.0.0))
+    let typed = extensions.get::<RequestMetaObject>().map(|meta| &meta.0.0);
+    merge_legacy_meta(typed, extensions)
 }
 
 /// Borrow the notification `_meta` map from extensions, if any.
 fn notification_meta(extensions: &Extensions) -> Option<Cow<'_, JsonObject>> {
-    extensions
+    let typed = extensions
         .get::<NotificationMetaObject>()
-        .map(|meta| Cow::Borrowed(&meta.0.0))
+        .map(|meta| &meta.0.0);
+    merge_legacy_meta(typed, extensions)
 }
 
 /// Build extensions holding a typed metadata map deserialized from `params._meta`.
@@ -761,6 +782,62 @@ mod test {
         let _req: PingRequest = serde_json::from_value(json!({"method": "ping"})).unwrap();
     }
 
+    #[test]
+    fn test_legacy_meta_extension_still_serializes() {
+        // Pre-3.x code inserts `MetaObject` into extensions through the
+        // deprecated `Meta` name; its metadata must not be silently dropped.
+        let mut extensions = Extensions::new();
+        let mut legacy = crate::model::MetaObject::new();
+        legacy.insert("traceId".to_string(), json!("legacy"));
+        extensions.insert(legacy);
+
+        let req = CallToolRequest {
+            extensions,
+            method: Default::default(),
+            params: CallToolRequestParams {
+                meta: None,
+                name: "my_tool".into(),
+                arguments: None,
+                task: None,
+                input_responses: None,
+                request_state: None,
+            },
+        };
+
+        let value = serde_json::to_value(&req).unwrap();
+        assert_eq!(value["params"]["_meta"]["traceId"], json!("legacy"));
+    }
+
+    #[test]
+    fn test_typed_meta_wins_over_legacy_extension_on_conflict() {
+        let mut extensions = Extensions::new();
+        let mut legacy = crate::model::MetaObject::new();
+        legacy.insert("shared".to_string(), json!("legacy"));
+        legacy.insert("legacy_only".to_string(), json!("kept"));
+        extensions.insert(legacy);
+        let mut typed = RequestMetaObject::new();
+        typed.insert("shared".to_string(), json!("typed"));
+        extensions.insert(typed);
+
+        let req = CallToolRequest {
+            extensions,
+            method: Default::default(),
+            params: CallToolRequestParams {
+                meta: None,
+                name: "my_tool".into(),
+                arguments: None,
+                task: None,
+                input_responses: None,
+                request_state: None,
+            },
+        };
+
+        let value = serde_json::to_value(&req).unwrap();
+        let meta = value["params"]["_meta"].as_object().unwrap();
+        assert_eq!(meta.get("shared").unwrap(), "typed");
+        assert_eq!(meta.get("legacy_only").unwrap(), "kept");
+    }
+
     #[test]
     fn test_arbitrary_meta_keys_round_trip_unchanged() {
         let input = json!({

crates/rmcp/tests/test_message_schema.rs

@@ -61,11 +61,13 @@ mod tests {
         );
     }
 
-    /// The three metadata definitions must match the MCP 2026-07-28 draft
-    /// schema exactly: `MetaObject` is an open map, `RequestMetaObject`
-    /// reserves `progressToken` plus the SEP-1319 keys (three of which the
-    /// draft marks required), and `NotificationMetaObject` reserves
-    /// `io.modelcontextprotocol/subscriptionId`.
+    /// The three metadata definitions must expose the MCP 2026-07-28 draft
+    /// vocabulary: `MetaObject` is an open map, `RequestMetaObject` reserves
+    /// `progressToken` plus the SEP-2575 keys, and `NotificationMetaObject`
+    /// reserves `io.modelcontextprotocol/subscriptionId`. The keys the draft
+    /// marks as required stay optional because rmcp generates one schema
+    /// shared by every supported protocol version; draft-strict validation is
+    /// a runtime concern (`RequestMetaObject::missing_required_keys`).
     #[test]
     fn test_metadata_definitions_match_draft_schema() {
         let settings = SchemaSettings::draft07();
@@ -96,11 +98,6 @@ mod tests {
                     "io.modelcontextprotocol/clientCapabilities": { "$ref": "#/definitions/ClientCapabilities" },
                     "io.modelcontextprotocol/logLevel": { "$ref": "#/definitions/LoggingLevel" },
                 },
-                "required": [
-                    "io.modelcontextprotocol/protocolVersion",
-                    "io.modelcontextprotocol/clientInfo",
-                    "io.modelcontextprotocol/clientCapabilities",
-                ],
                 "additionalProperties": true,
             })
         );

crates/rmcp/tests/test_message_schema/client_json_rpc_message_schema.json

@@ -1727,12 +1727,7 @@
           "$ref": "#/definitions/ProgressToken"
         }
       },
-      "additionalProperties": true,
-      "required": [
-        "io.modelcontextprotocol/protocolVersion",
-        "io.modelcontextprotocol/clientInfo",
-        "io.modelcontextprotocol/clientCapabilities"
-      ]
+      "additionalProperties": true
     },
     "RequestNoParam": {
       "type": "object",

crates/rmcp/tests/test_message_schema/client_json_rpc_message_schema_current.json

@@ -1727,12 +1727,7 @@
           "$ref": "#/definitions/ProgressToken"
         }
       },
-      "additionalProperties": true,
-      "required": [
-        "io.modelcontextprotocol/protocolVersion",
-        "io.modelcontextprotocol/clientInfo",
-        "io.modelcontextprotocol/clientCapabilities"
-      ]
+      "additionalProperties": true
     },
     "RequestNoParam": {
       "type": "object",

crates/rmcp/tests/test_message_schema/server_json_rpc_message_schema.json

@@ -2607,12 +2607,7 @@
           "$ref": "#/definitions/ProgressToken"
         }
       },
-      "additionalProperties": true,
-      "required": [
-        "io.modelcontextprotocol/protocolVersion",
-        "io.modelcontextprotocol/clientInfo",
-        "io.modelcontextprotocol/clientCapabilities"
-      ]
+      "additionalProperties": true
     },
     "RequestNoParam": {
       "type": "object",

crates/rmcp/tests/test_message_schema/server_json_rpc_message_schema_current.json

@@ -2607,12 +2607,7 @@
           "$ref": "#/definitions/ProgressToken"
         }
       },
-      "additionalProperties": true,
-      "required": [
-        "io.modelcontextprotocol/protocolVersion",
-        "io.modelcontextprotocol/clientInfo",
-        "io.modelcontextprotocol/clientCapabilities"
-      ]
+      "additionalProperties": true
     },
     "RequestNoParam": {
       "type": "object",