Enum Check 

#[non_exhaustive]
pub enum Check {
    ValidStructuredResponse,
    MalformedJson,
    UnknownFields,
    MissingRequiredFields,
    MultipleActs,
    ToolAndReadRequestIds,
    StreamingReconstruction,
    StreamingIncremental,
    StreamingUsageAgreement,
    TokenUsageContract,
    EmptyOutput,
    Refusal,
    Timeout,
    RateLimit,
    AuthenticationFailure,
    ContextOverflow,
    Cancellation,
    RetryClassification,
    SecretRedaction,
    NoSilentCapabilityDowngrade,
    StatusMapping(StatusRow),
}

One row of the spec §20.8 table.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

ValidStructuredResponse

A schema-conformant body maps to a normalized response with every field intact.

MalformedJson

A body that is not JSON is a typed failure, never a partial parse.

UnknownFields

A field the schema forbids rejects the whole response.

MissingRequiredFields

A missing required field rejects the whole response; no default is filled in.

MultipleActs

A multi-act plan round-trips in order, as one proposal.

ToolAndReadRequestIds

Tool and read request ids survive, and preserves_call_ids matches what actually happens.

StreamingReconstruction

The reassembled stream equals the non-streamed answer for the same exchange.

StreamingIncremental

An answer that arrived as several wire events produced several deltas.

Without this row an adapter that reads the whole body, then emits one TextDelta at the end, reassembles perfectly and gives an adopter nothing: the point of streaming is prose appearing while it is written.

StreamingUsageAgreement

The streamed and the whole path report the same TokenUsage for the same answer.

Usage rides on a final frame in most vendors, so it is the first thing a streaming implementation drops — and a cost figure that depends on which path served the turn is worse than no cost figure.

TokenUsageContract

The reported usage keeps its own contract: cached_input is a subset of input, never a figure alongside it.

input is the whole prompt and cached_input is the part of it the provider served from its cache. An adapter that reports the net figure — input minus cache — makes every cost estimate wrong and every cache-hit ratio over one.

EmptyOutput

An empty body is a typed failure or an empty response, never an empty plan that parses.

Refusal

A refusal maps to the refusal variant, distinguishable from malformed output.

Timeout

A deadline that passes produces Timeout.

RateLimit

A rate limit maps to its variant and preserves the Retry-After hint.

AuthenticationFailure

Rejected credentials map to a non-retryable variant, and the key never appears in the error.

ContextOverflow

A context overflow gets its own variant, so the runtime can shrink the prompt instead of retrying blindly.

Cancellation

Dropping the future aborts cleanly, with nothing left running.

RetryClassification

Every observed error carries the RetryClass the policy layer expects.

SecretRedaction

The configured credential appears in no rendering of the adapter, its responses or its errors.

NoSilentCapabilityDowngrade

A profile that declares schema enforcement actually sends the schema.

StatusMapping(StatusRow)

One wire failure maps onto the one error kind it means (spec §24).

RetryClassification proves the class of whatever kind the adapter produced; these rows prove it produced the right kind. Without them an adapter that flattens every failure onto Transport passes the whole suite.

Implementations

impl Check

pub const ALL: [Check; 20]

The feature rows of spec §20.8, in the order run_all executes them.

Seventeen come from the specification’s own table; the three that follow StreamingReconstruction were added because reassembly on its own proves neither that a stream is incremental nor that the counts survive it.

A full run also reports the thirteen STATUS rows; run_order is the complete sequence.

pub const STATUS: [Check; 13]

The thirteen per-status rows, in the order a run executes them.

They run before RetryClassification, so the kinds they observe are classified too.

pub fn run_order() -> Vec<Check>

Every row a full run reports, in execution order.

The STATUS rows sit where they are exercised — after the failure checks and before RetryClassification — rather than appended at the end, so the classification row covers what they saw.

pub const fn as_str(self) -> &'static str

Stable snake-case label.

pub const fn status_row(self) -> Option<StatusRow>

The per-status row this check exercises, when it is one.

pub const fn is_declaration_check(self) -> bool

Returns true for the checks whose failure means the profile’s declaration is wrong rather than its plumbing.

Failing one of these is never fixed by relaxing the test: the declaration must be lowered instead (spec §20.3).

pub const fn is_declarable(self) -> bool

Returns true for the feature rows a deployment may declare it cannot produce, in words, through WireFixtures::feature_support.

These are the rows whose behaviour depends on what sits around the model rather than on the model: a daemon started on a laptop authenticates nobody, meters nothing and has no safety filter, and a deployment may genuinely have no streaming endpoint. Every other row is a property of the adapter itself and cannot be declared away — a declaration on one of those fails the row rather than skipping it.

A per-status row is declared through WireFixtures::status_support instead, which is why it is not listed here.

Trait Implementations

impl Clone for Check

fn clone(&self) -> Check

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Check

impl Debug for Check

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

Formats the value using the given formatter.

impl Display for Check

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

Formats the value using the given formatter.

impl Eq for Check

impl Hash for Check

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for Check

fn cmp(&self, other: &Check) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

fn clamp_to<R>(self, range: R) -> Self

where Self: Sized, R: ClampBounds<Self>,

🔬This is a nightly-only experimental API. (clamp_to)

Restrict a value to a certain range.

impl PartialEq for Check

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

Equality operator ==.

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

Inequality operator !=.

impl PartialOrd for Check

fn partial_cmp(&self, other: &Check) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl StructuralPartialEq for Check