Struct Response 

#[non_exhaustive]
pub struct Response {
    pub model: String,
    pub answers: IndexMap<String, Answer>,
    pub usage: TokenUsage,
}

What one request came back with: an Answer per question, under the id the question had.

use typesafe_jev::{Answer, Response};

let response: Response = serde_json::from_str(r#"{
    "model": "jev-1.13.0",
    "answers": {
        "is_urgent": {"type": "noul", "noul": 0.95},
        "department": {"type": "choice", "choice": "billing", "confidence": 0.81,
                       "probabilities": {"billing": 0.88, "technical": 0.12, "sales": 0.0}}
    },
    "usage": {"input_tokens": 318, "output_tokens": 34}
}"#)?;

assert_eq!(response.noul("is_urgent").map(|answer| answer.noul), Some(0.95));
let department = response.choice("department").expect("asked as a choice");
assert_eq!((department.choice.as_str(), department.probabilities["technical"]), ("billing", 0.12));
assert!(response.score("department").is_none(), "it is there, but it is not a score");
assert!(matches!(response.answers["is_urgent"], Answer::Noul(_)));

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

model: String

The model that performed the evaluation: the release that an alias like jev-latest stood for.

answers: IndexMap<String, Answer>

One answer per question, keyed and ordered as the API returned them.

usage: TokenUsage

The tokens this request used.

Implementations

impl Response

pub fn noul(&self, id: &str) -> Option<&NoulAnswer>

The answer under id, if there is one and it answers a Noul.

Examples found in repository

examples/ask.rs (line 68)

fn main() -> Result<(), Error> {
    let client = Client::from_env(Config::default())?;

    let ticket = Ticket {
        customer_plan: "business",
        message: "Hi, I've been trying to connect my Stripe account for 3 days and the integration keeps failing. \
                  I'm losing sales. Please help ASAP.",
    };
    let questions = Questions::new()
        .with(
            "department",
            Choice::new(
                "Which team should handle the `message`?",
                [
                    ("billing", "Payment or subscription issues"),
                    ("technical", "Bugs or integration problems"),
                    ("sales", "Pricing or account questions"),
                ],
            ),
        )
        .with(
            "frustration",
            Score::new(
                "How frustrated the customer appears",
                ["Calm, just stating facts", "Frustrated but civil", "Very angry, strong language"],
            ),
        )
        .with("is_urgent", Noul::new("The message conveys urgency or time-sensitivity"));

    let response = match client.ask(&ticket, &questions) {
        Ok(response) => response,
        // Too much state for one request: a real caller would split it and ask again.
        Err(Error::TokenLimit(message)) => {
            eprintln!("request too large: {message}");
            return Ok(());
        }
        Err(other) => return Err(other),
    };

    if let Some(department) = response.choice("department") {
        println!("department: {} (confidence {:.2})", department.choice, department.confidence);
        for (option, probability) in &department.probabilities {
            println!("  {option}: {probability:.2}");
        }
    }
    if let Some(frustration) = response.score("frustration") {
        println!("frustration: {:.2} of {} (confidence {:.2})", frustration.score, frustration.legend.len() - 1, frustration.confidence);
    }
    if let Some(urgent) = response.noul("is_urgent") {
        println!("urgent: p={:.2}", urgent.noul);
    }

    let usage = client.usage();
    println!(
        "{}: {} request(s), {} retries, {} input tokens, ~${:.6}",
        response.model,
        usage.requests(),
        usage.retries(),
        usage.input_tokens(),
        usage.cost_usd()
    );
    Ok(())
}

pub fn choice(&self, id: &str) -> Option<&ChoiceAnswer>

The answer under id, if there is one and it answers a Choice.

Examples found in repository

examples/ask.rs (line 59)

