Enum Question 

pub enum Question {
    Noul {
        instructions: Entry,
        criteria: Option<NoulCriteria>,
    },
    Choice {
        instructions: Entry,
        criteria: IndexMap<String, Entry>,
    },
    Score {
        instructions: Entry,
        criteria: Vec<Entry>,
    },
}

A typed System One question.

Build with Question::noul, Question::choice, and Question::score. Choice needs at least two options; Score needs at least two levels. Validation runs before the request is sent.

Examples

use typesafe_rs::Question;

let urgent = Question::noul("Does this convey urgency?")
    .when_true("Explicitly time-sensitive")
    .when_false("No time pressure");
let team = Question::choice("Which team?")
    .option("billing", "Payments")
    .option("technical", "Bugs");
let mood = Question::score("How frustrated?")
    .level("Calm")
    .level("Frustrated")
    .level("Very angry");

Variants

Noul

Yes/no question; the answer is a probability in [0, 1].

Fields

instructions: Entry

The question to evaluate.

criteria: Option<NoulCriteria>

Optional descriptions of the yes and no outcomes.

Choice

Select one named option from a set.

Fields

instructions: Entry

What the model should decide.

criteria: IndexMap<String, Entry>

Option labels mapped to descriptions (null if undescribed).

Score

Rate the state against an ordered rubric.

Fields

instructions: Entry

What the model should rate.

criteria: Vec<Entry>

Level descriptions; index is the integer score.

Implementations

impl Question

pub fn noul(instructions: impl Into<Entry>) -> Self

Build a Noul question.

Examples found in repository

examples/blocking.rs (line 27)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let rt = tokio::runtime::Builder::new_multi_thread()
        .enable_all()
        .build()?;
    let mock = rt.block_on(MockServer::start());
    mock.on_system_one().respond(json!({
        "urgent": noul(0.91),
    }));

    let client = ClientConfig::new()
        .api_key("test")
        .base_url(mock.url())
        .build_blocking()?;

    let response = client.system_one(
        "Help! My payouts have been failing for 3 days.",
        questions! { "urgent" => Question::noul("Does this convey urgency?") },
    )?;
    println!("urgent noul = {:?}", response.noul("urgent"));

    drop(client);
    drop(mock);
    drop(rt);
    Ok(())
}

examples/quickstart.rs (line 31)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mock = MockServer::start().await;
    mock.on_system_one().respond(json!({
        "urgent": noul(0.97),
    }));

    let client = Client::new(ClientConfig {
        api_key: Some("test".into()),
        base_url: Some(mock.url()),
        default_model: Some("jev-latest".into()),
        ..ClientConfig::default()
    })?;

    let response = client
        .system_one(
            "Help! My payouts have been failing for 3 days.",
            questions! {
                "urgent" => Question::noul("Does this convey urgency?")
                    .when_true("Explicitly time-sensitive")
                    .when_false("No time pressure"),
            },
        )
        .await?;

    println!("urgent noul = {:?}", response.noul("urgent"));
    println!("request id  = {:?}", response.meta.request_id);
    Ok(())
}

examples/triage.rs (line 29)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mock = MockServer::start().await;
    mock.on_system_one().respond(json!({
        "urgent": noul(0.97),
        "team": choice("technical", 0.82),
        "frustration": score(1.6, 0.78),
    }));

    let client = ClientConfig::new()
        .api_key("test")
        .base_url(mock.url())
        .build()?;

    let response = client
        .system_one(
            "Help! My payouts have been failing for 3 days.",
            questions! {
                "urgent" => Question::noul("Does this convey urgency?")
                    .when_true("Explicitly time-sensitive")
                    .when_false("No time pressure"),
                "team" => Question::choice("Which team should handle this?")
                    .option("billing", "Payments, invoicing, refunds")
                    .option("technical", "Bugs, outages, integrations")
                    .option("sales", "Pricing, upgrades, new accounts"),
                "frustration" => Question::score("How frustrated is the customer?")
                    .level("Calm")
                    .level("Frustrated")
                    .level("Very angry"),
            },
        )
        .await?;

    println!("urgent      = {:?}", response.noul("urgent"));
    println!(
        "team        = {:?}",
        response.choice("team").map(|c| c.choice)
    );
    println!(
        "frustration = {:?}",
        response.score("frustration").map(|s| s.score)
    );
    Ok(())
}

pub fn choice(instructions: impl Into<Entry>) -> Self

Build a Choice question with no options yet.

Examples found in repository

