[ZeroClaw] 비동기 에이전트 런타임을 위한 Rust 채널 기반 IPC 설계

// Cargo.toml dependencies
// [dependencies]
// tokio = { version = "1", features = ["full"] }
// serde = { version = "1", features = ["derive"] }

use tokio::sync::mpsc;
use serde::{Serialize, Deserialize};

#[derive(Debug, Serialize, Deserialize)]
enum AgentMessage {
    TaskAssigned { task_id: String, description: String },
    TaskCompleted { task_id: String, result: String },
    StatusCheck,
}

struct Agent {
    id: String,
    rx: mpsc::Receiver<AgentMessage>,
}

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

    async fn run(mut self) {
        println!("[{}] Agent started. Listening for messages...", self.id);
        
        // 메시지 수신 대기 (비동기)
        while let Some(msg) = self.rx.recv().await {
            match msg {
                AgentMessage::TaskAssigned { task_id, description } => {
                    println!("[{}] Received task: {} - {}", self.id, task_id, description);
                    // 실제 로직 처리 (예: 파일 분석, 외부 API 호출)
                    // 여기서는 예시를 위해 1초 대기 후 완료 메시지를 전송한다고 가정합니다.
                }
                AgentMessage::StatusCheck => {
                    println!("[{}] Status: Active", self.id);
                }
                _ => {}
            }
        }
        println!("[{}] Agent shutting down.", self.id);
    }
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 1. 채널 생성 (용량 32)
    let (tx, rx) = mpsc::channel::<AgentMessage>(32);

    // 2. 에이전트 생성 및 실행 (비동기 태스크로 분리)
    let agent_handle = {
        let agent = Agent::new("Agent-A".to_string(), rx);
        tokio::spawn(async move {
            agent.run().await;
        })
    };

    // 3. 메인 런타임에서 메시지 송신
    // 다른 에이전트나 API 서버가 이 tx를 사용하여 메시지를 보낼 수 있습니다.
    
    // 작업 할당
    let _ = tx.send(AgentMessage::TaskAssigned {
        task_id: "T-101".to_string(),
        description: "Analyze server logs".to_string(),
    }).await;

    // 상태 확인
    let _ = tx.send(AgentMessage::StatusCheck).await;

    // 4. 에이전트가 작업을 마칠 때까지 대기 (실제 환경에서는 계속 실행됨)
    drop(tx); // 송신자 종료 -> 채널 닫힘 -> 에이전트 루프 종료 조건 성립
    
    agent_handle.await?;
    
    Ok(())
}