s1

#[derive(Choice)]
#[s1(instructions = "Which team should handle this ticket?")]
enum Department {
    #[s1("Payment, invoice, refund, or subscription issues")]
    Billing,
    #[s1("Bugs, errors, or integration problems")]
    Technical,
    #[s1("Pricing or plan questions")]
    Sales,
}

#[derive(Score)]
#[s1(instructions = "How frustrated does the customer appear?")]
enum Frustration {
    #[s1("Calm, just stating facts")] Calm,
    #[s1("Frustrated but civil")]     Annoyed,
    #[s1("Angry, strong language")]   Furious,
}

#[derive(Questions)]
struct Triage {
    department: Department,
    frustration: Frustration,
    #[s1(noul = "The message conveys urgency or time pressure")]
    urgent: bool,
}

let t: Answers<Triage> = s1.ask::<Triage>(&ticket).await?;

match t.department.gate(Policy::act(0.85).review(0.6)) {
    Verdict::Act(Department::Billing) => billing_queue.push(ticket),
    Verdict::Act(Department::Technical) => eng_queue.push(ticket),
    Verdict::Act(Department::Sales) => sales_queue.push(ticket),
    Verdict::Review(guess) => human_queue.push_with_hint(ticket, guess),
    Verdict::Escalate => llm_fallback(ticket).await?,
}

use s1::{Choice, Policy, Questions, S1, Score, Verdict};
use s1_test::{FakeClient, Script};

let fake = FakeClient::new().on::<Triage>(|_state| {
    Script::new()
        .choice(Department::Billing, 0.91)
        .score::<Frustration>(1.2)
        .noul("urgent", 0.97)
});

let s1 = S1::new(fake);
let t = s1.ask::<Triage>(&ticket).await?;

assert_eq!(
    t.department.gate(Policy::act(0.85).review(0.6)),
    Verdict::Act(Department::Billing)
);
assert_eq!(t.frustration.nearest(), Frustration::Annoyed);
assert!((t.urgent.p() - 0.97).abs() < 1e-9);

use s1::S1;
use typesafe_rs::Client;

let client = Client::from_env()?;
let s1 = S1::new(client);
let t = s1.ask::<Triage>(&ticket).await?;

let policy = Policy::act(0.85)
    .review(0.6)
    .for_variant(Department::Billing, 0.9, 0.7);

match t.department.gate(&policy) {
    Verdict::Act(dept) => route(dept),
    Verdict::Review(guess) => review_queue.push(guess),
    Verdict::Escalate => fallback().await?,
}

match t.urgent.gate(NoulPolicy::new(0.9, 0.15, 0.35, 0.65)) {
    Verdict::Act(true) => page_oncall(),
    Verdict::Act(false) => (),
    Verdict::Review(_) => human_queue.push(ticket),
    Verdict::Escalate => fallback().await?,
}