Fix Race Conditions in Network Operations

[devfire]

🔄 CONCURRENCY NIGHTMARE

Location: network.rs:232-235

Problem

buffer.truncate(bytes_received);
match AgentMessage::deserialize(&buffer) {
    Ok(message) => { /* ... */ }
    Err(e) => { /* ... */ }
}

Issues

• Shared buffer access without synchronization
• Potential data races on buffer
• Memory safety violations possible

Suggested Fix

// Use thread-local buffers or proper synchronization
#[async_trait]
impl NetworkManager {
    pub async fn receive_message(&self) -> Result<AgentMessage, NetworkError> {
        let mut buffer = vec![0u8; self.config.buffer_size];

        match self.socket.recv_from(&mut buffer).await {
            Ok((bytes_received, sender_addr)) => {
                buffer.truncate(bytes_received);

                match AgentMessage::deserialize(&buffer) {
                    Ok(message) => {
                        tracing::debug!(
                            "Successfully deserialized message from agent {} with content: '{}'",
                            message.sender_id,
                            message.content.chars().take(50).collect::<String>()
                        );
                        Ok(message)
                    }
                    Err(e) => {
                        let error_msg = format!("Failed to deserialize message from {}: {}", sender_addr, e);
                        tracing::warn!("{}", error_msg);
                        Err(NetworkError::DeserializationError(e))
                    }
                }
            }
            Err(e) => {
                let error_msg = format!("Failed to receive message on agent {}: {}", self.agent_id, e);
                tracing::error!("{}", error_msg);
                Err(NetworkError::ReceiveError(error_msg))
            }
        }
    }
}

Priority: High - Race conditions can cause data corruption and memory safety violations, leading to crashes or incorrect behavior.