examples/triage.rs (line 32)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mock = MockServer::start().await;
    mock.on_system_one().respond(json!({
        "urgent": noul(0.97),
        "team": choice("technical", 0.82),
        "frustration": score(1.6, 0.78),
    }));

    let client = ClientConfig::new()
        .api_key("test")
        .base_url(mock.url())
        .build()?;

    let response = client
        .system_one(
            "Help! My payouts have been failing for 3 days.",
            questions! {
                "urgent" => Question::noul("Does this convey urgency?")
                    .when_true("Explicitly time-sensitive")
                    .when_false("No time pressure"),
                "team" => Question::choice("Which team should handle this?")
                    .option("billing", "Payments, invoicing, refunds")
                    .option("technical", "Bugs, outages, integrations")
                    .option("sales", "Pricing, upgrades, new accounts"),
                "frustration" => Question::score("How frustrated is the customer?")
                    .level("Calm")
                    .level("Frustrated")
                    .level("Very angry"),
            },
        )
        .await?;

    println!("urgent      = {:?}", response.noul("urgent"));
    println!(
        "team        = {:?}",
        response.choice("team").map(|c| c.choice)
    );
    println!(
        "frustration = {:?}",
        response.score("frustration").map(|s| s.score)
    );
    Ok(())
}

pub fn score(instructions: impl Into<Entry>) -> Self

Build a Score question with no levels yet.

Examples found in repository

examples/triage.rs (line 36)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mock = MockServer::start().await;
    mock.on_system_one().respond(json!({
        "urgent": noul(0.97),
        "team": choice("technical", 0.82),
        "frustration": score(1.6, 0.78),
    }));

    let client = ClientConfig::new()
        .api_key("test")
        .base_url(mock.url())
        .build()?;

    let response = client
        .system_one(
            "Help! My payouts have been failing for 3 days.",
            questions! {
                "urgent" => Question::noul("Does this convey urgency?")
                    .when_true("Explicitly time-sensitive")
                    .when_false("No time pressure"),
                "team" => Question::choice("Which team should handle this?")
                    .option("billing", "Payments, invoicing, refunds")
                    .option("technical", "Bugs, outages, integrations")
                    .option("sales", "Pricing, upgrades, new accounts"),
                "frustration" => Question::score("How frustrated is the customer?")
                    .level("Calm")
                    .level("Frustrated")
                    .level("Very angry"),
            },
        )
        .await?;

    println!("urgent      = {:?}", response.noul("urgent"));
    println!(
        "team        = {:?}",
        response.choice("team").map(|c| c.choice)
    );
    println!(
        "frustration = {:?}",
        response.score("frustration").map(|s| s.score)
    );
    Ok(())
}

pub fn when_true(self, description: impl Into<Entry>) -> Self

Describe the yes outcome of a Noul question.

No-op if this is not a Noul question.

Examples found in repository

examples/quickstart.rs (line 32)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mock = MockServer::start().await;
    mock.on_system_one().respond(json!({
        "urgent": noul(0.97),
    }));

    let client = Client::new(ClientConfig {
        api_key: Some("test".into()),
        base_url: Some(mock.url()),
        default_model: Some("jev-latest".into()),
        ..ClientConfig::default()
    })?;

    let response = client
        .system_one(
            "Help! My payouts have been failing for 3 days.",
            questions! {
                "urgent" => Question::noul("Does this convey urgency?")
                    .when_true("Explicitly time-sensitive")
                    .when_false("No time pressure"),
            },
        )
        .await?;

    println!("urgent noul = {:?}", response.noul("urgent"));
    println!("request id  = {:?}", response.meta.request_id);
    Ok(())
}

examples/triage.rs (line 30)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mock = MockServer::start().await;
    mock.on_system_one().respond(json!({
        "urgent": noul(0.97),
        "team": choice("technical", 0.82),
        "frustration": score(1.6, 0.78),
    }));

    let client = ClientConfig::new()
        .api_key("test")
        .base_url(mock.url())
        .build()?;

    let response = client
        .system_one(
            "Help! My payouts have been failing for 3 days.",
            questions! {
                "urgent" => Question::noul("Does this convey urgency?")
                    .when_true("Explicitly time-sensitive")
                    .when_false("No time pressure"),
                "team" => Question::choice("Which team should handle this?")
                    .option("billing", "Payments, invoicing, refunds")
                    .option("technical", "Bugs, outages, integrations")
                    .option("sales", "Pricing, upgrades, new accounts"),
                "frustration" => Question::score("How frustrated is the customer?")
                    .level("Calm")
                    .level("Frustrated")
                    .level("Very angry"),
            },
        )
        .await?;

    println!("urgent      = {:?}", response.noul("urgent"));
    println!(
        "team        = {:?}",
        response.choice("team").map(|c| c.choice)
    );
    println!(
        "frustration = {:?}",
        response.score("frustration").map(|s| s.score)
    );
    Ok(())
}

pub fn when_false(self, description: impl Into<Entry>) -> Self

Describe the no outcome of a Noul question.

No-op if this is not a Noul question.

Examples found in repository

