Struct SwarmExecutor 

pub struct SwarmExecutor { /* private fields */ }

The swarm executor runs subtasks in parallel

Implementations

impl SwarmExecutor

pub fn new(config: SwarmConfig) -> Self

Create a new executor

pub async fn with_cache( config: SwarmConfig, cache_config: CacheConfig, ) -> Result<Self>

Create a new executor with caching enabled

pub fn with_cache_instance(self, cache: Arc<Mutex<SwarmCache>>) -> Self

Set a pre-initialized cache

pub fn with_bus(self, bus: Arc<AgentBus>) -> Self

Set an agent bus for inter-agent communication

pub fn bus(&self) -> Option<&Arc<AgentBus>>

Get the agent bus if set

pub fn with_event_tx(self, tx: Sender<SwarmEvent>) -> Self

Set an event channel for real-time TUI updates

pub fn with_coordinator_agent(self, agent: Arc<Mutex<Agent>>) -> Self

Set a coordinator agent for swarm-level coordination

pub fn with_telemetry( self, telemetry: Arc<Mutex<SwarmTelemetryCollector>>, ) -> Self

Set a telemetry collector for swarm execution metrics

pub fn telemetry_arc(&self) -> Arc<Mutex<SwarmTelemetryCollector>>

Get the telemetry collector as an Arc

pub fn coordinator_agent(&self) -> Option<&Arc<Mutex<Agent>>>

Get the coordinator agent if set

pub fn result_store(&self) -> &Arc<ResultStore>

Get the shared result store

pub async fn cache_stats(&self) -> Option<CacheStats>

Get cache statistics if caching is enabled

pub async fn clear_cache(&self) -> Result<()>

Clear the cache if enabled

pub async fn execute( &self, task: &str, strategy: DecompositionStrategy, ) -> Result<SwarmResult>

Execute a task using the swarm

pub async fn execute_single(&self, task: &str) -> Result<SwarmResult>

Execute a single task without decomposition (for simple cases)