Struct AgentCoordinator 

pub struct AgentCoordinator { /* private fields */ }

Agent Coordinator

Coordinates multiple agents with task assignment, load balancing, and deadlock detection.

Implementations

impl AgentCoordinator

pub fn new() -> Self

Create a new coordinator

pub fn with_heartbeat_timeout(self, secs: i64) -> Self

Set heartbeat timeout

pub fn register_agent( &mut self, capabilities: AgentCapabilities, ) -> CoordinatorResult<()>

Register an agent

pub fn unregister_agent(&mut self, agent_id: &str) -> CoordinatorResult<()>

Unregister an agent

pub fn update_agent_status( &mut self, agent_id: &str, status: AgentStatus, ) -> CoordinatorResult<()>

Update agent status

pub fn heartbeat(&mut self, agent_id: &str) -> CoordinatorResult<()>

Update agent heartbeat

pub fn get_agent(&self, agent_id: &str) -> Option<&AgentCapabilities>

Get agent by ID

pub fn get_agent_mut( &mut self, agent_id: &str, ) -> Option<&mut AgentCapabilities>

Get mutable agent by ID

pub fn get_agents(&self) -> Vec<&AgentCapabilities>

Get all agents

pub fn get_agents_by_type(&self, agent_type: &str) -> Vec<&AgentCapabilities>

Get agents by type

pub fn get_agents_with_capability( &self, capability: &str, ) -> Vec<&AgentCapabilities>

Get agents with capability

pub fn check_agent_health(&mut self)

Check agent health and mark offline if heartbeat timeout

pub fn assign_task( &mut self, task: Task, criteria: &AssignmentCriteria, ) -> CoordinatorResult<String>

Assign a task to an agent based on criteria

pub fn start_task(&mut self, task_id: &str) -> CoordinatorResult<()>

Mark a task as started

pub fn complete_task( &mut self, task_id: &str, result: TaskResult, ) -> CoordinatorResult<()>

Complete a task

pub fn fail_task( &mut self, task_id: &str, error: String, ) -> CoordinatorResult<()>

Fail a task

pub fn get_task(&self, task_id: &str) -> Option<(&Task, TaskStatus)>

Get task assignment

pub fn get_task_result(&self, task_id: &str) -> Option<&TaskResult>

Get task result

pub fn get_agent_tasks(&self, agent_id: &str) -> Vec<&Task>

Get tasks assigned to an agent

pub fn get_pending_tasks(&self) -> Vec<&Task>

Get pending tasks

pub fn get_running_tasks(&self) -> Vec<&Task>

Get running tasks

pub fn record_resource_dependency(&mut self, agent_id: &str, resource: &str)

Record that an agent is waiting for a resource

pub fn remove_resource_dependency(&mut self, agent_id: &str, resource: &str)

Remove a resource dependency

pub fn record_resource_holder(&mut self, resource: &str, agent_id: &str)

Record that an agent holds a resource

pub fn remove_resource_holder(&mut self, resource: &str)

Remove a resource holder

pub fn detect_deadlock(&self) -> Option<DeadlockInfo>

Detect deadlock using cycle detection in the wait-for graph

pub fn create_sync_barrier(&mut self, agent_ids: Vec<String>) -> String

Create a synchronization barrier for agents

pub fn arrive_at_barrier( &mut self, barrier_id: &str, agent_id: &str, ) -> CoordinatorResult<bool>

Agent arrives at a barrier

pub fn is_barrier_reached(&self, barrier_id: &str) -> bool

Check if all agents have arrived at a barrier

pub fn remove_barrier(&mut self, barrier_id: &str)

Remove a barrier

pub fn get_pending_agents(&self, barrier_id: &str) -> Vec<String>

Get agents that haven’t arrived at a barrier

pub fn get_stats(&self) -> CoordinatorStats

Get coordinator statistics

pub fn on_event<F>(&mut self, callback: F)

where F: Fn(&CoordinatorEvent) + Send + Sync + 'static,

Register an event callback

pub fn clear_event_callbacks(&mut self)

Clear all event callbacks

Trait Implementations

impl Default for AgentCoordinator

fn default() -> Self

Returns the “default value” for a type.