ZeroClaw 아키텍처 심화: Rust 기반 안전한 에이전트 간 통신 구현하기

// message.rs
use serde::{Deserialize, Serialize};
use validator::Validate;

/// 에이전트 간 통신 메시지 타입
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum AgentMessage {
    TaskRequest { id: String, payload: TaskPayload },
    TaskResponse { id: String, result: String },
    Heartbeat,
}

/// 작업 페이로드 (검증 로직 포함)
#[derive(Debug, Clone, Serialize, Deserialize, Validate)]
pub struct TaskPayload {
    #[validate(length(min = 1, max = 100))]
    pub command: String,
    
    // JSON 형식의 인자를 받지만, 구조적으로 안전하게 파싱해야 함
    pub args: serde_json::Value, 
}

impl AgentMessage {
    /// 바이트 배열로부터 안전하게 메시지를 역직렬화합니다.
    pub fn from_bytes(bytes: &[u8]) -> Result<Self, Box<dyn std::error::Error>> {
        // 1. 기본 직렬화 검증
        let msg: AgentMessage = bincode::deserialize(bytes)?;
        
        // 2. 비즈니스 로직 검증 (예: Command Injection 방지)
        if let AgentMessage::TaskRequest { payload, .. } = &msg {
            payload.validate()?; // validator 크레이트 사용
            
            // 보안: 허용되지 않는 쉘 명령어 필터링 예시
            if payload.command.contains("rm ") || payload.command.contains("sudo") {
                return Err("Blocked potentially dangerous command".into());
            }
        }
        
        Ok(msg)
    }
}

// agent.rs
use tokio::sync::mpsc;
use super::message::AgentMessage;

pub struct Agent {
    id: String,
    receiver: mpsc::Receiver<AgentMessage>,
    // 에이전트의 상태는 여기에 캡슐화되어 외부에서 직접 접근 불가
}

impl Agent {
    pub fn new(id: String, receiver: mpsc::Receiver<AgentMessage>) -> Self {
        Self { id, receiver }
    }

    /// 에이전트의 메인 루프
    pub async fn run(mut self) {
        println!("[{}] Agent started", self.id);
        
        while let Some(msg) = self.receiver.recv().await {
            if let Err(e) = self.handle_message(msg).await {
                eprintln!("[{}] Error handling message: {:?}", self.id, e);
            }
        }
    }

    async fn handle_message(&self, msg: AgentMessage) -> Result<(), Box<dyn std::error::Error>> {
        match msg {
            AgentMessage::TaskRequest { id, payload } => {
                println!("[{}] Executing task {}: {}", self.id, id, payload.command);
                // 여기에 실제 작업 실행 로직 (예: LLM 호출, 파일 쓰기 등)
                // 안전 장치: 샌드박스 환경에서 실행하거나 권한을 제한합니다.
            },
            AgentMessage::Heartbeat => {
                // 생존 신호 처리
            },
            _ => return Err("Unknown message type".into()),
        }
        Ok(())
    }
}

// runtime.rs
use tokio::sync::mpsc;
use std::collections::HashMap;
use super::agent::Agent;
use super::message::AgentMessage;

pub struct Runtime {
    agents: HashMap<String, mpsc::Sender<AgentMessage>>,
}

impl Runtime {
    pub fn new() -> Self {
        Self { agents: HashMap::new() }
    }

    pub fn spawn_agent(&mut self, id: &str) {
        let (tx, rx) = mpsc::channel(32);
        let agent = Agent::new(id.to_string(), rx);
        
        // 에이전트를 별도의 태스크로 실행
        tokio::spawn(agent.run());
        
        self.agents.insert(id.to_string(), tx);
        println!("Runtime: Agent '{}' spawned", id);
    }

    pub async fn broadcast(&self, msg: AgentMessage) {
        for (id, tx) in self.agents.iter() {
            if let Err(e) = tx.send(msg.clone()).await {
                eprintln!("Failed to send to {}: {:?}", id, e);
            }
        }
    }
}