Struct Containment 

pub struct Containment {
    pub max_total_agents: u32,
    pub max_concurrent: u32,
    pub max_depth: u32,
    pub max_total_tokens: u64,
    pub max_total_cost: Option<u64>,
    pub max_total_duration: Option<Duration>,
}

The caps a whole agent tree runs under. Tokens are the hard spend ceiling (no price telemetry exists, so spend is counted in tokens); an optional cost and duration are carried for callers that supply them.

use io_harness::Containment;

// Twelve agents in the tree, four running at once, two levels of nesting, and
// 200k tokens for all of them together. A spawned contract can tighten any of
// these and can raise none of them.
let containment = Containment::new(12, 4, 2, 200_000);

// The ceiling actually enforced is the token one: a provider reports tokens
// and never money, so `max_total_cost` is inert and stays `None`.
assert_eq!(containment.max_total_tokens, 200_000);
assert_eq!(containment.max_total_cost, None);

// Serde, so an operator's config file is the source of the caps rather than a
// recompile.
let stored = serde_json::to_string(&containment).unwrap();
let loaded: Containment = serde_json::from_str(&stored).unwrap();
assert_eq!(loaded, containment);

Fields

max_total_agents: u32

Maximum number of agents that may exist in the tree, root included.

max_concurrent: u32

Maximum number of agents that may run at once.

max_depth: u32

Maximum nesting depth, counted from the root (the root is depth 0).

max_total_tokens: u64

Aggregate token ceiling drawn down by the entire tree together.

max_total_cost: Option<u64>

Optional aggregate cost ceiling, in whatever unit the caller supplies (there is no price telemetry, so the crate never derives this itself). Reserved, and not enforced. Setting it has no effect.

Enforcing a cost ceiling needs a price per token, and the crate has no price telemetry — a provider reports tokens, never money, so any figure the harness compared against would be one it invented. The field is kept rather than removed because it serialises in callers’ stored configuration and deleting it would break their deserialisation for no gain; it is documented as inert instead, which is the honest state.

Spend that is enforced is Self::max_total_tokens. To bound money, convert your budget to tokens at your provider’s rate and set that.

max_total_duration: Option<Duration>

Optional wall-clock ceiling for the whole tree, measured from when the ROOT run started — so it counts a 24-hour tree’s whole life, including time the process was down, not the age of whichever agent notices.

Crossing it halts the tree with RunOutcome::BudgetCeilingReached, the same way the token ceiling does, and a child’s own contract cannot raise it. Declared in 0.5.0 and not actually enforced until 0.12.0.

Implementations

impl Containment

pub fn new( max_total_agents: u32, max_concurrent: u32, max_depth: u32, max_total_tokens: u64, ) -> Self

A containment with token, agent, concurrency, and depth caps and no cost/duration ceiling.

Trait Implementations

impl Clone for Containment

fn clone(&self) -> Containment

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Containment

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Containment

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Containment

impl PartialEq for Containment

fn eq(&self, other: &Containment) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for Containment

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Containment