Struct StructuredOutput 

pub struct StructuredOutput {
    pub raw: String,
    pub parsed: Option<Value>,
    pub validation_result: ValidationResult,
}

Structured output result with validation.

Wraps the raw response from the AI model with parsed, validated, and formatted data.

Fields

raw: String

Raw response content as string

parsed: Option<Value>

Parsed JSON data (None if parsing failed)

validation_result: ValidationResult

Validation result (always populated)

Implementations

impl StructuredOutput

pub fn from_response_unvalidated(content: impl Into<String>) -> Self

Create a structured output from raw content without validation.

Arguments

• content - Raw response content

Returns: A StructuredOutput instance with parsed data but without validation.

Use .validate() method to add validation after creation.

Example:

use ai_lib_rust::structured::{StructuredOutput, OutputValidator};
use serde_json::json;

let schema = json!({"type": "object", "properties": {"name": {"type": "string"}}});
let validator = OutputValidator::lenient(schema);

let mut output = StructuredOutput::from_response_unvalidated(
    r#"{"name": "Alice"}"#
);

output.validate(&validator);
assert!(output.is_valid());

pub fn validate(&mut self, validator: &OutputValidator)

Validate this output against a schema.

Arguments

• validator - The validator to use

Updates the validation_result with the schema check result.

Example:

use ai_lib_rust::structured::{StructuredOutput, OutputValidator};
use serde_json::json;

let schema = json!({"type": "object", "properties": {"name": {"type": "string"}}});
let validator = OutputValidator::lenient(schema);

let mut output = StructuredOutput::from_response_unvalidated(r#"{"name": "Alice"}"#);
output.validate(&validator);

pub fn from_response( content: impl Into<String>, validator: &OutputValidator, ) -> Self

Create a structured output from raw content with validation.

Arguments

• content - Raw response content
• validator - Validator to check the content

Returns: A StructuredOutput instance with parsed and validated data.

Example:

use ai_lib_rust::structured::{StructuredOutput, OutputValidator};
use serde_json::json;

let schema = json!({"type": "object", "properties": {"name": {"type": "string"}}});
let validator = OutputValidator::lenient(schema);

let output = StructuredOutput::from_response(
    r#"{"name": "Alice"}"#,
    &validator
);

assert!(output.is_valid());

pub fn is_valid(&self) -> bool

Check if the output is valid.

Returns true if:

1. JSON parsing succeeded
2. Validation passed (if validation was performed)

pub fn data(&self) -> Value

Get the best available data representation.

Priority:

1. Validated data (if validation passed)
2. Parsed data (if available)
3. Raw content as string

pub fn raw(&self) -> &str

Get the raw response content.

pub fn parsed(&self) -> Option<&Value>

Get the parsed JSON data (if parsing succeeded).

pub fn validation_result(&self) -> &ValidationResult

Get the validation result.

pub fn errors(&self) -> Vec<ValidationError>

Get validation errors if validation failed.

pub fn error_messages(&self) -> Vec<String>

Get error messages as strings.

Trait Implementations

impl Clone for StructuredOutput

fn clone(&self) -> StructuredOutput

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for StructuredOutput

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

Formats the value using the given formatter.