examples/quickstart.rs (line 33)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mock = MockServer::start().await;
    mock.on_system_one().respond(json!({
        "urgent": noul(0.97),
    }));

    let client = Client::new(ClientConfig {
        api_key: Some("test".into()),
        base_url: Some(mock.url()),
        default_model: Some("jev-latest".into()),
        ..ClientConfig::default()
    })?;

    let response = client
        .system_one(
            "Help! My payouts have been failing for 3 days.",
            questions! {
                "urgent" => Question::noul("Does this convey urgency?")
                    .when_true("Explicitly time-sensitive")
                    .when_false("No time pressure"),
            },
        )
        .await?;

    println!("urgent noul = {:?}", response.noul("urgent"));
    println!("request id  = {:?}", response.meta.request_id);
    Ok(())
}

examples/triage.rs (line 31)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mock = MockServer::start().await;
    mock.on_system_one().respond(json!({
        "urgent": noul(0.97),
        "team": choice("technical", 0.82),
        "frustration": score(1.6, 0.78),
    }));

    let client = ClientConfig::new()
        .api_key("test")
        .base_url(mock.url())
        .build()?;

    let response = client
        .system_one(
            "Help! My payouts have been failing for 3 days.",
            questions! {
                "urgent" => Question::noul("Does this convey urgency?")
                    .when_true("Explicitly time-sensitive")
                    .when_false("No time pressure"),
                "team" => Question::choice("Which team should handle this?")
                    .option("billing", "Payments, invoicing, refunds")
                    .option("technical", "Bugs, outages, integrations")
                    .option("sales", "Pricing, upgrades, new accounts"),
                "frustration" => Question::score("How frustrated is the customer?")
                    .level("Calm")
                    .level("Frustrated")
                    .level("Very angry"),
            },
        )
        .await?;

    println!("urgent      = {:?}", response.noul("urgent"));
    println!(
        "team        = {:?}",
        response.choice("team").map(|c| c.choice)
    );
    println!(
        "frustration = {:?}",
        response.score("frustration").map(|s| s.score)
    );
    Ok(())
}

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

Add a named option to a Choice question.

No-op if this is not a Choice question.

Examples found in repository

examples/triage.rs (line 33)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mock = MockServer::start().await;
    mock.on_system_one().respond(json!({
        "urgent": noul(0.97),
        "team": choice("technical", 0.82),
        "frustration": score(1.6, 0.78),
    }));

    let client = ClientConfig::new()
        .api_key("test")
        .base_url(mock.url())
        .build()?;

    let response = client
        .system_one(
            "Help! My payouts have been failing for 3 days.",
            questions! {
                "urgent" => Question::noul("Does this convey urgency?")
                    .when_true("Explicitly time-sensitive")
                    .when_false("No time pressure"),
                "team" => Question::choice("Which team should handle this?")
                    .option("billing", "Payments, invoicing, refunds")
                    .option("technical", "Bugs, outages, integrations")
                    .option("sales", "Pricing, upgrades, new accounts"),
                "frustration" => Question::score("How frustrated is the customer?")
                    .level("Calm")
                    .level("Frustrated")
                    .level("Very angry"),
            },
        )
        .await?;

    println!("urgent      = {:?}", response.noul("urgent"));
    println!(
        "team        = {:?}",
        response.choice("team").map(|c| c.choice)
    );
    println!(
        "frustration = {:?}",
        response.score("frustration").map(|s| s.score)
    );
    Ok(())
}

pub fn level(self, description: impl Into<Entry>) -> Self

Append a rubric level to a Score question.

No-op if this is not a Score question.

Examples found in repository

examples/triage.rs (line 37)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mock = MockServer::start().await;
    mock.on_system_one().respond(json!({
        "urgent": noul(0.97),
        "team": choice("technical", 0.82),
        "frustration": score(1.6, 0.78),
    }));

    let client = ClientConfig::new()
        .api_key("test")
        .base_url(mock.url())
        .build()?;

    let response = client
        .system_one(
            "Help! My payouts have been failing for 3 days.",
            questions! {
                "urgent" => Question::noul("Does this convey urgency?")
                    .when_true("Explicitly time-sensitive")
                    .when_false("No time pressure"),
                "team" => Question::choice("Which team should handle this?")
                    .option("billing", "Payments, invoicing, refunds")
                    .option("technical", "Bugs, outages, integrations")
                    .option("sales", "Pricing, upgrades, new accounts"),
                "frustration" => Question::score("How frustrated is the customer?")
                    .level("Calm")
                    .level("Frustrated")
                    .level("Very angry"),
            },
        )
        .await?;

    println!("urgent      = {:?}", response.noul("urgent"));
    println!(
        "team        = {:?}",
        response.choice("team").map(|c| c.choice)
    );
    println!(
        "frustration = {:?}",
        response.score("frustration").map(|s| s.score)
    );
    Ok(())
}

Trait Implementations

impl Clone for Question

fn clone(&self) -> Question

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Question

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Question

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Question

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for Question

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 Question