diff --git a/satrs/src/mode_tree.rs b/satrs/src/mode_tree.rs
index 80d8b2c..e088981 100644
--- a/satrs/src/mode_tree.rs
+++ b/satrs/src/mode_tree.rs
@@ -7,8 +7,9 @@ use crate::{
     mode::{Mode, ModeAndSubmode, ModeReply, ModeRequest, Submode},
     queue::GenericTargetedMessagingError,
     request::{
-        MessageWithSenderId, MpscMessageReceiverWithIds, MpscMessageSenderAndReceiver,
-        MpscMessageSenderMap, MpscMessageSenderWithId, MpscRequestAndReplySenderAndReceiver,
+        MessageReceiver, MessageReceiverWithId, MessageSender, MessageSenderAndReceiver,
+        MessageSenderMap, MessageSenderMapWithId, MessageWithSenderId,
+        RequestAndReplySenderAndReceiver,
     },
     ChannelId,
 };
@@ -71,7 +72,7 @@ pub trait ModeReplyReceiver {
     ) -> Result<Option<MessageWithSenderId<ModeReply>>, GenericTargetedMessagingError>;
 }
 
-impl MpscMessageSenderMap<ModeRequest> {
+impl<S: MessageSender<ModeRequest>> MessageSenderMap<ModeRequest, S> {
     pub fn send_mode_request(
         &self,
         local_id: ChannelId,
@@ -81,16 +82,12 @@ impl MpscMessageSenderMap<ModeRequest> {
         self.send_message(local_id, target_id, request)
     }
 
-    pub fn add_request_target(
-        &mut self,
-        target_id: ChannelId,
-        request_sender: mpsc::Sender<MessageWithSenderId<ModeRequest>>,
-    ) {
+    pub fn add_request_target(&mut self, target_id: ChannelId, request_sender: S) {
         self.add_message_target(target_id, request_sender)
     }
 }
 
-impl MpscMessageSenderMap<ModeReply> {
+impl<S: MessageSender<ModeReply>> MessageSenderMap<ModeReply, S> {
     pub fn send_mode_reply(
         &self,
         local_id: ChannelId,
@@ -100,16 +97,12 @@ impl MpscMessageSenderMap<ModeReply> {
         self.send_message(local_id, target_id, request)
     }
 
-    pub fn add_reply_target(
-        &mut self,
-        target_id: ChannelId,
-        request_sender: mpsc::Sender<MessageWithSenderId<ModeReply>>,
-    ) {
+    pub fn add_reply_target(&mut self, target_id: ChannelId, request_sender: S) {
         self.add_message_target(target_id, request_sender)
     }
 }
 
-impl ModeReplySender for MpscMessageSenderWithId<ModeReply> {
+impl<S: MessageSender<ModeReply>> ModeReplySender for MessageSenderMapWithId<ModeReply, S> {
     fn send_mode_reply(
         &self,
         target_channel_id: ChannelId,
@@ -123,7 +116,7 @@ impl ModeReplySender for MpscMessageSenderWithId<ModeReply> {
     }
 }
 
-impl ModeRequestSender for MpscMessageSenderWithId<ModeRequest> {
+impl<S: MessageSender<ModeRequest>> ModeRequestSender for MessageSenderMapWithId<ModeRequest, S> {
     fn local_channel_id(&self) -> ChannelId {
         self.local_channel_id
     }
@@ -137,14 +130,16 @@ impl ModeRequestSender for MpscMessageSenderWithId<ModeRequest> {
     }
 }
 
-impl ModeReplyReceiver for MpscMessageReceiverWithIds<ModeReply> {
+impl<R: MessageReceiver<ModeReply>> ModeReplyReceiver for MessageReceiverWithId<ModeReply, R> {
     fn try_recv_mode_reply(
         &self,
     ) -> Result<Option<MessageWithSenderId<ModeReply>>, GenericTargetedMessagingError> {
         self.try_recv_message()
     }
 }
-impl ModeRequestReceiver for MpscMessageReceiverWithIds<ModeRequest> {
+impl<R: MessageReceiver<ModeRequest>> ModeRequestReceiver
+    for MessageReceiverWithId<ModeRequest, R>
+{
     fn try_recv_mode_request(
         &self,
     ) -> Result<Option<MessageWithSenderId<ModeRequest>>, GenericTargetedMessagingError> {
@@ -152,7 +147,9 @@ impl ModeRequestReceiver for MpscMessageReceiverWithIds<ModeRequest> {
     }
 }
 
-impl<FROM> ModeRequestSender for MpscMessageSenderAndReceiver<ModeRequest, FROM> {
+impl<FROM, S: MessageSender<ModeRequest>, R: MessageReceiver<FROM>> ModeRequestSender
+    for MessageSenderAndReceiver<ModeRequest, FROM, S, R>
+{
     fn local_channel_id(&self) -> ChannelId {
         self.local_channel_id_generic()
     }
@@ -167,7 +164,9 @@ impl<FROM> ModeRequestSender for MpscMessageSenderAndReceiver<ModeRequest, FROM>
     }
 }
 
-impl<FROM> ModeReplySender for MpscMessageSenderAndReceiver<ModeReply, FROM> {
+impl<FROM, S: MessageSender<ModeReply>, R: MessageReceiver<FROM>> ModeReplySender
+    for MessageSenderAndReceiver<ModeReply, FROM, S, R>
+{
     fn local_channel_id(&self) -> ChannelId {
         self.local_channel_id_generic()
     }
@@ -182,7 +181,9 @@ impl<FROM> ModeReplySender for MpscMessageSenderAndReceiver<ModeReply, FROM> {
     }
 }
 
-impl<TO> ModeReplyReceiver for MpscMessageSenderAndReceiver<TO, ModeReply> {
+impl<TO, S: MessageSender<TO>, R: MessageReceiver<ModeReply>> ModeReplyReceiver
+    for MessageSenderAndReceiver<TO, ModeReply, S, R>
+{
     fn try_recv_mode_reply(
         &self,
     ) -> Result<Option<MessageWithSenderId<ModeReply>>, GenericTargetedMessagingError> {
@@ -190,7 +191,9 @@ impl<TO> ModeReplyReceiver for MpscMessageSenderAndReceiver<TO, ModeReply> {
             .try_recv_message(self.local_channel_id_generic())
     }
 }
-impl<TO> ModeRequestReceiver for MpscMessageSenderAndReceiver<TO, ModeRequest> {
+impl<TO, S: MessageSender<TO>, R: MessageReceiver<ModeRequest>> ModeRequestReceiver
+    for MessageSenderAndReceiver<TO, ModeRequest, S, R>
+{
     fn try_recv_mode_request(
         &self,
     ) -> Result<Option<MessageWithSenderId<ModeRequest>>, GenericTargetedMessagingError> {
@@ -199,33 +202,63 @@ impl<TO> ModeRequestReceiver for MpscMessageSenderAndReceiver<TO, ModeRequest> {
     }
 }
 
-pub type MpscModeRequestHandlerConnector = MpscMessageSenderAndReceiver<ModeReply, ModeRequest>;
-pub type MpscModeRequestorConnector = MpscMessageSenderAndReceiver<ModeRequest, ModeReply>;
-pub type MpscModeConnector = MpscRequestAndReplySenderAndReceiver<ModeRequest, ModeReply>;
+pub type ModeRequestHandlerConnector<S, R> = MessageSenderAndReceiver<ModeReply, ModeRequest, S, R>;
+pub type MpscModeRequestHandlerConnector = ModeRequestHandlerConnector<
+    mpsc::Sender<MessageWithSenderId<ModeReply>>,
+    mpsc::Receiver<MessageWithSenderId<ModeRequest>>,
+>;
 
-impl<REPLY> MpscRequestAndReplySenderAndReceiver<ModeRequest, REPLY> {
-    pub fn add_request_target(
-        &mut self,
-        target_id: ChannelId,
-        request_sender: mpsc::Sender<MessageWithSenderId<ModeRequest>>,
-    ) {
+pub type ModeRequestorConnector<S, R> = MessageSenderAndReceiver<ModeRequest, ModeReply, S, R>;
+pub type MpscModeRequestorConnector = ModeRequestorConnector<
+    mpsc::Sender<MessageWithSenderId<ModeRequest>>,
+    mpsc::Receiver<MessageWithSenderId<ModeReply>>,
+>;
+
+pub type ModeConnector<S0, R0, S1, R1> =
+    RequestAndReplySenderAndReceiver<ModeRequest, ModeReply, S0, R0, S1, R1>;
+pub type MpscModeConnector = ModeConnector<
+    mpsc::Sender<MessageWithSenderId<ModeRequest>>,
+    mpsc::Receiver<MessageWithSenderId<ModeReply>>,
+    mpsc::Sender<MessageWithSenderId<ModeReply>>,
+    mpsc::Receiver<MessageWithSenderId<ModeRequest>>,
+>;
+
+impl<
+        REPLY,
+        S0: MessageSender<ModeRequest>,
+        R0: MessageReceiver<REPLY>,
+        S1: MessageSender<REPLY>,
+        R1: MessageReceiver<ModeRequest>,
+    > RequestAndReplySenderAndReceiver<ModeRequest, REPLY, S0, R0, S1, R1>
+{
+    pub fn add_request_target(&mut self, target_id: ChannelId, request_sender: S0) {
         self.request_sender_map
             .add_message_target(target_id, request_sender)
     }
 }
 
-impl<REQUEST> MpscRequestAndReplySenderAndReceiver<REQUEST, ModeReply> {
-    pub fn add_reply_target(
-        &mut self,
-        target_id: ChannelId,
-        reply_sender: mpsc::Sender<MessageWithSenderId<ModeReply>>,
-    ) {
+impl<
+        REQUEST,
+        S0: MessageSender<REQUEST>,
+        R0: MessageReceiver<ModeReply>,
+        S1: MessageSender<ModeReply>,
+        R1: MessageReceiver<REQUEST>,
+    > RequestAndReplySenderAndReceiver<REQUEST, ModeReply, S0, R0, S1, R1>
+{
+    pub fn add_reply_target(&mut self, target_id: ChannelId, reply_sender: S1) {
         self.reply_sender_map
             .add_message_target(target_id, reply_sender)
     }
 }
 
-impl<REPLY> ModeRequestSender for MpscRequestAndReplySenderAndReceiver<ModeRequest, REPLY> {
+impl<
+        REPLY,
+        S0: MessageSender<ModeRequest>,
+        R0: MessageReceiver<REPLY>,
+        S1: MessageSender<REPLY>,
+        R1: MessageReceiver<ModeRequest>,
+    > ModeRequestSender for RequestAndReplySenderAndReceiver<ModeRequest, REPLY, S0, R0, S1, R1>
+{
     fn local_channel_id(&self) -> ChannelId {
         self.local_channel_id_generic()
     }
@@ -240,7 +273,14 @@ impl<REPLY> ModeRequestSender for MpscRequestAndReplySenderAndReceiver<ModeReque
     }
 }
 
-impl<REQUEST> ModeReplySender for MpscRequestAndReplySenderAndReceiver<REQUEST, ModeReply> {
+impl<
+        REQUEST,
+        S0: MessageSender<REQUEST>,
+        R0: MessageReceiver<ModeReply>,
+        S1: MessageSender<ModeReply>,
+        R1: MessageReceiver<REQUEST>,
+    > ModeReplySender for RequestAndReplySenderAndReceiver<REQUEST, ModeReply, S0, R0, S1, R1>
+{
     fn local_channel_id(&self) -> ChannelId {
         self.local_channel_id_generic()
     }
@@ -255,7 +295,14 @@ impl<REQUEST> ModeReplySender for MpscRequestAndReplySenderAndReceiver<REQUEST,
     }
 }
 
-impl<REQUEST> ModeReplyReceiver for MpscRequestAndReplySenderAndReceiver<REQUEST, ModeReply> {
+impl<
+        REQUEST,
+        S0: MessageSender<REQUEST>,
+        R0: MessageReceiver<ModeReply>,
+        S1: MessageSender<ModeReply>,
+        R1: MessageReceiver<REQUEST>,
+    > ModeReplyReceiver for RequestAndReplySenderAndReceiver<REQUEST, ModeReply, S0, R0, S1, R1>
+{
     fn try_recv_mode_reply(
         &self,
     ) -> Result<Option<MessageWithSenderId<ModeReply>>, GenericTargetedMessagingError> {
@@ -264,7 +311,14 @@ impl<REQUEST> ModeReplyReceiver for MpscRequestAndReplySenderAndReceiver<REQUEST
     }
 }
 
-impl<REPLY> ModeRequestReceiver for MpscRequestAndReplySenderAndReceiver<ModeRequest, REPLY> {
+impl<
+        REPLY,
+        S0: MessageSender<ModeRequest>,
+        R0: MessageReceiver<REPLY>,
+        S1: MessageSender<REPLY>,
+        R1: MessageReceiver<ModeRequest>,
+    > ModeRequestReceiver for RequestAndReplySenderAndReceiver<ModeRequest, REPLY, S0, R0, S1, R1>
+{
     fn try_recv_mode_request(
         &self,
     ) -> Result<Option<MessageWithSenderId<ModeRequest>>, GenericTargetedMessagingError> {
diff --git a/satrs/src/request.rs b/satrs/src/request.rs
index 4ef482c..2cb174c 100644
--- a/satrs/src/request.rs
+++ b/satrs/src/request.rs
@@ -11,7 +11,7 @@ use spacepackets::{
     ByteConversionError, CcsdsPacket,
 };
 
-use crate::{ChannelId, TargetId};
+use crate::{queue::GenericTargetedMessagingError, ChannelId, TargetId};
 
 pub type Apid = u16;
 
@@ -113,20 +113,31 @@ impl fmt::Display for TargetAndApidId {
     }
 }
 
-pub struct MessageWithSenderId<MESSAGE> {
+pub struct MessageWithSenderId<MSG> {
     pub sender_id: ChannelId,
-    pub message: MESSAGE,
+    pub message: MSG,
 }
 
-impl<MESSAGE> MessageWithSenderId<MESSAGE> {
-    pub fn new(sender_id: ChannelId, message: MESSAGE) -> Self {
+impl<MSG> MessageWithSenderId<MSG> {
+    pub fn new(sender_id: ChannelId, message: MSG) -> Self {
         Self { sender_id, message }
     }
 }
 
+/// Generic trait for objects which can send targeted messages.
+pub trait MessageSender<MSG>: Send {
+    fn send(&self, message: MessageWithSenderId<MSG>) -> Result<(), GenericTargetedMessagingError>;
+}
+
+// Generic trait for objects which can receive targeted messages.
+pub trait MessageReceiver<MSG> {
+    fn try_recv(&self) -> Result<Option<MessageWithSenderId<MSG>>, GenericTargetedMessagingError>;
+}
+
 #[cfg(feature = "std")]
 #[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
 mod std_mod {
+    use core::marker::PhantomData;
     use std::sync::mpsc;
 
     use hashbrown::HashMap;
@@ -136,24 +147,59 @@ mod std_mod {
         ChannelId,
     };
 
-    use super::MessageWithSenderId;
+    use super::{MessageReceiver, MessageSender, MessageWithSenderId};
 
-    pub struct MpscMessageSenderMap<MESSAGE>(
-        pub HashMap<ChannelId, mpsc::Sender<MessageWithSenderId<MESSAGE>>>,
-    );
-
-    impl<MESSAGE> Default for MpscMessageSenderMap<MESSAGE> {
-        fn default() -> Self {
-            Self(Default::default())
+    impl<MSG: Send> MessageSender<MSG> for mpsc::Sender<MessageWithSenderId<MSG>> {
+        fn send(
+            &self,
+            message: MessageWithSenderId<MSG>,
+        ) -> Result<(), GenericTargetedMessagingError> {
+            self.send(message)
+                .map_err(|_| GenericSendError::RxDisconnected)?;
+            Ok(())
+        }
+    }
+    impl<MSG: Send> MessageSender<MSG> for mpsc::SyncSender<MessageWithSenderId<MSG>> {
+        fn send(
+            &self,
+            message: MessageWithSenderId<MSG>,
+        ) -> Result<(), GenericTargetedMessagingError> {
+            if let Err(e) = self.try_send(message) {
+                match e {
+                    mpsc::TrySendError::Full(_) => {
+                        return Err(GenericSendError::QueueFull(None).into());
+                    }
+                    mpsc::TrySendError::Disconnected(_) => todo!(),
+                }
+            }
+            Ok(())
         }
     }
 
-    impl<MESSAGE> MpscMessageSenderMap<MESSAGE> {
+    pub struct MessageSenderMap<MSG, S: MessageSender<MSG>>(
+        pub HashMap<ChannelId, S>,
+        PhantomData<MSG>,
+    );
+
+    pub type MpscSenderMap<MSG> = MessageReceiverWithId<MSG, mpsc::Sender<MSG>>;
+    pub type MpscBoundedSenderMap<MSG> = MessageReceiverWithId<MSG, mpsc::SyncSender<MSG>>;
+
+    impl<MSG, S: MessageSender<MSG>> Default for MessageSenderMap<MSG, S> {
+        fn default() -> Self {
+            Self(Default::default(), PhantomData)
+        }
+    }
+
+    impl<MSG, S: MessageSender<MSG>> MessageSenderMap<MSG, S> {
+        pub fn add_message_target(&mut self, target_id: ChannelId, message_sender: S) {
+            self.0.insert(target_id, message_sender);
+        }
+
         pub fn send_message(
             &self,
             local_channel_id: ChannelId,
             target_channel_id: ChannelId,
-            message: MESSAGE,
+            message: MSG,
         ) -> Result<(), GenericTargetedMessagingError> {
             if self.0.contains_key(&target_channel_id) {
                 self.0
@@ -167,22 +213,14 @@ mod std_mod {
                 target_channel_id,
             ))
         }
-
-        pub fn add_message_target(
-            &mut self,
-            target_id: ChannelId,
-            message_sender: mpsc::Sender<MessageWithSenderId<MESSAGE>>,
-        ) {
-            self.0.insert(target_id, message_sender);
-        }
     }
 
-    pub struct MpscMessageSenderWithId<MESSAGE> {
+    pub struct MessageSenderMapWithId<MSG, S: MessageSender<MSG>> {
         pub local_channel_id: ChannelId,
-        pub message_sender_map: MpscMessageSenderMap<MESSAGE>,
+        pub message_sender_map: MessageSenderMap<MSG, S>,
     }
 
-    impl<MESSAGE> MpscMessageSenderWithId<MESSAGE> {
+    impl<MSG, S: MessageSender<MSG>> MessageSenderMapWithId<MSG, S> {
         pub fn new(local_channel_id: ChannelId) -> Self {
             Self {
                 local_channel_id,
@@ -193,62 +231,62 @@ mod std_mod {
         pub fn send_message(
             &self,
             target_channel_id: ChannelId,
-            message: MESSAGE,
+            message: MSG,
         ) -> Result<(), GenericTargetedMessagingError> {
             self.message_sender_map
                 .send_message(self.local_channel_id, target_channel_id, message)
         }
 
-        pub fn add_message_target(
-            &mut self,
-            target_id: ChannelId,
-            message_sender: mpsc::Sender<MessageWithSenderId<MESSAGE>>,
-        ) {
+        pub fn add_message_target(&mut self, target_id: ChannelId, message_sender: S) {
             self.message_sender_map
                 .add_message_target(target_id, message_sender)
         }
     }
 
-    pub struct MpscMessageWithSenderReceiver<MESSAGE>(
-        pub mpsc::Receiver<MessageWithSenderId<MESSAGE>>,
-    );
-
-    impl<MESSAGE> From<mpsc::Receiver<MessageWithSenderId<MESSAGE>>>
-        for MpscMessageWithSenderReceiver<MESSAGE>
-    {
-        fn from(value: mpsc::Receiver<MessageWithSenderId<MESSAGE>>) -> Self {
-            Self(value)
+    impl<MSG> MessageReceiver<MSG> for mpsc::Receiver<MessageWithSenderId<MSG>> {
+        fn try_recv(
+            &self,
+        ) -> Result<Option<MessageWithSenderId<MSG>>, GenericTargetedMessagingError> {
+            match self.try_recv() {
+                Ok(msg) => Ok(Some(msg)),
+                Err(e) => match e {
+                    mpsc::TryRecvError::Empty => Ok(None),
+                    mpsc::TryRecvError::Disconnected => {
+                        Err(GenericReceiveError::TxDisconnected(None).into())
+                    }
+                },
+            }
         }
     }
 
-    impl<MESSAGE> MpscMessageWithSenderReceiver<MESSAGE> {
+    pub struct MessageWithSenderIdReceiver<MSG, R: MessageReceiver<MSG>>(pub R, PhantomData<MSG>);
+
+    impl<MSG, R: MessageReceiver<MSG>> From<R> for MessageWithSenderIdReceiver<MSG, R> {
+        fn from(receiver: R) -> Self {
+            MessageWithSenderIdReceiver(receiver, PhantomData)
+        }
+    }
+
+    impl<MSG, R: MessageReceiver<MSG>> MessageWithSenderIdReceiver<MSG, R> {
         pub fn try_recv_message(
             &self,
-            local_id: ChannelId,
-        ) -> Result<Option<MessageWithSenderId<MESSAGE>>, GenericTargetedMessagingError> {
-            match self.0.try_recv() {
-                Ok(reply) => {
-                    return Ok(Some(reply));
-                }
-                Err(e) => {
-                    if e == mpsc::TryRecvError::Disconnected {
-                        return Err(GenericReceiveError::TxDisconnected(Some(local_id)).into());
-                    }
-                }
-            }
-            Ok(None)
+            _local_id: ChannelId,
+        ) -> Result<Option<MessageWithSenderId<MSG>>, GenericTargetedMessagingError> {
+            self.0.try_recv()
         }
     }
 
-    pub struct MpscMessageReceiverWithIds<MESSAGE> {
+    pub struct MessageReceiverWithId<MSG, R: MessageReceiver<MSG>> {
         local_channel_id: ChannelId,
-        reply_receiver: MpscMessageWithSenderReceiver<MESSAGE>,
+        reply_receiver: MessageWithSenderIdReceiver<MSG, R>,
     }
 
-    impl<MESSAGE> MpscMessageReceiverWithIds<MESSAGE> {
+    pub type MpscMessageReceiverWithId<MSG> = MessageReceiverWithId<MSG, mpsc::Receiver<MSG>>;
+
+    impl<MSG, R: MessageReceiver<MSG>> MessageReceiverWithId<MSG, R> {
         pub fn new(
             local_channel_id: ChannelId,
-            reply_receiver: MpscMessageWithSenderReceiver<MESSAGE>,
+            reply_receiver: MessageWithSenderIdReceiver<MSG, R>,
         ) -> Self {
             Self {
                 local_channel_id,
@@ -259,50 +297,34 @@ mod std_mod {
         pub fn local_channel_id(&self) -> ChannelId {
             self.local_channel_id
         }
+    }
 
+    impl<MSG, R: MessageReceiver<MSG>> MessageReceiverWithId<MSG, R> {
         pub fn try_recv_message(
             &self,
-        ) -> Result<Option<MessageWithSenderId<MESSAGE>>, GenericTargetedMessagingError> {
-            match self.reply_receiver.0.try_recv() {
-                Ok(reply) => {
-                    return Ok(Some(reply));
-                }
-                Err(e) => {
-                    if e == mpsc::TryRecvError::Disconnected {
-                        return Err(GenericReceiveError::TxDisconnected(Some(
-                            self.local_channel_id(),
-                        ))
-                        .into());
-                    }
-                }
-            }
-            Ok(None)
+        ) -> Result<Option<MessageWithSenderId<MSG>>, GenericTargetedMessagingError> {
+            self.reply_receiver.0.try_recv()
         }
     }
 
-    pub struct MpscMessageSenderAndReceiver<TO, FROM> {
+    pub struct MessageSenderAndReceiver<TO, FROM, S: MessageSender<TO>, R: MessageReceiver<FROM>> {
         pub local_channel_id: ChannelId,
-        pub message_sender_map: MpscMessageSenderMap<TO>,
-        pub message_receiver: MpscMessageWithSenderReceiver<FROM>,
+        pub message_sender_map: MessageSenderMap<TO, S>,
+        pub message_receiver: MessageWithSenderIdReceiver<FROM, R>,
     }
 
-    impl<TO, FROM> MpscMessageSenderAndReceiver<TO, FROM> {
-        pub fn new(
-            local_channel_id: ChannelId,
-            message_receiver: mpsc::Receiver<MessageWithSenderId<FROM>>,
-        ) -> Self {
+    impl<TO, FROM, S: MessageSender<TO>, R: MessageReceiver<FROM>>
+        MessageSenderAndReceiver<TO, FROM, S, R>
+    {
+        pub fn new(local_channel_id: ChannelId, message_receiver: R) -> Self {
             Self {
                 local_channel_id,
                 message_sender_map: Default::default(),
-                message_receiver: MpscMessageWithSenderReceiver::from(message_receiver),
+                message_receiver: MessageWithSenderIdReceiver::from(message_receiver),
             }
         }
 
-        pub fn add_message_target(
-            &mut self,
-            target_id: ChannelId,
-            message_sender: mpsc::Sender<MessageWithSenderId<TO>>,
-        ) {
+        pub fn add_message_target(&mut self, target_id: ChannelId, message_sender: S) {
             self.message_sender_map
                 .add_message_target(target_id, message_sender)
         }
@@ -312,22 +334,33 @@ mod std_mod {
         }
     }
 
-    pub struct MpscRequestAndReplySenderAndReceiver<REQUEST, REPLY> {
+    pub struct RequestAndReplySenderAndReceiver<
+        REQUEST,
+        REPLY,
+        S0: MessageSender<REQUEST>,
+        R0: MessageReceiver<REPLY>,
+        S1: MessageSender<REPLY>,
+        R1: MessageReceiver<REQUEST>,
+    > {
         pub local_channel_id: ChannelId,
         // These 2 are a functional group.
-        pub request_sender_map: MpscMessageSenderMap<REQUEST>,
-        pub reply_receiver: MpscMessageWithSenderReceiver<REPLY>,
+        pub request_sender_map: MessageSenderMap<REQUEST, S0>,
+        pub reply_receiver: MessageWithSenderIdReceiver<REPLY, R0>,
         // These 2 are a functional group.
-        pub request_receiver: MpscMessageWithSenderReceiver<REQUEST>,
-        pub reply_sender_map: MpscMessageSenderMap<REPLY>,
+        pub request_receiver: MessageWithSenderIdReceiver<REQUEST, R1>,
+        pub reply_sender_map: MessageSenderMap<REPLY, S1>,
     }
 
-    impl<REQUEST, REPLY> MpscRequestAndReplySenderAndReceiver<REQUEST, REPLY> {
-        pub fn new(
-            local_channel_id: ChannelId,
-            request_receiver: mpsc::Receiver<MessageWithSenderId<REQUEST>>,
-            reply_receiver: mpsc::Receiver<MessageWithSenderId<REPLY>>,
-        ) -> Self {
+    impl<
+            REQUEST,
+            REPLY,
+            S0: MessageSender<REQUEST>,
+            R0: MessageReceiver<REPLY>,
+            S1: MessageSender<REPLY>,
+            R1: MessageReceiver<REQUEST>,
+        > RequestAndReplySenderAndReceiver<REQUEST, REPLY, S0, R0, S1, R1>
+    {
+        pub fn new(local_channel_id: ChannelId, request_receiver: R1, reply_receiver: R0) -> Self {
             Self {
                 local_channel_id,
                 request_receiver: request_receiver.into(),