Struct ModelContext 

pub struct ModelContext {
    pub capabilities: ModelCapabilities,
    pub tags: Vec<String>,
    pub inference_defaults: Option<InferenceConfig>,
    pub defaults_origin: Option<DefaultsOrigin>,
    pub context_length: Option<u64>,
}

Everything a request pipeline needs to know about the target model, gathered in a single catalog round-trip.

The five fields feed the resolution and shaping stages, which is why they travel together rather than being looked up where each is needed:

• capabilities — request-side transforms (strict-turn coalescing and friends).
• tags — response-stream parser selection, and (via the reasoning tag) the sampling floor.
• inference_defaults — the per-model layer of the sampling hierarchy.
• defaults_origin — which rung inference_defaults occupies in that hierarchy.
• context_length — the history-truncation budget.

Before this type was shared, the proxy resolved all of them while every other surface resolved the same row and kept only tags, so capability coalescing and per-model defaults were unreachable outside the proxy.

Fields

capabilities: ModelCapabilities

Stored capability bitfield — drives request-side transforms.

tags: Vec<String>

format:* tags — drives response-stream parser selection.

inference_defaults: Option<InferenceConfig>

Per-model inference defaults to merge into each request.

defaults_origin: Option<DefaultsOrigin>

Whether inference_defaults was set by the user or auto-detected. See DefaultsOrigin.

context_length: Option<u64>

Maximum context the model supports, in tokens — the history-truncation budget for every surface that cannot measure a live serving context.

Implementations

impl ModelContext

pub fn passthrough() -> Self

The zeroed context: empty capabilities so every transform is a no-op, empty tags so the identity passthrough parser is selected, no per-model defaults, and no truncation budget.

This is the conservative fallback used whenever the model cannot be resolved — an unresolvable model must never block a request, only lose its model-specific handling.

pub fn context_budget_chars(&self) -> Option<usize>

The history-truncation budget in characters, from the model’s own capacity: context_length tokens converted at CHARS_PER_TOKEN_APPROX.

None when the context size is unknown, which apply reads as do not truncate. Guessing a budget for an unresolvable model would risk rejecting a request over a number nobody actually knows; losing model-specific handling is the whole fallback policy of this module.

Callers that know the live serving context — the proxy, which also learns a per-model chars-per-token ratio from observed usage frames — compute a better number and pass that instead. This is the answer for everyone else.

Trait Implementations

impl Clone for ModelContext

fn clone(&self) -> ModelContext

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ModelContext

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

Formats the value using the given formatter.

impl Default for ModelContext

fn default() -> ModelContext

Returns the “default value” for a type.

impl From<&ModelSummary> for ModelContext

fn from(summary: &ModelSummary) -> Self

Converts to this type from the input type.

impl PartialEq for ModelContext

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for ModelContext