symbi_runtime/types/
communication.rs

1//! Communication system types and data structures
2
3use bytes::Bytes;
4use serde::{Deserialize, Serialize};
5use std::time::{Duration, SystemTime};
6
7use super::{AgentId, MessageId, RequestId};
8
9/// Secure message structure for inter-agent communication
10#[derive(Debug, Clone, Serialize, Deserialize)]
11pub struct SecureMessage {
12    pub id: MessageId,
13    pub sender: AgentId,
14    pub recipient: Option<AgentId>, // None for broadcast
15    pub topic: Option<String>,      // For pub/sub
16    pub payload: EncryptedPayload,
17    pub signature: MessageSignature,
18    pub timestamp: SystemTime,
19    pub ttl: Duration,
20    pub message_type: MessageType,
21}
22
23/// Types of messages in the communication system
24#[derive(Debug, Clone, Serialize, Deserialize)]
25pub enum MessageType {
26    Direct(AgentId),
27    Publish(String),
28    Subscribe(String),
29    Broadcast,
30    Request(RequestId),
31    Response(RequestId),
32}
33
34/// Encrypted message payload
35#[derive(Debug, Clone, Serialize, Deserialize)]
36pub struct EncryptedPayload {
37    pub data: Bytes,
38    pub encryption_algorithm: EncryptionAlgorithm,
39    pub nonce: Vec<u8>,
40}
41
42/// Supported encryption algorithms
43#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Default)]
44pub enum EncryptionAlgorithm {
45    #[default]
46    Aes256Gcm,
47    ChaCha20Poly1305,
48    None, // For testing or non-sensitive data
49}
50
51/// Message signature for integrity verification
52#[derive(Debug, Clone, Serialize, Deserialize)]
53pub struct MessageSignature {
54    pub signature: Vec<u8>,
55    pub algorithm: SignatureAlgorithm,
56    pub public_key: Vec<u8>,
57}
58
59/// Supported signature algorithms
60#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Default)]
61pub enum SignatureAlgorithm {
62    #[default]
63    Ed25519,
64    EcdsaP256,
65    None, // For testing or non-critical messages
66}
67
68/// Communication channel handle
69#[derive(Debug, Clone)]
70pub struct ChannelHandle {
71    pub id: String,
72    pub agent_id: AgentId,
73    pub channel_type: ChannelType,
74    pub created_at: SystemTime,
75}
76
77/// Types of communication channels
78#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
79pub enum ChannelType {
80    Direct,
81    Broadcast,
82    Topic(String),
83}
84
85/// Message routing table entry
86#[derive(Debug, Clone)]
87pub struct RouteEntry {
88    pub destination: AgentId,
89    pub channel: ChannelHandle,
90    pub last_used: SystemTime,
91    pub message_count: u64,
92}
93
94/// Dead letter queue for undeliverable messages
95#[derive(Debug, Clone)]
96pub struct DeadLetterQueue {
97    pub messages: Vec<DeadLetterMessage>,
98    pub max_size: usize,
99}
100
101impl DeadLetterQueue {
102    pub fn new(max_size: usize) -> Self {
103        Self {
104            messages: Vec::new(),
105            max_size,
106        }
107    }
108
109    pub fn add_message(&mut self, message: SecureMessage, reason: DeadLetterReason) {
110        if self.messages.len() >= self.max_size {
111            self.messages.remove(0); // Remove oldest message
112        }
113
114        self.messages.push(DeadLetterMessage {
115            original_message: message,
116            reason,
117            timestamp: SystemTime::now(),
118        });
119    }
120}
121
122/// Message that couldn't be delivered
123#[derive(Debug, Clone)]
124pub struct DeadLetterMessage {
125    pub original_message: SecureMessage,
126    pub reason: DeadLetterReason,
127    pub timestamp: SystemTime,
128}
129
130/// Reasons why a message ended up in the dead letter queue
131#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
132pub enum DeadLetterReason {
133    RecipientNotFound,
134    RecipientUnavailable,
135    MessageExpired,
136    PolicyViolation(String),
137    EncryptionFailure,
138    SignatureVerificationFailure,
139    MessageTooLarge,
140    RateLimitExceeded,
141    QueueFull,
142    AgentNotFound,
143    Expired,
144}
145
146/// Message delivery guarantees
147#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Default)]
148pub enum DeliveryGuarantee {
149    /// Best effort delivery, no guarantees
150    AtMostOnce,
151    /// Guaranteed delivery with possible duplicates
152    #[default]
153    AtLeastOnce,
154    /// Guaranteed single delivery (for critical messages)
155    ExactlyOnce,
156}
157
158/// Rate limiting configuration
159#[derive(Debug, Clone, Serialize, Deserialize)]
160pub struct RateLimitConfig {
161    pub messages_per_second: u32,
162    pub burst_size: u32,
163    pub window_duration: Duration,
164}
165
166impl Default for RateLimitConfig {
167    fn default() -> Self {
168        Self {
169            messages_per_second: 100,
170            burst_size: 200,
171            window_duration: Duration::from_secs(60),
172        }
173    }
174}
175
176/// Message security configuration
177#[derive(Debug, Clone, Serialize, Deserialize)]
178pub struct MessageSecurity {
179    pub encryption_enabled: bool,
180    pub signature_required: bool,
181    pub key_rotation_interval: Duration,
182    pub max_message_size: usize,
183    pub rate_limiting: RateLimitConfig,
184}
185
186impl Default for MessageSecurity {
187    fn default() -> Self {
188        Self {
189            encryption_enabled: true,
190            signature_required: true,
191            key_rotation_interval: Duration::from_secs(86400), // 24 hours
192            max_message_size: 1024 * 1024,                     // 1MB
193            rate_limiting: RateLimitConfig::default(),
194        }
195    }
196}
197
198/// Communication subsystem configuration
199#[derive(Debug, Clone, Serialize, Deserialize)]
200pub struct CommunicationConfig {
201    pub max_concurrent_connections: usize,
202    pub message_buffer_size: usize,
203    pub connection_timeout: Duration,
204    pub message_timeout: Duration,
205    pub security: MessageSecurity,
206    pub dead_letter_queue_size: usize,
207}
208
209impl Default for CommunicationConfig {
210    fn default() -> Self {
211        Self {
212            max_concurrent_connections: 10000,
213            message_buffer_size: 1000,
214            connection_timeout: Duration::from_secs(30),
215            message_timeout: Duration::from_secs(60),
216            security: MessageSecurity::default(),
217            dead_letter_queue_size: 1000,
218        }
219    }
220}
221
222/// Communication channels for an execution context
223#[derive(Debug, Clone, Default)]
224pub struct CommunicationChannels {
225    pub direct_channel: Option<ChannelHandle>,
226    pub broadcast_channel: Option<ChannelHandle>,
227    pub subscribed_topics: Vec<String>,
228}
symbi_runtime/types/communication.rs

symbi_runtime/types/
communication.rs
