Struct OutputSpec 

pub struct OutputSpec {
    pub format: Option<String>,
    pub instructions: Option<String>,
    pub example: Option<String>,
    pub schema: Option<Value>,
    pub validator: Option<String>,
}

What shape an agent should return.

Declared by a blueprint ([agent.output]), narrowed by a stage ([stages.<name>.output]), and overridable by whoever starts the run. See resolve_output_spec for how the three combine.

Every field is optional, and an entirely empty spec is meaningful: it asks for a final output without constraining its shape.

Fields

format: Option<String>

An opaque label for the shape, carried to the model and recorded beside the result. "markdown", "json", "a2ui", and "application/vnd.acme.report+xml" are all equally valid and equally uninterpreted. Consumers that render differently per format (a browser UI, say) match on this string; the engine never does.

instructions: Option<String>

Free-form guidance folded into the submit_output tool description and the output stage’s system prompt. This is where a format that the model has never seen gets explained.

example: Option<String>

A literal sample shown to the model verbatim. The most effective lever for an unusual format, and the reason one needs no code support.

schema: Option<Value>

A JSON Schema describing the answer’s shape. When present, a submission is parsed as JSON and validated against it, and a failure is refused back to the model so it can correct itself.

Separate from format because they answer different questions. format = "json" asks “does this parse as JSON”; a schema asks “does the parsed document have the fields I need”. A format check comes free for the handful of formats the engine can parse; shape is only ever checked when someone writes a schema down.

validator: Option<String>

A .rhai script that decides whether an answer is valid, as a path relative to the blueprint directory.

For a format the engine cannot parse and a shape a JSON Schema cannot describe. The script defines fn validate(content) and returns () when the answer is fine or a string saying what is wrong; the string goes back to the agent as the same refusal a schema failure produces.

Written for the format it accompanies, so a caller who overrides the format retires it along with the schema.

Implementations

impl OutputSpec

pub fn is_empty(&self) -> bool

Whether this spec constrains anything at all. An empty spec still asks for an output, so this is about wording the request, not skipping it.

Trait Implementations

impl Clone for OutputSpec

fn clone(&self) -> OutputSpec

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for OutputSpec

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

Formats the value using the given formatter.

impl Default for OutputSpec

fn default() -> OutputSpec

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for OutputSpec

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for OutputSpec

impl PartialEq for OutputSpec

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for OutputSpec

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 OutputSpec