Struct Message 

pub struct Message {
    pub id: String,
    pub topic: String,
    pub payload: Vec<u8>,
    pub sender: String,
    pub metadata: HashMap<String, String>,
    pub created_at: i64,
}

A message for inter-agent communication.

Messages carry binary payloads between agents in a mesh.

Example

use ceylon_runtime::Message;

// Create a message
let msg = Message::new("greeting", b"Hello!".to_vec(), "sender-agent");

// Access message properties
println!("Topic: {}", msg.topic);
println!("From: {}", msg.sender);

Fields

id: String

Unique message identifier (auto-generated UUID).

topic: String

Message topic/type for routing or categorization.

payload: Vec<u8>

Binary payload data.

sender: String

Name of the sending agent.

metadata: HashMap<String, String>

Arbitrary metadata key-value pairs.

created_at: i64

Creation timestamp in microseconds since epoch.

Implementations

impl Message

pub fn new( topic: impl Into<String>, payload: Vec<u8>, sender: impl Into<String>, ) -> Self

Create a new message.

Arguments

• topic - Message topic for routing
• payload - Binary payload
• sender - Name of the sending agent

Examples found in repository

examples/mesh_architecture.rs (line 38)

    async fn on_message(&mut self, msg: Message, _ctx: &mut AgentContext) -> Result<()> {
        let content = String::from_utf8_lossy(&msg.payload);
        println!("[Worker] Received task from {}: {}", msg.sender, content);

        // Simulate processing
        tokio::time::sleep(Duration::from_millis(500)).await;

        // Send response
        let response = format!("Processed: {}", content);
        println!("[Worker] Sending response: {}", response);

        let reply_msg = Message::new("result", response.into_bytes(), self.name());
        self.mesh.send(reply_msg, &msg.sender).await?;

        Ok(())
    }
}

// --- Manager Agent ---
struct ManagerAgent {
    mesh: Arc<LocalMesh>,
    completion_notify: Arc<Notify>,
}

#[async_trait]
impl Agent for ManagerAgent {
    fn name(&self) -> String {
        "manager".to_string()
    }

    async fn on_start(&mut self, _ctx: &mut AgentContext) -> Result<()> {
        println!("[Manager] Started. Sending task to worker...");

        // Send a task to the worker
        let task_msg = Message::new("task", b"Analyze data".to_vec(), self.name());
        self.mesh.send(task_msg, "worker").await?;

        Ok(())
    }

examples/llm_multi_agent_mesh.rs (line 91)

    async fn on_message(&mut self, msg: Message, ctx: &mut AgentContext) -> Result<()> {
        let topic = String::from_utf8_lossy(&msg.payload);
        println!("\n[Researcher] Received research request: {}", topic);

        // Use LLM to research the topic
        let research_prompt = format!(
            "Research the following topic and provide key information: {}",
            topic
        );

        match self
            .llm_agent
            .send_message_and_get_response(&research_prompt, ctx)
            .await
        {
            Ok(research_result) => {
                println!("[Researcher] Research complete. Sending to summarizer...");

                // Send research results to the summarizer
                let research_msg =
                    Message::new("research_result", research_result.into_bytes(), self.name());
                self.mesh.send(research_msg, "summarizer").await?;
            }
            Err(e) => {
                eprintln!("[Researcher] Error during research: {}", e);
                // Send error message to summarizer
                let error_msg = Message::new(
                    "error",
                    format!("Research failed: {}", e).into_bytes(),
                    self.name(),
                );
                self.mesh.send(error_msg, "summarizer").await?;
            }
        }

        Ok(())
    }
}

// --- Summarizer Agent Wrapper ---
// Wraps an LlmAgent to summarize research findings
struct SummarizerAgent {
    llm_agent: LlmAgent,
    completion_notify: Arc<Notify>,
}

impl SummarizerAgent {
    fn new(completion_notify: Arc<Notify>) -> Result<Self> {
        let llm_agent = LlmAgent::builder("summarizer", "ollama::gemma3:latest")
            .with_system_prompt(
                "You are a summarization expert. When given research content, \
                 create a clear and concise summary with bullet points highlighting \
                 the most important facts. Keep the summary to 5-7 bullet points.",
            )
            .with_temperature(0.5)
            .with_max_tokens(512)
            .build()?;

        Ok(Self {
            llm_agent,
            completion_notify,
        })
    }
}

#[async_trait]
impl Agent for SummarizerAgent {
    fn name(&self) -> String {
        "summarizer".to_string()
    }

    async fn on_start(&mut self, _ctx: &mut AgentContext) -> Result<()> {
        println!("[Summarizer] Started and ready to summarize.");
        Ok(())
    }

    async fn on_message(&mut self, msg: Message, ctx: &mut AgentContext) -> Result<()> {
        let content = String::from_utf8_lossy(&msg.payload);
        println!("\n[Summarizer] Received content from {}", msg.sender);

        if msg.topic == "error" {
            println!("[Summarizer] Received error: {}", content);
            self.completion_notify.notify_one();
            return Ok(());
        }

        // Use LLM to summarize the research
        let summary_prompt = format!(
            "Please summarize the following research content into clear bullet points:\n\n{}",
            content
        );

        match self
            .llm_agent
            .send_message_and_get_response(&summary_prompt, ctx)
            .await
        {
            Ok(summary) => {
                println!("\n========================================");
                println!("           FINAL SUMMARY");
                println!("========================================\n");
                println!("{}", summary);
                println!("\n========================================\n");
            }
            Err(e) => {
                eprintln!("[Summarizer] Error during summarization: {}", e);
            }
        }

        // Signal completion
        self.completion_notify.notify_one();
        Ok(())
    }
}

// --- Coordinator Agent ---
// Initiates the workflow by sending a research topic
struct CoordinatorAgent {
    mesh: Arc<LocalMesh>,
    topic: String,
}

#[async_trait]
impl Agent for CoordinatorAgent {
    fn name(&self) -> String {
        "coordinator".to_string()
    }

    async fn on_start(&mut self, _ctx: &mut AgentContext) -> Result<()> {
        println!("[Coordinator] Starting multi-agent workflow...");
        println!("[Coordinator] Topic: {}\n", self.topic);

        // Small delay to ensure all agents are ready
        tokio::time::sleep(Duration::from_millis(100)).await;

        // Send topic to researcher
        let task_msg = Message::new(
            "research_topic",
            self.topic.as_bytes().to_vec(),
            self.name(),
        );
        self.mesh.send(task_msg, "researcher").await?;

        Ok(())
    }

pub fn correlation_id(&self) -> Option<String>

Get the correlation ID for request/response tracking.

pub fn set_correlation_id(&mut self, id: &str)

Set a correlation ID for request/response tracking.

Trait Implementations

impl Clone for Message

fn clone(&self) -> Message

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Message

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Message

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Message

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.