Struct LocalMesh 

pub struct LocalMesh { /* private fields */ }

Implementations

impl LocalMesh

pub fn new(name: impl Into<String>) -> Self

Examples found in repository

examples/mesh_architecture.rs (line 80)

async fn main() -> Result<()> {
    // 1. Create the Mesh (wrapped in Arc for sharing)
    let mesh = Arc::new(LocalMesh::new("main_mesh"));

    // 2. Create Agents with reference to mesh
    let completion = Arc::new(Notify::new());

    let worker = Box::new(WorkerAgent { mesh: mesh.clone() });
    let manager = Box::new(ManagerAgent {
        mesh: mesh.clone(),
        completion_notify: completion.clone(),
    });

    // 3. Register Agents
    mesh.add_agent(worker).await?;
    mesh.add_agent(manager).await?;

    // 4. Start Mesh
    mesh.start().await?;

    // Wait for the interaction to complete
    println!("Waiting for interaction to complete...");
    // Timeout after 5 seconds
    tokio::select! {
        _ = completion.notified() => {
            println!("Interaction completed successfully!");
        }
        _ = tokio::time::sleep(Duration::from_secs(5)) => {
            println!("Timeout waiting for interaction.");
        }
    }

    // 5. Stop Mesh
    mesh.stop().await?;

    Ok(())
}

pub fn request_queue(&self) -> Arc<RequestQueue>

Get the request queue (for sharing with agent wrappers)

impl LocalMesh

pub async fn broadcast( &self, message: Message, exclude: Option<&str>, ) -> Result<Vec<Result<()>>>

Broadcast a message to all agents in the mesh

pub async fn submit(&self, target: &str, payload: String) -> Result<String>

Submit a request (fire-and-forget). Returns request ID.

pub fn get_pending(&self) -> Vec<MeshRequest>

Get pending requests

pub fn has_pending(&self) -> bool

Check if there are pending requests

pub fn get_results(&self) -> Vec<MeshResult>

Get available results (removes them from queue)

pub fn peek_results(&self) -> Vec<MeshResult>

Peek at results without removing

pub async fn send_reminders(&self, older_than_secs: f64) -> Result<Vec<String>>

Send reminders for stale requests

pub async fn wait_for( &self, request_id: &str, timeout_secs: f64, reminder_interval_secs: f64, ) -> Result<MeshResult>

Wait for a specific result with auto-reminders

pub async fn collect_results( &self, reminder_interval_secs: f64, ) -> Vec<MeshResult>

Collect all results, blocking until all pending complete

Trait Implementations

impl Mesh for LocalMesh

fn start<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn stop<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn add_agent<'life0, 'async_trait>( &'life0 self, agent: Box<dyn Agent + 'static>, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn send<'life0, 'life1, 'async_trait>( &'life0 self, message: Message, target: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,