Struct TaskExecutor 

pub struct TaskExecutor {
    pub graph: TaskGraph,
    pub max_concurrent: usize,
    pub max_retries: u32,
}

Parallel wave-based executor for a TaskGraph.

Usage

let executor = TaskExecutor::new(graph)
    .with_max_concurrent(4)
    .with_max_retries(2);

let report = executor.run(llm, tools, tool_ctx, io).await?;
println!("completed: {}", report.task_results.len());

Execution Model

The executor runs a loop:

loop:
  1. Find all Pending tasks whose deps are all Completed → "ready set"
  2. If ready.is_empty() && nothing running && not finished → deadlock (error)
  3. Dispatch up to (max_concurrent - running) tasks from the ready set
  4. Wait for ONE task to finish (JoinSet::join_next)
  5. On success  → mark_completed, store result
     On failure  → if retries < max_retries: reset_for_retry (will be re-queued)
                   else: mark_failed, cancel all downstream dependents
  6. Repeat until graph.is_finished()

Fields

graph: TaskGraph

The task graph being executed. Made pub so callers can inspect it after a failed run.

max_concurrent: usize

Maximum number of tasks that may be executing concurrently. Default: 4.

max_retries: u32

How many times a task may be retried before it is permanently failed. Default: 2.

Implementations

impl TaskExecutor

pub fn new(graph: TaskGraph) -> Self

Create an executor with default settings (4 concurrent, 2 retries).

pub fn with_max_concurrent(self, n: usize) -> Self

Override the maximum concurrency (number of tasks running at once).

pub fn with_max_retries(self, n: u32) -> Self

Override the per-task retry limit.

pub async fn run( self, llm: Arc<dyn LlmProvider>, tools: Arc<ToolRegistry>, tool_ctx: ToolContext, io: Arc<dyn AgentIO>, ) -> Result<ExecutionReport>

Execute the task graph, returning a report when all tasks finish.

Parameters

• llm — LLM provider shared across all tasks (thread-safe Arc).
• tools — Tool registry shared across all tasks.
• tool_ctx — Per-execution tool context (cloned for each task).
• io — I/O channel for progress output.

Errors

Returns an error if:

• The graph enters a deadlock (tasks remain but none are ready or running).
• A spawned tokio task panics (join error).