chore(unstable): Remove RequiredNullable dead code (#1026)

Author: benbrandt

src/agent.rs

@@ -6051,6 +6051,22 @@ mod test_serialization {
         assert!(deserialized.current.is_none());
     }
 
+    #[cfg(feature = "unstable_llm_providers")]
+    #[test]
+    fn test_provider_info_explicit_null_current_decodes_to_none() {
+        // current: null and an omitted current are equivalent on the wire;
+        // both must deserialize into None so the disabled state is preserved
+        // regardless of which form the peer chose to send.
+        let json = json!({
+            "id": "main",
+            "supported": ["anthropic"],
+            "required": true,
+            "current": null
+        });
+        let deserialized: ProviderInfo = serde_json::from_value(json).unwrap();
+        assert!(deserialized.current.is_none());
+    }
+
     #[cfg(feature = "unstable_llm_providers")]
     #[test]
     fn test_list_providers_response_serialization() {

src/serde_util.rs

@@ -3,7 +3,6 @@
 //! ## Types
 //!
 //! - [`MaybeUndefined<T>`] — three-state: undefined (key absent), null, or value.
-//! - [`RequiredNullable<T>`] — required-but-nullable: key must be present, value may be null.
 //! - [`SkipListener`] — [`serde_with::InspectError`] hook used by every
 //!   `VecSkipError` call site in the protocol types.
 //!
@@ -630,140 +629,6 @@ impl IntoMaybeUndefined<serde_json::Value> for Cow<'_, str> {
     }
 }
 
