Struct Choice 

#[non_exhaustive]
pub struct Choice {
    pub instructions: Option<Content>,
    pub criteria: IndexMap<String, Option<Content>>,
}

Picks one option from a set you define. The answer names the most probable option and gives the probability of each.

The options keep the order they are given in. The API accepts up to 255 of them.

use typesafe_jev::Choice;

let department = Choice::new("Which team should handle this?", [
    ("billing", "Payments, invoicing, refunds"),
    ("technical", "Bugs, outages, integrations"),
])
.option("sales", "Pricing, upgrades, new accounts");
assert_eq!(department.criteria.keys().collect::<Vec<_>>(), ["billing", "technical", "sales"]);

// Options whose names say it all need no description.
let tone = Choice::labels("What is the tone?", ["calm", "frustrated", "angry"]);
assert_eq!(tone.criteria["calm"], None);

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.

instructions: Option<Content>

What the model should decide.

criteria: IndexMap<String, Option<Content>>

Each option and its description, in order. None (JSON null) is an option that needs no more detail than its name.

Implementations

impl Choice

pub fn new<N, D>( instructions: impl Into<Content>, options: impl IntoIterator<Item = (N, D)>, ) -> Self

where N: Into<String>, D: Into<Content>,

A choice between described options.

Examples found in repository

examples/ask.rs (lines 31-38)

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 labels<N: Into<String>>( instructions: impl Into<Content>, names: impl IntoIterator<Item = N>, ) -> Self

A choice between options that their names describe well enough.

pub fn option( self, name: impl Into<String>, description: impl Into<Content>, ) -> Self

Adds a described option, or replaces the description of one that is there.

pub fn label(self, name: impl Into<String>) -> Self

Adds an option with no description.

Trait Implementations

impl Clone for Choice

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 Choice

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Choice

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<Choice> for Question

fn from(question: Choice) -> Self

Converts to this type from the input type.

impl PartialEq for Choice

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for Choice

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 Choice