app-server: propagate nested experimental gating for AskForApproval::Reject

codex-rs/app-server-protocol/src/experimental_api.rs

@@ -1,3 +1,6 @@
+use std::collections::BTreeMap;
+use std::collections::HashMap;
+
 /// Marker trait for protocol types that can signal experimental usage.
 pub trait ExperimentalApi {
     /// Returns a short reason identifier when an experimental method or field is
@@ -28,8 +31,34 @@ pub fn experimental_required_message(reason: &str) -> String {
     format!("{reason} requires experimentalApi capability")
 }
 
+impl<T: ExperimentalApi> ExperimentalApi for Option<T> {
+    fn experimental_reason(&self) -> Option<&'static str> {
+        self.as_ref().and_then(ExperimentalApi::experimental_reason)
+    }
+}
+
+impl<T: ExperimentalApi> ExperimentalApi for Vec<T> {
+    fn experimental_reason(&self) -> Option<&'static str> {
+        self.iter().find_map(ExperimentalApi::experimental_reason)
+    }
+}
+
+impl<K, V: ExperimentalApi, S> ExperimentalApi for HashMap<K, V, S> {
+    fn experimental_reason(&self) -> Option<&'static str> {
+        self.values().find_map(ExperimentalApi::experimental_reason)
+    }
+}
+
+impl<K: Ord, V: ExperimentalApi> ExperimentalApi for BTreeMap<K, V> {
+    fn experimental_reason(&self) -> Option<&'static str> {
+        self.values().find_map(ExperimentalApi::experimental_reason)
+    }
+}
+
 #[cfg(test)]
 mod tests {
+    use std::collections::HashMap;
+
     use super::ExperimentalApi as ExperimentalApiTrait;
     use codex_experimental_api_macros::ExperimentalApi;
     use pretty_assertions::assert_eq;
@@ -48,6 +77,27 @@ mod tests {
         StableTuple(u8),
     }
 
+    #[allow(dead_code)]
+    #[derive(ExperimentalApi)]
+    struct NestedFieldShape {
+        #[experimental(nested)]
+        inner: Option<EnumVariantShapes>,
+    }
+
+    #[allow(dead_code)]
+    #[derive(ExperimentalApi)]
+    struct NestedCollectionShape {
+        #[experimental(nested)]
+        inners: Vec<EnumVariantShapes>,
+    }
+
+    #[allow(dead_code)]
+    #[derive(ExperimentalApi)]
+    struct NestedMapShape {
+        #[experimental(nested)]
+        inners: HashMap<String, EnumVariantShapes>,
+    }
+
     #[test]
     fn derive_supports_all_enum_variant_shapes() {
         assert_eq!(
@@ -67,4 +117,56 @@ mod tests {
             None
         );
     }
+
+    #[test]
+    fn derive_supports_nested_experimental_fields() {
+        assert_eq!(
+            ExperimentalApiTrait::experimental_reason(&NestedFieldShape {
+                inner: Some(EnumVariantShapes::Named { value: 1 }),
+            }),
+            Some("enum/named")
+        );
+        assert_eq!(
+            ExperimentalApiTrait::experimental_reason(&NestedFieldShape { inner: None }),
+            None
+        );
+    }
+
+    #[test]
+    fn derive_supports_nested_collections() {
+        assert_eq!(
+            ExperimentalApiTrait::experimental_reason(&NestedCollectionShape {
+                inners: vec![
+                    EnumVariantShapes::StableTuple(1),
+                    EnumVariantShapes::Tuple(2)
+                ],
+            }),
+            Some("enum/tuple")
+        );
+        assert_eq!(
+            ExperimentalApiTrait::experimental_reason(&NestedCollectionShape {
+                inners: Vec::new()
+            }),
+            None
+        );
+    }
+
+    #[test]
+    fn derive_supports_nested_maps() {
+        assert_eq!(
+            ExperimentalApiTrait::experimental_reason(&NestedMapShape {
+                inners: HashMap::from([(
+                    "default".to_string(),
+                    EnumVariantShapes::Named { value: 1 },
+                )]),
+            }),
+            Some("enum/named")
+        );
+        assert_eq!(
+            ExperimentalApiTrait::experimental_reason(&NestedMapShape {
+                inners: HashMap::new(),
+            }),
+            None
+        );
+    }
 }

codex-rs/app-server-protocol/src/protocol/common.rs

@@ -44,15 +44,15 @@ pub enum AuthMode {
 
 macro_rules! experimental_reason_expr {
     // If a request variant is explicitly marked experimental, that reason wins.
-    (#[experimental($reason:expr)] $params:ident $(, $inspect_params:tt)?) => {
+    (variant $variant:ident, #[experimental($reason:expr)] $params:ident $(, $inspect_params:tt)?) => {
         Some($reason)
     };
     // `inspect_params: true` is used when a method is mostly stable but needs
     // field-level gating from its params type (for example, ThreadStart).
-    ($params:ident, true) => {
+    (variant $variant:ident, $params:ident, true) => {
         crate::experimental_api::ExperimentalApi::experimental_reason($params)
     };
-    ($params:ident $(, $inspect_params:tt)?) => {
+    (variant $variant:ident, $params:ident $(, $inspect_params:tt)?) => {
         None
     };
 }
@@ -136,6 +136,7 @@ macro_rules! client_request_definitions {
                     $(
                         Self::$variant { params: _params, .. } => {
                             experimental_reason_expr!(
+                                variant $variant,
                                 $(#[experimental($reason)])?
                                 _params
                                 $(, $inspect_params)?