Struct ModelRef 

pub struct ModelRef {
    pub provider: String,
    pub model: String,
    pub max_tokens: Option<u32>,
    pub max_input_tokens: Option<u32>,
    pub reasoning_effort: Option<ReasoningEffort>,
    pub reasoning_summary: bool,
    pub compaction: Option<Compaction>,
    pub pricing: Option<Pricing>,
}

One model, named the way a provider names it.

Fields

provider: String

The driver: anthropic, openai, or whatever an embedder registered.

Not an enum. This crate does not own the set of providers, and a closed enum here would make adding a driver a breaking change to the manifest format for everyone who never used it.

model: String

The provider’s own model identifier, pinned exactly.

max_tokens: Option<u32>

A per-call output ceiling, if this role needs one.

max_input_tokens: Option<u32>

A per-call input ceiling: the most tokens one call may send, cached ones included.

Output is bounded before the call, because max_tokens is sent to the provider; input is not — it grows with the conversation — so this is checked against what the provider reports, and a call that sent more fails. With max_tokens and pricing it states what one call can cost, which is what a tenant’s spend quota reserves beside the run’s ceiling: under a quota a role without it leaves that figure unbounded and the run is refused.

reasoning_effort: Option<ReasoningEffort>

Explicit reasoning depth. Omitted uses the selected model’s default.

reasoning_summary: bool

Ask for a readable summary of the model’s reasoning beside each answer.

Shown on the completion and in the live stream; never the provider’s signed or encrypted reasoning. A driver whose wire cannot ask — chat-completions, bedrock — sends nothing and returns none.

compaction: Option<Compaction>

Ask the provider to compact the conversation once a call’s input reaches trigger_tokens, optionally under summary instructions. anthropic (at least 50 000) and openai (no instructions) compact; every other driver refuses the call. Must be below max_input_tokens when both are declared.

pricing: Option<Pricing>

What this model’s tokens cost, in minor units per million tokens.

Required on every declared role when budgets.max_minor_units is set: an unpriced call reports no money, and a money ceiling beside one is a control that never binds. There is no built-in price table — rates change, and the deployment is the party that knows its contract.

Implementations

impl ModelRef

pub fn new(provider: impl Into<String>, model: impl Into<String>) -> Self

A role naming only its driver and model, as YAML gives one that names only those.

pub fn call_bound(&self) -> Option<Spend>

The most one call through this role can report, when the declaration bounds it: max_input_tokens plus the output ceiling in tokens, and those tokens at the declared price in money.

The output ceiling is max_tokens, or the default every call is sent with when the role names none — either way the figure the provider is told. Input is priced at the dearest of the input, cache-read and cache-write rates, because which of them a call’s input lands in is the provider’s decision, not the declaration’s. An unpriced role reports no money, so its money figure is zero.

None when max_input_tokens is absent: input grows with the conversation, and nothing else bounds it.

Trait Implementations

impl Clone for ModelRef

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 ModelRef

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ModelRef

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for ModelRef

impl JsonSchema for ModelRef

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl PartialEq for ModelRef

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for ModelRef

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 ModelRef