fix(ci): fix compile errors after ZSerdes refactor

- protobuf_demo: ProtobufSerdes is now a unit struct, remove type param
- rmw-zenoh-rs/msg.rs: disambiguate Self::serialize with fully-qualified syntax
- service.rs: make rmw_send_request generic over S: ZSerdes, add rmw_send_response for RMW path that bypasses serde bounds

Author: YuanYuYuan

crates/rmw-zenoh-rs/src/msg.rs

@@ -95,7 +95,7 @@ impl ZSerdes<RosMessage> for RosSerdes {
     }
 
     fn serialize_with_hint(msg: &RosMessage, _capacity_hint: usize) -> zenoh_buffers::ZBuf {
-        Self::serialize(msg)
+        <RosSerdes as ZSerdes<RosMessage>>::serialize(msg)
     }
 
     fn serialize_to_vec(msg: &RosMessage) -> Vec<u8> {

crates/rmw-zenoh-rs/src/service.rs

@@ -63,7 +63,9 @@ impl ClientImpl {
         };
 
         // Send the request with notification callback
-        let _ = self.inner.rmw_send_request(&req, notify_callback)?;
+        let _ = self
+            .inner
+            .rmw_send_request::<crate::msg::RosSerdes, _>(&req, notify_callback)?;
 
         // Return the sequence number we tracked
         unsafe {
@@ -317,7 +319,10 @@ impl ServiceImpl {
         let resp = crate::msg::RosMessage::new(response, self.response_ts.response);
 
         // Send response
-        match self.inner.send_response(&resp, &key) {
+        match self
+            .inner
+            .rmw_send_response::<crate::msg::RosSerdes>(&resp, &key)
+        {
             Ok(_) => {
                 tracing::debug!("[ServiceImpl::send_response] Response sent successfully");
                 Ok(())

crates/ros-z/examples/protobuf_demo/src/lib.rs

@@ -34,7 +34,7 @@ pub fn run_pubsub_demo(ctx: ZContext, max_count: Option<usize>) -> Result<()> {
     println!("--- Part 1: ROS geometry_msgs/Vector3 with Protobuf ---");
     let ros_pub = node
         .create_pub::<Vector3Proto>("/vector_proto")
-        .with_serdes::<ProtobufSerdes<Vector3Proto>>()
+        .with_serdes::<ProtobufSerdes>()
         .build()?;
 
     println!("Publishing ROS Vector3 messages...\n");
@@ -55,7 +55,7 @@ pub fn run_pubsub_demo(ctx: ZContext, max_count: Option<usize>) -> Result<()> {
     println!("\n--- Part 2: Custom SensorData message (pure protobuf) ---");
     let custom_pub = node
         .create_pub::<SensorData>("/sensor_data")
-        .with_serdes::<ProtobufSerdes<SensorData>>()
+        .with_serdes::<ProtobufSerdes>()
         .build()?;
 
     println!("Publishing custom SensorData messages...\n");
@@ -82,7 +82,7 @@ pub fn run_pubsub_demo(ctx: ZContext, max_count: Option<usize>) -> Result<()> {
     println!("\nKey points:");
     println!("1. ROS messages (Vector3Proto): Auto-generated from ros-z-msgs with MessageTypeInfo");
     println!("2. Custom messages (SensorData): Generated from your own .proto files");
-    println!("3. Both use .with_serdes::<ProtobufSerdes<T>>() for protobuf serialization");
+    println!("3. Both use .with_serdes::<ProtobufSerdes>() for protobuf serialization");
     println!("4. ros-z is transport-agnostic - works with ANY protobuf message!");
 
     Ok(())

crates/ros-z/examples/protobuf_demo/src/types.rs

@@ -1,9 +1,5 @@
 /// Shared protobuf type definitions and trait implementations
-use ros_z::{
-    MessageTypeInfo, ServiceTypeInfo, WithTypeInfo,
-    entity::TypeHash,
-    msg::{ProtobufSerdes, ZService},
-};
+use ros_z::{MessageTypeInfo, ServiceTypeInfo, WithTypeInfo, entity::TypeHash, msg::ZService};
 
 // Include protobuf messages generated from sensor_data.proto
 pub mod generated {

crates/ros-z/src/service.rs

@@ -274,17 +274,17 @@ where
     }
 
     #[cfg(feature = "rmw")]
-    pub fn rmw_send_request<F>(&self, msg: &T::Request, notify: F) -> Result<i64>
+    pub fn rmw_send_request<S, F>(&self, msg: &T::Request, notify: F) -> Result<i64>
     where
+        S: ZSerdes<T::Request>,
         F: Fn() + Send + Sync + 'static,
-        T::Request: serde::Serialize + serde::de::DeserializeOwned + Send + Sync + 'static,
     {
         let tx = self.tx.clone();
         let attachment = self.new_attachment();
         let sn = attachment.sequence_number;
         self.inner
             .get()
-            .payload(<CdrCompatSerdes as ZSerdes<T::Request>>::serialize(msg))
+            .payload(<S as ZSerdes<T::Request>>::serialize(msg))
             .attachment(attachment)
             .callback(move |reply| {
                 match reply.into_result() {
@@ -612,6 +612,32 @@ where
         }
     }
 
+    /// RMW-specific: send response using an explicit serializer type parameter.
+    ///
+    /// Use this instead of [`send_response`](Self::send_response) when the response type does not
+    /// implement `serde::Serialize` (e.g., `RosMessage` in the RMW crate, which is serialized via
+    /// a C FFI path through `RosSerdes`).
+    #[cfg(feature = "rmw")]
+    pub fn rmw_send_response<S>(&mut self, msg: &T::Response, key: &QueryKey) -> Result<()>
+    where
+        S: ZSerdes<T::Response>,
+    {
+        match self.map.remove(key) {
+            Some(query) => {
+                let payload = <S as ZSerdes<T::Response>>::serialize(msg);
+                let attachment = Attachment::new(key.sn, key.gid);
+                query
+                    .reply(&self.key_expr, payload)
+                    .attachment(attachment)
+                    .wait()
+            }
+            None => {
+                error!("[SRV] No query found for sn={}", key.sn);
+                Err("Query map doesn't contain key".into())
+            }
+        }
+    }
+
     /// Awaits sending the response to a service request.
     ///
     /// - `msg` is the response message to send.