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 describe_in_prompt: bool,
    pub required: bool,
    pub summarizable: bool,
    pub admission: Admission,
    pub volatility: Volatility,
    pub required_message: Option<String>,
    pub seed: Option<RegionSeed>,
    pub accepts: Vec<String>,
}

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 that names a token count directly gets an absolute ceiling. 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

describe_in_prompt: bool

Whether description is also shown to the model, under the region’s name. Off by default - see crate::region::Region::describe_in_prompt.

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.

summarizable: bool

Whether an edge transform may hand this region to the summarizer.

transform = "compact" reads as “summarize the transcript on the way out” and means “summarize every region that is not pinned”, which includes the ones holding the run’s results. Figures that survive a paraphrase are no longer figures: without this, a results region carrying computed values is rewritten into prose before the stage that reports them ever sees it.

Setting this false protects the region wherever it is used, rather than at each of the N edges that might touch it. clear still applies - this says “do not paraphrase my content”, not “keep it forever”.

admission: Admission

What this region does when a write does not fit.

Declared per region rather than per stage: whether losing the oldest entry is acceptable is a property of what the region holds, and does not change depending on which stage is writing to it.

volatility: Volatility

How much this region’s contents move between requests. See crate::region::Volatility.

Defaulted on the wire so a definition written before this existed still loads, and loads as the pessimistic value - which is what an unclassified region should be.

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.

accepts: Vec<String>

Mime type patterns this region takes; empty means anything. See crate::region::Region::accepts.

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) -> Self

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.