Struct RegionDefinition 

pub struct RegionDefinition {
    pub name: String,
    pub kind: RegionKind,
    pub max_tokens: usize,
    pub budget: BudgetSpec,
    pub compact_at: Option<f64>,
    pub schema: Option<RegionSchema>,
    pub description: Option<String>,
    pub required: bool,
    pub required_message: Option<String>,
    pub seed: Option<RegionSeed>,
}

Definition of a region in a layout.

This is the blueprint for creating a Region instance. It specifies the region’s configuration but doesn’t contain actual content.

Fields

name: String

Unique name for this region

kind: RegionKind

Region lifecycle policy

max_tokens: usize

Resolved maximum tokens for this region. This is the concrete ceiling every downstream consumer reads; for a percentage budget it is populated when the layout is resolved against a model window (see ContextLayout::resolved). Self::budget is the source of truth for how this value is derived.

budget: BudgetSpec

How this region’s ceiling is expressed. Defaults (via Self::new) to BudgetSpec::Absolute holding max_tokens, so a region built the old way behaves exactly as before. A percentage budget is resolved against the model context window at window-build time.

compact_at: Option<f64>

For RegionKind::Compacting regions only: compact when the region reaches this fraction of its resolved budget (0.80 for compact_at = "80%"). None keeps the absolute threshold_tokens carried on the kind. See ContextLayout::resolved for how this becomes a concrete threshold.

schema: Option<RegionSchema>

Optional validation schema

description: Option<String>

Human-readable description of this region’s purpose

required: bool

When true, this region must be non-empty before a stage that can write to it is allowed to complete. Guards against an agent skipping a context-population step (e.g. never writing the plan region). Enforced in the run loop, which re-runs the stage with Self::required_message until the region is populated.

required_message: Option<String>

Optional custom message shown to the agent when this region is required but empty. Falls back to a generated default when None.

seed: Option<RegionSeed>

Where this region’s initial content comes from at run start. None means the region starts empty (the agent populates it). See RegionSeed.

Implementations

impl RegionDefinition

pub fn new(name: String, kind: RegionKind, max_tokens: usize) -> Self

Create a new region definition with an absolute token ceiling.

The budget is set to BudgetSpec::Absolute holding max_tokens and compact_at to None, so every existing caller (and every region without a percentage budget) is unaffected - resolving such a layout is a no-op.

pub fn with_budget(self, budget: BudgetSpec) -> Self

Set this region’s budget spec (e.g. a percentage of the model window). max_tokens is left as the provisional/resolved value; it is (re)computed from the budget when the owning layout is resolved.

pub fn with_compact_at(self, fraction: f64) -> Self

Set the compaction trigger fraction for a RegionKind::Compacting region (0.80 == compact at 80% of the resolved budget).

pub fn with_seed(self, seed: RegionSeed) -> Self

Set this region’s seed source.

pub fn with_required(self, required: bool, message: Option<String>) -> Self

Mark this region as required, with an optional custom nudge message.

pub fn with_schema(self, schema: RegionSchema) -> Self

Add a schema to this region definition.

pub fn with_description(self, description: String) -> Self

Add a description to this region definition.

Trait Implementations

impl Clone for RegionDefinition

fn clone(&self) -> RegionDefinition

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for RegionDefinition

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for RegionDefinition

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for RegionDefinition

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.