feat(libsy): support ordered cutoffs for N-way decision routing

Signed-off-by: nachiketb <nachiketb@nvidia.com>

Author: nachiketb-nvidia

crates/libsy-llm-client/src/run.rs

@@ -1305,6 +1305,7 @@ mod tests {
                 LlmClassifierConfig::Capability {
                     config: TaskClassifierConfig {
                         judge: CapabilityJudgeConfig::Decision(DecisionJudgeConfig {
+                            policy: None,
                             cutoff: 0.4,
                             instructions: None,
                             candidates: BTreeMap::from([

crates/libsy/src/algorithms/llm_class.rs

@@ -13,7 +13,7 @@ use switchyard_protocol::{Category, ContentBlock, Message, Role};
 
 mod decision;
 use decision::DecisionClassifier;
-pub use decision::DecisionJudgeConfig;
+pub use decision::{DecisionJudgeConfig, DecisionPolicy, DecisionRule};
 
 use super::escalation;
 use super::fall_through::FallThrough;
@@ -1294,6 +1294,7 @@ mod tests {
 
         let settings = DecisionJudgeConfig {
             cutoff: 0.4,
+            policy: None,
             instructions: None,
             candidates: BTreeMap::from([
                 ("a".into(), "capable".into()),
@@ -1306,6 +1307,21 @@ mod tests {
                 "summaries": [],
             }),
         };
+        let ordered_policy = DecisionPolicy {
+            rules: vec![
+                DecisionRule {
+                    score: "a".into(),
+                    target: "a".into(),
+                    cutoff: 0.6,
+                },
+                DecisionRule {
+                    score: "c".into(),
+                    target: "c".into(),
+                    cutoff: 0.2,
+                },
+            ],
+            fallback: "b".into(),
+        };
         let mut request = classify_session_request();
         request.llm_request.messages.push(Message {
             role: Role::Assistant,
@@ -1344,8 +1360,19 @@ mod tests {
             ("provider error", 0.0, false, None),
             ("dropped reply", 0.0, true, Some("capable")),
             ("missing candidate", 0.0, true, None),
+            ("ordered first", 0.65, true, Some("capable")),
+            ("ordered second", 0.6, false, Some("third")),
+            ("ordered fallback", 0.6, false, Some("efficient")),
+            ("ordered no distribution", 0.0, true, Some("efficient")),
+            ("ordered provider error", 0.0, true, Some("efficient")),
+            ("ordered provider error", 0.0, false, None),
+            ("ordered invalid", f64::NAN, true, Some("efficient")),
         ] {
             let mut config = settings.clone();
+            let ordered = name.starts_with("ordered");
+            if ordered {
+                config.policy = Some(ordered_policy.clone());
+            }
             if name == "missing candidate" {
                 config.candidates.remove("a");
             }
@@ -1378,15 +1405,15 @@ mod tests {
                     calls.fetch_add(1, Ordering::SeqCst);
                     assert_eq!(call.model, "judge");
                     assert_eq!(call.request.model, Some("judge".into()));
-                    assert_eq!(
-                        call.request.context,
-                        json!({
-                            "task": expected_task,
-                            "candidates": ["a", "b", "c"],
-                            "comparison": {"capable": "a", "efficient": "b"},
-                            "evidence": settings.evidence,
-                        })
-                    );
+                    let mut context = json!({
+                        "task": expected_task,
+                        "candidates": ["a", "b", "c"],
+                        "evidence": settings.evidence,
+                    });
+                    if !ordered {
+                        context["comparison"] = json!({"capable": "a", "efficient": "b"});
+                    }
+                    assert_eq!(call.request.context, context);
                     assert_eq!(call.request.questions.len(), 1);
                     let question = &call.request.questions["route"];
                     let switchyard_protocol::DecisionKind::Choice { options } = &question.kind
@@ -1398,16 +1425,20 @@ mod tests {
                             .iter()
                             .map(|option| option.id.as_str())
                             .collect::<Vec<_>>(),
-                        ["advantage", "no_advantage"]
+                        if ordered {
+                            vec!["a", "b", "c"]
+                        } else {
+                            vec!["advantage", "no_advantage"]
+                        }
                     );
                     if let Some(instructions) = override_instructions {
                         assert_eq!(&question.instructions, instructions);
-                    } else {
+                    } else if !ordered {
                         for key in ["setting", "evidence", "comparison", "boundary", "policy"] {
                             assert!(question.instructions[key].as_str().is_some());
                         }
                     }
-                    if name == "provider error" {
+                    if name.ends_with("provider error") {
                         return call
                             .respond(std::future::ready(Err(LibsyError::client_call(
                                 "judge",
@@ -1423,8 +1454,16 @@ mod tests {
                         DecisionValue::Boolean(BooleanEstimate::Value(true))
                     } else {
                         DecisionValue::Choice {
-                            selected: "no_advantage".into(),
-                            probabilities: (name != "no distribution").then(|| {
+                            selected: if ordered { "b" } else { "no_advantage" }.into(),
+                            probabilities: (!name.ends_with("no distribution")).then(|| {
+                                if ordered {
+                                    let third = if name == "ordered fallback" { 0.2 } else { 0.3 };
+                                    return BTreeMap::from([
+                                        ("a".into(), Probability(score)),
+                                        ("b".into(), Probability(1.0 - score - third)),
+                                        ("c".into(), Probability(third)),
+                                    ]);
+                                }
                                 BTreeMap::from([
                                     ("advantage".into(), Probability(score)),
                                     ("no_advantage".into(), Probability(1.0 - score)),
@@ -1452,7 +1491,16 @@ mod tests {
                     .await
                 }
             };
-            let models = Arc::new(RuntimeModels::new(runtime_models()));
+            let mut runtime = runtime_models();
+            if ordered {
+                runtime.remove(&Category::Capable);
+                runtime.remove(&Category::Efficient);
+                runtime
+                    .get_mut(&Category::Any)
+                    .unwrap()
+                    .push("third".into());
+            }
+            let models = Arc::new(RuntimeModels::new(runtime));
             let result = drive(router.clone(), request.clone(), models.clone(), &serve).await;
             assert_eq!(
                 calls.load(Ordering::SeqCst),
@@ -1480,14 +1528,19 @@ mod tests {
                 .metadata
                 .and_then(|metadata| metadata.evidence)
                 .expect("routing evidence");
-            if matches!(name, "above" | "equal" | "below") {
+            if matches!(
+                name,
+                "ordered first" | "ordered second" | "ordered fallback"
+            ) {
+                assert_eq!(evidence["verdict"], "ordered_cutoffs");
+            } else if matches!(name, "above" | "equal" | "below") {
                 assert_eq!(evidence["source"], "decision_classifier");
                 assert_eq!(evidence["verdict"], "relative_advantage");
                 assert_eq!(evidence["threshold"], settings.cutoff);
                 assert_eq!(evidence["score"], score);
             } else {
                 let reason = match name {
-                    "provider error" => "client_error",
+                    name if name.ends_with("provider error") => "client_error",
                     "dropped reply" => "call_error",
                     _ => "invalid_verdict",
                 };
@@ -1504,9 +1557,18 @@ mod tests {
                 "affinity should skip the judge: {name}"
             );
         }
-        for cutoff in [-0.1, 1.1, f64::NAN] {
+        for (cutoff, ordered) in [-0.1, 1.1, f64::NAN]
+            .into_iter()
+            .flat_map(|cutoff| [(cutoff, false), (cutoff, true)])
+        {
             let mut config = settings.clone();
-            config.cutoff = cutoff;
+            if ordered {
+                let mut policy = ordered_policy.clone();
+                policy.rules[0].cutoff = cutoff;
+                config.policy = Some(policy);
+            } else {
+                config.cutoff = cutoff;
+            }
             assert!(
                 LlmTaskClassifier::new(LlmClassifierConfig::Capability {
                     config: TaskClassifierConfig {
@@ -1517,6 +1579,18 @@ mod tests {
                 .is_err()
             );
         }
+        for field in ["score", "target", "fallback", "rules"] {
+            let mut config = settings.clone();
+            let mut policy = ordered_policy.clone();
+            match field {
+                "score" => policy.rules[0].score = "missing".into(),
+                "target" => policy.rules[0].target = "missing".into(),
+                "fallback" => policy.fallback = "missing".into(),
+                _ => policy.rules.clear(),
+            }
+            config.policy = Some(policy);
+            assert!(config.validate().is_err());
+        }
         let mut duplicate = settings.clone();
         duplicate
             .candidates