-// ---- RequiredNullable<T> ----
-
-/// A value that must be present on the wire but whose value may be `null`.
-///
-/// Unlike `Option<T>`, which serde treats as an implicitly optional field
-/// (defaulting to `None` when absent), `RequiredNullable<T>` requires the key to be
-/// present during deserialization. A missing field will produce a
-/// deserialization error rather than silently defaulting to `None`.
-///
-/// On the wire this serializes identically to `Option<T>` — either `null` or
-/// the JSON representation of `T`.
-///
-/// **Note:** The `Deserialize` impl uses `serde_json::Value` internally to
-/// enforce the "required" constraint, so this type is JSON-only.
-///
-/// # Example
-///
-/// ```rust
-/// use agent_client_protocol_schema::RequiredNullable;
-/// use serde::{Serialize, Deserialize};
-///
-/// #[derive(Serialize, Deserialize, Debug, PartialEq)]
-/// struct Config {
-///     // MUST be present in JSON, but its value can be null
-///     value: RequiredNullable<String>,
-/// }
-///
-/// // ✅ Present with a value
-/// let c: Config = serde_json::from_str(r#"{"value":"hello"}"#).unwrap();
-/// assert_eq!(c.value, RequiredNullable::new("hello".to_string()));
-///
-/// // ✅ Present as null
-/// let c: Config = serde_json::from_str(r#"{"value":null}"#).unwrap();
-/// assert_eq!(c.value, RequiredNullable::null());
-///
-/// // ❌ Missing key — deserialization error
-/// assert!(serde_json::from_str::<Config>(r#"{}"#).is_err());
-/// ```
-#[cfg(feature = "unstable_llm_providers")]
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, JsonSchema)]
-#[schemars(with = "Option<T>", inline)]
-#[non_exhaustive]
-pub struct RequiredNullable<T>(pub Option<T>);
-
-#[cfg(feature = "unstable_llm_providers")]
-impl<T> Default for RequiredNullable<T> {
-    fn default() -> Self {
-        Self(None)
-    }
-}
-
-#[cfg(feature = "unstable_llm_providers")]
-impl<T: Serialize> Serialize for RequiredNullable<T> {
-    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
-        self.0.serialize(serializer)
-    }
-}
-
-#[cfg(feature = "unstable_llm_providers")]
-impl<'de, T: Deserialize<'de>> Deserialize<'de> for RequiredNullable<T> {
-    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
-        // Deserialize via serde_json::Value so that `deserialize_any` is called.
-        // serde's MissingFieldDeserializer errors on `deserialize_any` (good — the
-        // field is required), whereas `deserialize_option` silently returns None.
-        let value = serde_json::Value::deserialize(deserializer)?;
-        if value.is_null() {
-            Ok(RequiredNullable(None))
-        } else {
-            T::deserialize(value)
-                .map(RequiredNullable::new)
-                .map_err(serde::de::Error::custom)
-        }
-    }
-}
-
-#[cfg(feature = "unstable_llm_providers")]
-impl<T> RequiredNullable<T> {
-    /// Creates a `RequiredNullable` containing a value.
-    #[must_use]
-    pub fn new(value: T) -> Self {
-        Self(Some(value))
-    }
-
-    /// Creates a `RequiredNullable` representing `null`.
-    #[must_use]
-    pub fn null() -> Self {
-        Self(None)
-    }
-
-    /// Returns `true` if the value is `null`.
-    #[must_use]
-    pub fn is_null(&self) -> bool {
-        self.0.is_none()
-    }
-
-    /// Returns `true` if the value is present (not null).
-    #[must_use]
-    pub fn is_value(&self) -> bool {
-        self.0.is_some()
-    }
-
-    /// Returns a reference to the contained value, if present.
-    #[must_use]
-    pub fn value(&self) -> Option<&T> {
-        self.0.as_ref()
-    }
-
-    /// Returns a mutable reference to the contained value, if present.
-    #[must_use]
-    pub fn value_mut(&mut self) -> Option<&mut T> {
-        self.0.as_mut()
-    }
-
-    /// Converts into the inner `Option<T>`.
-    #[must_use]
-    pub fn into_inner(self) -> Option<T> {
-        self.0
-    }
-}
-
-#[cfg(feature = "unstable_llm_providers")]
-impl<T> From<Option<T>> for RequiredNullable<T> {
-    fn from(value: Option<T>) -> Self {
-        Self(value)
-    }
-}
-
-#[cfg(feature = "unstable_llm_providers")]
-impl<T> From<RequiredNullable<T>> for Option<T> {
-    fn from(value: RequiredNullable<T>) -> Self {
-        value.0
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use serde::{Deserialize, Serialize};
@@ -957,89 +822,4 @@ mod tests {
         value = MaybeUndefined::Value(Err("error"));
         assert_eq!(value.transpose(), Err("error"));
     }
-
-    // ---- RequiredNullable tests ----
-
-    #[cfg(feature = "unstable_llm_providers")]
-    mod nullable_tests {
-        use super::*;
-        use serde_json::from_str;
-
-        #[derive(Serialize, Deserialize, Debug, PartialEq)]
-        struct Example {
-            value: RequiredNullable<String>,
-        }
-
-        #[test]
-        fn present_with_value() {
-            let example: Example = from_str(r#"{"value":"hello"}"#).unwrap();
-            assert_eq!(example.value, RequiredNullable(Some("hello".to_string())));
-        }
-
-        #[test]
-        fn present_as_null() {
-            let example: Example = from_str(r#"{"value":null}"#).unwrap();
-            assert_eq!(example.value, RequiredNullable(None));
-        }
-
-        #[test]
-        fn missing_key_fails() {
-            assert!(from_str::<Example>(r"{}").is_err());
-        }
-
-        #[test]
-        fn serialize_value() {
-            let example = Example {
-                value: RequiredNullable(Some("hello".to_string())),
-            };
-            assert_eq!(to_value(&example).unwrap(), json!({"value": "hello"}));
-        }
-
-        #[test]
-        fn serialize_null() {
-            let example = Example {
-                value: RequiredNullable(None),
-            };
-            assert_eq!(to_value(&example).unwrap(), json!({"value": null}));
-        }
-
-        #[test]
-        fn from_option() {
-            let nullable: RequiredNullable<i32> = Some(42).into();
-            assert_eq!(nullable, RequiredNullable(Some(42)));
-
-            let nullable: RequiredNullable<i32> = None.into();
-            assert_eq!(nullable, RequiredNullable(None));
-        }
-
-        #[test]
-        fn into_option() {
-            let option: Option<i32> = RequiredNullable(Some(42)).into();
-            assert_eq!(option, Some(42));
-
-            let option: Option<i32> = RequiredNullable(None).into();
-            assert_eq!(option, None);
-        }
-
-        #[test]
-        fn methods() {
-            let value = RequiredNullable::new(42);
-            assert!(value.is_value());
-            assert!(!value.is_null());
-            assert_eq!(value.value(), Some(&42));
-            assert_eq!(value.into_inner(), Some(42));
-
-            let null: RequiredNullable<i32> = RequiredNullable::null();
-            assert!(!null.is_value());
-            assert!(null.is_null());
-            assert_eq!(null.value(), None);
-            assert_eq!(null.into_inner(), None);
-        }
-
-        #[test]
-        fn default_is_null() {
-            let nullable: RequiredNullable<i32> = RequiredNullable::default();
-            assert_eq!(nullable, RequiredNullable(None));
-        }
-    }
 }