Enum Expected 

pub enum Expected {
    MustContain {
        must_contain: Vec<String>,
    },
    MustNotContain {
        must_not_contain: Vec<String>,
    },
    RegexMatch {
        pattern: String,
        flags: Vec<String>,
    },
    RegexNotMatch {
        pattern: String,
        flags: Vec<String>,
    },
    JsonSchema {
        json_schema: String,
        schema_file: Option<String>,
    },
    SemanticSimilarityTo {
        semantic_similarity_to: String,
        min_score: f64,
        thresholding: Option<ThresholdingConfig>,
    },
    JudgeCriteria {
        judge_criteria: Value,
    },
    Faithfulness {
        min_score: f64,
        rubric_version: Option<String>,
        thresholding: Option<ThresholdingConfig>,
    },
    Relevance {
        min_score: f64,
        rubric_version: Option<String>,
        thresholding: Option<ThresholdingConfig>,
    },
    ArgsValid {
        policy: Option<String>,
        schema: Option<Value>,
    },
    SequenceValid {
        policy: Option<String>,
        sequence: Option<Vec<String>>,
        rules: Option<Vec<SequenceRule>>,
    },
    ToolBlocklist {
        blocked: Vec<String>,
    },
    ToolDescriptionIntegrity {
        pinned_tools: Vec<PinnedTool>,
    },
    ToolOutputValid {
        schemas: Option<Value>,
    },
    ToolCollisionDetect {
        trusted_servers: Vec<String>,
    },
    Reference {
        path: String,
    },
}

Variants

MustContain

Fields

must_contain: Vec<String>

MustNotContain

Fields

must_not_contain: Vec<String>

RegexMatch

Fields

pattern: String

flags: Vec<String>

RegexNotMatch

Fields

pattern: String

flags: Vec<String>

JsonSchema

Fields

json_schema: String

schema_file: Option<String>

SemanticSimilarityTo

Fields

semantic_similarity_to: String

min_score: f64

thresholding: Option<ThresholdingConfig>

JudgeCriteria

Fields

judge_criteria: Value

Faithfulness

Fields

min_score: f64

rubric_version: Option<String>

thresholding: Option<ThresholdingConfig>

Relevance

Fields

min_score: f64

rubric_version: Option<String>

thresholding: Option<ThresholdingConfig>

ArgsValid

Fields

policy: Option<String>

schema: Option<Value>

SequenceValid

Fields

policy: Option<String>

sequence: Option<Vec<String>>

rules: Option<Vec<SequenceRule>>

ToolBlocklist

Fields

blocked: Vec<String>

ToolDescriptionIntegrity

Detect rug-pull attacks: verify tool descriptions/schemas match pinned expectations or remain consistent across multiple tool-list snapshots in the same trace.

Fields

pinned_tools: Vec<PinnedTool>

Pin specific tool definitions. If empty, snapshot-based mutation detection is used.

ToolOutputValid

Validate tool call outputs against per-tool JSON schemas.

Fields

schemas: Option<Value>

Map of tool_name → JSON Schema for the output. Only tools with a schema are checked.

ToolCollisionDetect

Detect tool shadowing: same tool name registered by multiple servers.

Fields

trusted_servers: Vec<String>

Only flag collisions involving servers outside this list. Empty = flag all duplicate tool names regardless of server.

Reference

Fields

path: String

Implementations

impl Expected

pub fn get_policy_path(&self) -> Option<&str>

pub fn thresholding_for_metric( &self, metric_name: &str, ) -> Option<&ThresholdingConfig>

Per-test thresholding for baseline regression (mode/max_drop) when this Expected variant matches the metric.

Trait Implementations

impl Clone for Expected

fn clone(&self) -> Expected

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Expected

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

Formats the value using the given formatter.

impl Default for Expected

fn default() -> Self

NOTE: this default is vacuous — an empty must_contain makes the must_contain metric pass unconditionally, because it has no substring to look for. It exists only so TestCase can derive Default and so a test whose checks live in assertions: can omit expected: entirely.

It must never be used as a parse fallback: an expected: block that fails to parse is a hard config error (see model::serde), and a test that ends up holding this value with no assertions is reported by the W_CFG_VACUOUS_EXPECTED rule in assay validate.

impl<'de> Deserialize<'de> for Expected

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Expected

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

where __S: Serializer,

Serialize this value into the given Serde serializer.