Struct AgentContext 

pub struct AgentContext {
    pub mesh_name: String,
    /* private fields */
}

Runtime context provided to agents during lifecycle and message handling.

The context gives agents access to mesh information and utilities for interacting with the request/response system.

Example

async fn on_message(&mut self, msg: Message, ctx: &mut AgentContext) -> Result<()> {
    println!("Running in mesh: {}", ctx.mesh_name);
    if let Some(id) = msg.correlation_id() {
        ctx.report_result(&id, "Done!".to_string());
    }
    Ok(())
}

Fields

mesh_name: String

The name of the mesh this agent is running in.

Implementations

impl AgentContext

pub fn new(mesh_name: String, request_queue: Option<Arc<RequestQueue>>) -> Self

Create a new agent context.

Arguments

• mesh_name - Name of the mesh
• request_queue - Optional request queue for request/response pattern

Examples found in repository

examples/llm_ollama.rs (line 39)

async fn main() -> Result<()> {
    println!("=== Ceylon Runtime - LLM Ollama Example ===\n");

    // Create an LLM agent using Ollama with gemma3:latest model
    // No API key is required for Ollama (local inference)
    let mut agent = LlmAgent::builder("gemma_agent", "ollama::gemma3:latest")
        .with_system_prompt(
            "You are a helpful AI assistant. Be concise and informative in your responses.",
        )
        .with_temperature(0.7)
        .with_max_tokens(1024)
        .build()?;

    println!("✓ LLM Agent created successfully with Ollama gemma3:latest\n");

    // Create an agent context for the conversation
    let mut ctx = AgentContext::new("gemma_demo_mesh".to_string(), None);

    // Example 1: Simple greeting
    println!("--- Example 1: Simple Greeting ---");
    let prompt1 = "Hello! What are you capable of?";
    println!("User: {}", prompt1);

    match agent.send_message_and_get_response(prompt1, &mut ctx).await {
        Ok(response) => {
            println!("Assistant: {}\n", response);
        }
        Err(e) => {
            eprintln!("Error: {}\n", e);
            eprintln!("Make sure Ollama is running and gemma3:latest model is available.");
            eprintln!("Pull the model with: ollama pull gemma3:latest");
            return Err(e);
        }
    }

    // Example 2: Technical question
    println!("--- Example 2: Technical Question ---");
    let prompt2 = "Explain what an AI agent is in 2-3 sentences.";
    println!("User: {}", prompt2);

    match agent.send_message_and_get_response(prompt2, &mut ctx).await {
        Ok(response) => {
            println!("Assistant: {}\n", response);
        }
        Err(e) => {
            eprintln!("Error: {}\n", e);
            return Err(e);
        }
    }

    // Example 3: Creative task
    println!("--- Example 3: Creative Task ---");
    let prompt3 = "Write a haiku about programming.";
    println!("User: {}", prompt3);

    match agent.send_message_and_get_response(prompt3, &mut ctx).await {
        Ok(response) => {
            println!("Assistant: {}\n", response);
        }
        Err(e) => {
            eprintln!("Error: {}\n", e);
            return Err(e);
        }
    }

    println!("=== Example completed successfully! ===");
    Ok(())
}

pub fn report_result(&self, request_id: &str, response: String)

Report a result for a pending request.

Call this to send a response back to the requester when handling a message with a correlation ID.

pub fn has_request_queue(&self) -> bool

Check if this context has a request queue available.