Struct TaskExecutor 

pub struct TaskExecutor { /* private fields */ }

Task executor for delegated child runs.

Implementations

impl TaskExecutor

pub fn new( registry: Arc<AgentRegistry>, llm_client: Arc<dyn LlmClient>, workspace: String, ) -> Self

Create a new task executor

pub fn with_mcp( registry: Arc<AgentRegistry>, llm_client: Arc<dyn LlmClient>, workspace: String, mcp_manager: Arc<McpManager>, ) -> Self

Create a new task executor with MCP manager for tool inheritance

pub fn with_parent_context(self, ctx: ChildRunContext) -> Self

Set parent session capabilities to inherit into child runs.

pub fn with_max_parallel_tasks(self, max_parallel_tasks: usize) -> Self

pub fn with_subagent_tracker( self, tracker: Arc<InMemorySubagentTaskTracker>, ) -> Self

Share a tracker with this executor. When set, each task registers a CancellationToken against the tracker so the parent session can cancel by task_id.

pub async fn execute( &self, params: TaskParams, event_tx: Option<Sender<AgentEvent>>, parent_session_id: Option<&str>, ) -> Result<TaskResult>

Execute a task by spawning an isolated child AgentLoop.

parent_session_id flows into the emitted SubagentStart/SubagentEnd events so dashboards can associate child runs with the parent session.

pub async fn execute_with_task_id( &self, task_id: String, params: TaskParams, event_tx: Option<Sender<AgentEvent>>, parent_session_id: Option<&str>, emit_start: bool, ) -> Result<TaskResult>

Execute a task using a caller-supplied task id. Used by execute_background so the synchronously-returned task id matches the one in lifecycle events. When emit_start is false the caller is responsible for emitting SubagentStart themselves (e.g. to avoid a race against a tracker query).

pub fn execute_background( self: Arc<Self>, params: TaskParams, event_tx: Option<Sender<AgentEvent>>, parent_session_id: Option<String>, ) -> String

Execute a task in the background.

Returns immediately with the task ID; the same id is used in the emitted SubagentStart/SubagentEnd events so callers can correlate. Pre-emits SubagentStart synchronously when an event channel is available so a caller that queries the subagent task tracker right after this call observes the task in Running state without a race window.

pub async fn execute_parallel( self: &Arc<Self>, tasks: Vec<TaskParams>, event_tx: Option<Sender<AgentEvent>>, parent_session_id: Option<&str>, ) -> Vec<TaskResult>

Execute multiple tasks in parallel.

Spawns all tasks concurrently and waits for all to complete. Returns results in the same order as the input tasks.