fn main() -> Result<(), Error> {
    let client = Client::from_env(Config::default())?;

    let ticket = Ticket {
        customer_plan: "business",
        message: "Hi, I've been trying to connect my Stripe account for 3 days and the integration keeps failing. \
                  I'm losing sales. Please help ASAP.",
    };
    let questions = Questions::new()
        .with(
            "department",
            Choice::new(
                "Which team should handle the `message`?",
                [
                    ("billing", "Payment or subscription issues"),
                    ("technical", "Bugs or integration problems"),
                    ("sales", "Pricing or account questions"),
                ],
            ),
        )
        .with(
            "frustration",
            Score::new(
                "How frustrated the customer appears",
                ["Calm, just stating facts", "Frustrated but civil", "Very angry, strong language"],
            ),
        )
        .with("is_urgent", Noul::new("The message conveys urgency or time-sensitivity"));

    let response = match client.ask(&ticket, &questions) {
        Ok(response) => response,
        // Too much state for one request: a real caller would split it and ask again.
        Err(Error::TokenLimit(message)) => {
            eprintln!("request too large: {message}");
            return Ok(());
        }
        Err(other) => return Err(other),
    };

    if let Some(department) = response.choice("department") {
        println!("department: {} (confidence {:.2})", department.choice, department.confidence);
        for (option, probability) in &department.probabilities {
            println!("  {option}: {probability:.2}");
        }
    }
    if let Some(frustration) = response.score("frustration") {
        println!("frustration: {:.2} of {} (confidence {:.2})", frustration.score, frustration.legend.len() - 1, frustration.confidence);
    }
    if let Some(urgent) = response.noul("is_urgent") {
        println!("urgent: p={:.2}", urgent.noul);
    }

    let usage = client.usage();
    println!(
        "{}: {} request(s), {} retries, {} input tokens, ~${:.6}",
        response.model,
        usage.requests(),
        usage.retries(),
        usage.input_tokens(),
        usage.cost_usd()
    );
    Ok(())
}

pub fn score(&self, id: &str) -> Option<&ScoreAnswer>

The answer under id, if there is one and it answers a Score.

Examples found in repository

examples/ask.rs (line 65)

fn main() -> Result<(), Error> {
    let client = Client::from_env(Config::default())?;

    let ticket = Ticket {
        customer_plan: "business",
        message: "Hi, I've been trying to connect my Stripe account for 3 days and the integration keeps failing. \
                  I'm losing sales. Please help ASAP.",
    };
    let questions = Questions::new()
        .with(
            "department",
            Choice::new(
                "Which team should handle the `message`?",
                [
                    ("billing", "Payment or subscription issues"),
                    ("technical", "Bugs or integration problems"),
                    ("sales", "Pricing or account questions"),
                ],
            ),
        )
        .with(
            "frustration",
            Score::new(
                "How frustrated the customer appears",
                ["Calm, just stating facts", "Frustrated but civil", "Very angry, strong language"],
            ),
        )
        .with("is_urgent", Noul::new("The message conveys urgency or time-sensitivity"));

    let response = match client.ask(&ticket, &questions) {
        Ok(response) => response,
        // Too much state for one request: a real caller would split it and ask again.
        Err(Error::TokenLimit(message)) => {
            eprintln!("request too large: {message}");
            return Ok(());
        }
        Err(other) => return Err(other),
    };

    if let Some(department) = response.choice("department") {
        println!("department: {} (confidence {:.2})", department.choice, department.confidence);
        for (option, probability) in &department.probabilities {
            println!("  {option}: {probability:.2}");
        }
    }
    if let Some(frustration) = response.score("frustration") {
        println!("frustration: {:.2} of {} (confidence {:.2})", frustration.score, frustration.legend.len() - 1, frustration.confidence);
    }
    if let Some(urgent) = response.noul("is_urgent") {
        println!("urgent: p={:.2}", urgent.noul);
    }

    let usage = client.usage();
    println!(
        "{}: {} request(s), {} retries, {} input tokens, ~${:.6}",
        response.model,
        usage.requests(),
        usage.retries(),
        usage.input_tokens(),
        usage.cost_usd()
    );
    Ok(())
}

Trait Implementations

impl Clone for Response

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Response

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Response

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Response

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for Response

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 Response