Struct TaskInfo 

pub struct TaskInfo {
    pub task: Task,
    pub name: Option<String>,
    pub batch_size: Option<usize>,
    pub summary_template: Option<String>,
    pub weight: u32,
    pub enriches: bool,
    pub rate_limiter: Option<Arc<dyn RateLimiter>>,
}

A Task bundled with optional per-task configuration.

Use TaskInfo::new to wrap a task and then chain .with_name / .with_batch_size to override the pipeline-level defaults:

TaskInfo::new(my_task)
    .with_name("embed-chunks")
    .with_batch_size(16)

Fields

task: Task

name: Option<String>

Human-readable label used in watcher events and status logs.

batch_size: Option<usize>

Overrides the pipeline-level batch_size for this task. None → inherit pipeline.batch_size.

summary_template: Option<String>

Template for a human-readable result summary recorded as a tracing span attribute when the telemetry feature is enabled.

Use {n} as a placeholder for the result count. E.g. "Classified {n} document(s)".

weight: u32

Relative weight for progress allocation. The executor normalizes weights across all tasks to determine what fraction of overall progress each task owns. Default: 1.

enriches: bool

If true, a returned PassthroughSentinel forwards the task’s input unchanged to the next task instead of being an error. Default false.

Note: pass-through is defined for single-value outputs only. For iterator/stream tasks there is no single “original input” to forward; those paths treat PassthroughSentinel as a regular value. Use DroppedSentinel to skip individual items in iterator/stream tasks.

rate_limiter: Option<Arc<dyn RateLimiter>>

Per-task rate limiter. Overrides the pipeline-level limiter when set. None inherits the pipeline limiter (or no throttling if that is also None). See RateLimiter for details.

Implementations

impl TaskInfo

pub fn new(task: Task) -> TaskInfo

pub fn with_name(self, name: impl Into<String>) -> TaskInfo

pub fn with_batch_size(self, size: usize) -> TaskInfo

pub fn with_summary(self, template: impl Into<String>) -> TaskInfo

Set a summary template for telemetry.

{n} is replaced with the result count at runtime. E.g. "Classified {n} document(s)".

pub fn with_weight(self, weight: u32) -> TaskInfo

pub fn with_enriches(self) -> TaskInfo

Mark this task as an enrichment step: returning PassthroughSentinel forwards the input unchanged rather than failing.

Pass-through is defined for single-value outputs only — it forwards the one input of a 1-in/1-out task. Iterator/stream tasks that want to skip individual items should yield DroppedSentinel instead.

pub fn with_rate_limiter(self, rl: Arc<dyn RateLimiter>) -> TaskInfo

Set a per-task rate limiter, overriding the pipeline-level one.

When set, every attempt inside call_with_retry (and every batch call in dispatch_batch) acquires a token from this limiter before calling the task. None inherits the pipeline-level limiter.

pub fn parallel(infos: Vec<TaskInfo>) -> TaskInfo

Build a parallel task from multiple TaskInfos.

Extracts the inner Tasks, delegates to Task::parallel, and auto-generates a name like "parallel([name1, name2, …])".

Trait Implementations

impl From<Task> for TaskInfo

fn from(task: Task) -> TaskInfo

Converts to this type from the input type.

impl<I, O> From<TypedTask<I, O>> for TaskInfo

where I: Value, O: Value,

fn from(t: TypedTask<I, O>) -> TaskInfo

Converts to this type from the input type.