Skip to main content

switchyard_libsy/algorithms/
composite.rs

1// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
2// SPDX-License-Identifier: Apache-2.0
3
4//! Routing that stacks a judge over a stage router.
5//!
6//! The judge runs as a [`Processor`]: it sets configuration the stage router reads,
7//! and picks no target itself.
8
9use std::collections::HashMap;
10use std::sync::Arc;
11
12use async_trait::async_trait;
13use parking_lot::Mutex;
14
15use super::fall_through::FallThrough;
16use super::llm_class::{
17    CustomClassifierConfig, LlmClassifierConfig, LlmTaskClassifier, TaskClassifierConfig,
18};
19use super::stage::{StageRouterConfig, build_stage_route};
20use super::util::affinity::{ClassifyTrigger, evict_if_full, has_new_user_turn, retention_key};
21use super::util::stage::{PickerMode, Tier, fall_open_tier, set_fall_open};
22use crate::core::algorithm::{Algorithm, Driver, RoutingIdentity};
23use crate::core::classifier::{Classification, Classifier};
24use crate::core::processor::{Event, Processor};
25use crate::core::state::State;
26use crate::{LibsyError, Result};
27use switchyard_protocol::{Category, Request, Response};
28
29const COMPOSITE: &str = "composite";
30
31/// Sets the stage router's fall-open tier from a judge verdict.
32///
33/// Retains the tier per routing identity, so it survives requests that carry no
34/// session ID when `message_hash_fallback` is on. The retained tier is replayed
35/// into state on every request so the cascade below reads it.
36struct TierSetter {
37    judge: Arc<dyn Classifier>,
38    trigger: ClassifyTrigger,
39    message_hash_fallback: bool,
40    default_tier: Tier,
41    tiers: Mutex<HashMap<RoutingIdentity, Tier>>,
42}
43
44impl TierSetter {
45    fn tier_for(category: Option<Category>) -> Option<Tier> {
46        match category {
47            Some(Category::Capable) => Some(Tier::Capable),
48            Some(Category::Efficient) => Some(Tier::Efficient),
49            _ => None,
50        }
51    }
52
53    /// Two requests for one identity can both pass this and both judge, since a
54    /// judge call sits between here and [`retain`](Self::retain). The later wins.
55    fn is_due(&self, identity: Option<&RoutingIdentity>, state: &State, request: &Request) -> bool {
56        match self.trigger {
57            ClassifyTrigger::UserTurn => {
58                !request.llm_request.is_compaction
59                    && has_new_user_turn(&request.llm_request.messages)
60            }
61            // Unkeyed requests with no carried tier cannot be told apart, so every one
62            // is a new session.
63            ClassifyTrigger::NewSession => {
64                identity.is_none_or(|identity| !self.tiers.lock().contains_key(identity))
65                    && fall_open_tier(state).is_none()
66            }
67            // Rejected by the constructor, and only in the enum for the standalone route.
68            ClassifyTrigger::EveryRequest => true,
69        }
70    }
71
72    fn retain(&self, identity: RoutingIdentity, tier: Tier) {
73        let mut tiers = self.tiers.lock();
74        // A user turn re-decides, so it overwrites. A session keeps its first verdict,
75        // matching how affinity retains an assignment.
76        let writable = self.trigger == ClassifyTrigger::UserTurn || !tiers.contains_key(&identity);
77        if writable {
78            evict_if_full(&mut tiers);
79            tiers.insert(identity, tier);
80        }
81    }
82}
83
84#[async_trait]
85impl Processor for TierSetter {
86    async fn process(&self, state: &mut State, event: Event<'_>) -> Result<()> {
87        let Event::Request { request, driver } = event else {
88            return Ok(());
89        };
90        let identity = retention_key(request, self.message_hash_fallback);
91        if self.is_due(identity.as_ref(), state, request) {
92            let (classification, _) = self.judge.score(state, request, driver).await?;
93            if let Some(winner) = classification.argmax(false)?
94                && let Some(tier) = Self::tier_for(winner.category)
95            {
96                set_fall_open(state, tier);
97                if let Some(identity) = identity {
98                    self.retain(identity, tier);
99                }
100                return Ok(());
101            }
102            if self.trigger == ClassifyTrigger::NewSession
103                && let Some(identity) = identity.as_ref()
104            {
105                // A failed opening judgment is still the session's one judgment.
106                self.retain(identity.clone(), self.default_tier);
107            }
108        }
109        // Either not this request's turn or the judge had no verdict, so the last
110        // tier stands rather than dropping back to the picker default.
111        if let Some(tier) = identity
112            .and_then(|identity| self.tiers.lock().get(&identity).copied())
113            .or_else(|| fall_open_tier(state))
114        {
115            set_fall_open(state, tier);
116            driver.set_evidence_if_empty(serde_json::json!({"source": "retained"}));
117        }
118        Ok(())
119    }
120}
121
122/// Classifier settings for the composite router's retained tier.
123pub enum CompositeJudgeConfig {
124    /// Selects a tier from a capability verdict.
125    Capability(TaskClassifierConfig),
126    /// Selects a tier using a custom schema and policy, retaining the fallback on failure.
127    Custom(CustomClassifierConfig),
128}
129
130/// Runs a stage router with a tier the judge picks.
131pub struct CompositeRouter {
132    route: FallThrough,
133}
134
135impl CompositeRouter {
136    /// Builds two independent stage profiles selected by the judge.
137    ///
138    /// The judge's efficient tier selects `profile_0` and its capable tier `profile_1`.
139    /// Errors on a configuration either algorithm rejects and on `every_request`.
140    pub fn new(
141        judge: CompositeJudgeConfig,
142        mut profile_0: StageRouterConfig,
143        mut profile_1: StageRouterConfig,
144    ) -> Result<Self> {
145        for profile in [&mut profile_0, &mut profile_1] {
146            if profile.mode == PickerMode::CapableFirst {
147                profile.efficient_hold_turns.get_or_insert(-1);
148            }
149        }
150        let setter = Self::tier_setter(judge)?;
151        let reset_on_user_turn = setter.trigger == ClassifyTrigger::UserTurn;
152        let profiles = StageProfiles([
153            build_stage_route(profile_0, reset_on_user_turn)?,
154            build_stage_route(profile_1, reset_on_user_turn)?,
155        ]);
156        let route = FallThrough::new_with_state()
157            .with_name(COMPOSITE)
158            .with_processor(Arc::new(setter))
159            .with_classifier(Arc::new(profiles));
160        Ok(Self { route })
161    }
162
163    fn tier_setter(judge: CompositeJudgeConfig) -> Result<TierSetter> {
164        let (trigger, message_hash_fallback) = match &judge {
165            CompositeJudgeConfig::Capability(judge) => {
166                (judge.classify_trigger, judge.message_hash_fallback)
167            }
168            CompositeJudgeConfig::Custom(config) => {
169                (config.classify_trigger, config.message_hash_fallback)
170            }
171        };
172        if trigger == ClassifyTrigger::EveryRequest {
173            return Err(LibsyError::AlgorithmError {
174                message: "composite: classify_trigger must be user_turn or new_session".to_string(),
175            });
176        }
177        let judge: Arc<dyn Classifier> = match judge {
178            CompositeJudgeConfig::Capability(judge) => {
179                // Composite owns the trigger and retained verdict.
180                Arc::new(LlmTaskClassifier::new(LlmClassifierConfig::Capability {
181                    config: TaskClassifierConfig {
182                        classify_trigger: ClassifyTrigger::EveryRequest,
183                        message_hash_fallback: false,
184                        ..judge
185                    },
186                })?)
187            }
188            CompositeJudgeConfig::Custom(config) => {
189                LlmTaskClassifier::custom_classifier(&config, true)?
190            }
191        };
192        Ok(TierSetter {
193            judge,
194            trigger,
195            message_hash_fallback,
196            default_tier: Tier::Efficient,
197            tiers: Mutex::new(HashMap::new()),
198        })
199    }
200}
201
202struct StageProfiles([FallThrough; 2]);
203
204#[async_trait]
205impl Classifier for StageProfiles {
206    async fn score(
207        &self,
208        state: &mut State,
209        request: &mut Request,
210        driver: &Driver,
211    ) -> Result<(Classification, Option<Response>)> {
212        let (profile, prefix) = match fall_open_tier(state) {
213            Some(Tier::Capable) => (&self.0[1], "composite.profile_1."),
214            _ => (&self.0[0], "composite.profile_0."),
215        };
216        // Each profile retains its own holds, including in caller-carried state.
217        let mut profile_state = State {
218            extra: state
219                .extra
220                .iter()
221                .filter_map(|(key, value)| {
222                    key.strip_prefix(prefix)
223                        .map(|key| (key.to_string(), value.clone()))
224                })
225                .collect(),
226            ..State::default()
227        };
228        let result = profile.route(&mut profile_state, driver, request).await;
229        state.extra.retain(|key, _| !key.starts_with(prefix));
230        state.extra.extend(
231            profile_state
232                .extra
233                .into_iter()
234                .map(|(key, value)| (format!("{prefix}{key}"), value)),
235        );
236        state.tool_signals = profile_state.tool_signals;
237        state.target_prompts = profile_state.target_prompts;
238        let (score, response) = result?;
239        Ok((Classification::Scores(vec![score]), response))
240    }
241}
242
243#[async_trait]
244impl Algorithm for CompositeRouter {
245    fn name(&self) -> &str {
246        COMPOSITE
247    }
248
249    async fn route(
250        self: Arc<Self>,
251        driver: Driver,
252        request: Request,
253    ) -> Result<crate::RoutingOutcome> {
254        self.route.execute(driver, request).await
255    }
256}
257
258#[cfg(test)]
259mod tests {
260    use crate::{CapabilityJudgeConfig, LlmCapabilityConfig};
261    use std::collections::HashMap;
262    use std::sync::Arc;
263
264    use switchyard_protocol::{Category, LlmClientError, Message, ModelId, Role};
265
266    use super::*;
267    use crate::algorithms::util::tier_fixtures::{JUDGE, Recorder, turn_request};
268    use crate::core::testing::test_drive_with_models;
269
270    fn runtime_models() -> HashMap<Category, Vec<ModelId>> {
271        [
272            (Category::Judge, vec![ModelId::from(JUDGE)]),
273            (Category::Efficient, vec![ModelId::from("weak")]),
274            (Category::Capable, vec![ModelId::from("strong")]),
275            (
276                Category::Any,
277                vec![ModelId::from("strong"), ModelId::from("weak")],
278            ),
279        ]
280        .into()
281    }
282
283    fn user_turn_request() -> Request {
284        let mut request = turn_request(false);
285        request
286            .llm_request
287            .messages
288            .push(Message::text(Role::User, "now rewrite the parser"));
289        request
290    }
291
292    /// The same request shape with no session ID, so only the hash can key it.
293    fn unkeyed(mut request: Request) -> Request {
294        if let Some(metadata) = request.metadata.as_mut() {
295            metadata.session_id = None;
296        }
297        request
298    }
299
300    /// Builds a router with an efficient-first and a capable-first profile.
301    fn router_with_judge(
302        judge: CompositeJudgeConfig,
303        efficient_hold_turns: Option<i64>,
304    ) -> Result<Arc<CompositeRouter>> {
305        let mut efficient = StageRouterConfig::new(PickerMode::EfficientFirst, 0.5);
306        efficient.efficient_hold_turns = efficient_hold_turns;
307        let mut capable = StageRouterConfig::new(PickerMode::CapableFirst, 0.0);
308        capable.efficient_hold_turns = efficient_hold_turns;
309        Ok(Arc::new(CompositeRouter::new(judge, efficient, capable)?))
310    }
311
312    fn hash_keyed_router() -> Result<Arc<CompositeRouter>> {
313        router_with_judge(
314            CompositeJudgeConfig::Capability(TaskClassifierConfig {
315                judge: CapabilityJudgeConfig::Llm(LlmCapabilityConfig {
316                    base_threshold: 0.5,
317                    ..LlmCapabilityConfig::default()
318                }),
319                classify_trigger: ClassifyTrigger::UserTurn,
320                message_hash_fallback: true,
321                ..Default::default()
322            }),
323            None,
324        )
325    }
326
327    fn router() -> Result<Arc<CompositeRouter>> {
328        router_with_trigger(ClassifyTrigger::UserTurn)
329    }
330
331    #[tokio::test]
332    async fn compaction_retains_the_profile_until_a_real_user_turn() -> Result<()> {
333        let router = router()?;
334        let recorder = Arc::new(Recorder::default());
335        let mut compacted = user_turn_request();
336        compacted.llm_request.is_compaction = true;
337        for (request, verdict, calls, target) in [
338            (user_turn_request(), 1.0, 1, "weak"),
339            (compacted, 0.0, 1, "weak"),
340            (user_turn_request(), 0.0, 2, "strong"),
341        ] {
342            *recorder.judge_p_solve.lock() = verdict;
343            let (model, _) =
344                test_drive_with_models(router.clone(), request, runtime_models(), recorder.serve())
345                    .await?;
346            assert_eq!(recorder.judge_calls(), calls);
347            assert_eq!(model.as_str(), target);
348        }
349        Ok(())
350    }
351
352    #[tokio::test]
353    async fn capable_first_defaults_to_pinning_efficient_after_a_switch() -> Result<()> {
354        for capable_first in [false, true] {
355            for turns in [None, Some(0), Some(1), Some(-1)] {
356                let router = router_with_hold(ClassifyTrigger::UserTurn, turns)?;
357                let recorder = Arc::new(Recorder::default());
358                *recorder.judge_p_solve.lock() = if capable_first { 0.0 } else { 1.0 };
359                let mut initial = turn_request(false);
360                initial.llm_request.messages.truncate(1);
361                let mut write = turn_request(false);
362                if let switchyard_protocol::ContentBlock::ToolCall(call) =
363                    &mut write.llm_request.messages[1].content[0]
364                {
365                    call.name = "Write".into();
366                }
367                for request in [
368                    initial,
369                    turn_request(true),
370                    write.clone(),
371                    write.clone(),
372                    write,
373                    turn_request(true),
374                    turn_request(true),
375                    turn_request(true),
376                ] {
377                    test_drive_with_models(
378                        router.clone(),
379                        request,
380                        runtime_models(),
381                        recorder.serve(),
382                    )
383                    .await?;
384                }
385                let actual: Vec<_> = recorder
386                    .routed()
387                    .into_iter()
388                    .map(|call| call.target)
389                    .collect();
390                let initial = if capable_first { "strong" } else { "weak" };
391                let mut expected = vec![initial, "strong", "strong", "strong", "weak"];
392                let count = turns.unwrap_or(if capable_first { -1 } else { 0 });
393                expected.extend((0..3).map(|i| {
394                    if count == -1 || i < count {
395                        "weak"
396                    } else {
397                        "strong"
398                    }
399                }));
400                assert_eq!(
401                    actual, expected,
402                    "capable_first={capable_first}, turns={turns:?}"
403                );
404                assert_eq!(recorder.judge_calls(), 1);
405            }
406        }
407        Ok(())
408    }
409
410    fn router_with_trigger(classify_trigger: ClassifyTrigger) -> Result<Arc<CompositeRouter>> {
411        router_with_hold(classify_trigger, None)
412    }
413
414    fn router_with_hold(
415        classify_trigger: ClassifyTrigger,
416        efficient_hold_turns: Option<i64>,
417    ) -> Result<Arc<CompositeRouter>> {
418        router_with_judge(
419            CompositeJudgeConfig::Capability(TaskClassifierConfig {
420                judge: CapabilityJudgeConfig::Llm(LlmCapabilityConfig {
421                    base_threshold: 0.5,
422                    ..LlmCapabilityConfig::default()
423                }),
424                classify_trigger,
425                ..Default::default()
426            }),
427            efficient_hold_turns,
428        )
429    }
430
431    #[tokio::test]
432    async fn profiles_reset_holds_and_keep_prompts_when_the_judge_switches() -> Result<()> {
433        for (has_session_id, picker, first_target, first_prompt) in [
434            (false, PickerMode::EfficientFirst, "weak", "EF efficient"),
435            (true, PickerMode::EfficientFirst, "weak", "EF efficient"),
436            (true, PickerMode::CapableFirst, "strong", "EF capable"),
437        ] {
438            let mut efficient = StageRouterConfig::new(picker, 0.5);
439            efficient.capable_hold_turns = -1;
440            efficient.capable_system_prompt = Some("EF capable".into());
441            efficient.efficient_system_prompt = Some("EF efficient".into());
442            let mut capable = StageRouterConfig::new(PickerMode::CapableFirst, 0.0);
443            capable.capable_hold_turns = 0;
444            capable.capable_system_prompt = Some("CF capable".into());
445            capable.efficient_system_prompt = Some("CF efficient".into());
446            for stage in [&mut efficient, &mut capable] {
447                stage.llm_fallback = Some(crate::algorithms::stage::LlmFallback {
448                    target: None,
449                    config: Default::default(),
450                });
451            }
452            let router = Arc::new(CompositeRouter::new(
453                CompositeJudgeConfig::Capability(TaskClassifierConfig {
454                    judge: CapabilityJudgeConfig::Llm(LlmCapabilityConfig {
455                        base_threshold: 0.5,
456                        ..Default::default()
457                    }),
458                    classify_trigger: ClassifyTrigger::UserTurn,
459                    ..Default::default()
460                }),
461                efficient,
462                capable,
463            )?);
464            let recorder = Arc::new(Recorder::default());
465            let mut write = turn_request(false);
466            if let switchyard_protocol::ContentBlock::ToolCall(call) =
467                &mut write.llm_request.messages[1].content[0]
468            {
469                call.name = "Write".into();
470            }
471            let mut context_update = write.clone();
472            context_update.llm_request.messages.push(Message::text(
473                Role::User,
474                "<environment_context><current_date>2026-10-31</current_date></environment_context>",
475            ));
476            let mut state = State::default();
477            for (p_solve, request, target, prompt) in [
478                (1.0, user_turn_request(), first_target, first_prompt),
479                (1.0, turn_request(true), "strong", "EF capable"),
480                (0.0, user_turn_request(), "strong", "CF capable"),
481                (0.0, write, "weak", "CF efficient"),
482                (1.0, context_update, "weak", "CF efficient"),
483                (1.0, user_turn_request(), first_target, first_prompt),
484                (0.0, user_turn_request(), "strong", "CF capable"),
485            ] {
486                *recorder.judge_p_solve.lock() = p_solve;
487                let request = if has_session_id {
488                    request
489                } else {
490                    unkeyed(request)
491                };
492                let outcome = crate::core::testing::test_drive_with_state(
493                    router.clone(),
494                    request,
495                    runtime_models(),
496                    state,
497                    recorder.serve(),
498                )
499                .await?;
500                assert_eq!(outcome.selected_model_id()?.as_str(), target);
501                assert_eq!(outcome.request.llm_request.instructions.len(), 1);
502                assert_eq!(
503                    outcome.request.llm_request.instructions[0].content,
504                    vec![switchyard_protocol::ContentBlock::Text {
505                        text: prompt.into()
506                    }]
507                );
508                state = outcome.state;
509            }
510            assert_eq!(recorder.judge_calls(), 4);
511        }
512        Ok(())
513    }
514
515    #[test]
516    fn rejects_every_request_as_a_trigger() {
517        for judge in [
518            CompositeJudgeConfig::Capability(TaskClassifierConfig::default()),
519            CompositeJudgeConfig::Custom(CustomClassifierConfig::new(
520                "Choose a tier",
521                serde_json::json!({"type": "object"}),
522                crate::CustomClassifierPolicy::target_selector("/decision/target"),
523            )),
524        ] {
525            let error = router_with_judge(judge, None)
526                .err()
527                .expect("every_request must be rejected for both classifier modes");
528            assert!(matches!(error, LibsyError::AlgorithmError { message }
529                if message == "composite: classify_trigger must be user_turn or new_session"));
530        }
531    }
532
533    fn custom_judge(trigger: ClassifyTrigger) -> CompositeJudgeConfig {
534        let mut config = CustomClassifierConfig::new(
535            "Select a tier",
536            serde_json::json!({"type": "object"}),
537            crate::CustomClassifierPolicy::target_selector("/decision/target"),
538        );
539        config.classify_trigger = trigger;
540        CompositeJudgeConfig::Custom(config)
541    }
542
543    #[tokio::test]
544    async fn a_failed_session_judgment_retains_the_configured_stage_default() -> Result<()> {
545        for custom in [false, true] {
546            for (mode, expected) in [
547                (PickerMode::EfficientFirst, "weak"),
548                (PickerMode::CapableFirst, "strong"),
549            ] {
550                let judge = if custom {
551                    custom_judge(ClassifyTrigger::NewSession)
552                } else {
553                    CompositeJudgeConfig::Capability(TaskClassifierConfig {
554                        classify_trigger: ClassifyTrigger::NewSession,
555                        ..Default::default()
556                    })
557                };
558                let router = Arc::new(CompositeRouter::new(
559                    judge,
560                    StageRouterConfig::new(mode, 0.5),
561                    StageRouterConfig::new(PickerMode::CapableFirst, 0.0),
562                )?);
563                let calls = Arc::new(Mutex::new(0));
564                let serve = {
565                    let calls = calls.clone();
566                    move |target: ModelId, _request: Request| {
567                        let completion = if target.as_str() == JUDGE {
568                            *calls.lock() += 1;
569                            "not JSON".to_string()
570                        } else {
571                            target.to_string()
572                        };
573                        async move { Ok(crate::core::testing::reply(completion)) }
574                    }
575                };
576                for request in [
577                    user_turn_request(),
578                    turn_request(false),
579                    user_turn_request(),
580                ] {
581                    let (selected, _) = test_drive_with_models(
582                        router.clone(),
583                        request,
584                        runtime_models(),
585                        serve.clone(),
586                    )
587                    .await?;
588                    assert_eq!(selected.as_str(), expected);
589                }
590                assert_eq!(
591                    *calls.lock(),
592                    1,
593                    "new_session must retain a failed judgment"
594                );
595            }
596        }
597        Ok(())
598    }
599
600    #[tokio::test]
601    async fn a_custom_judge_sets_the_tier_and_retains_it_on_failure() -> Result<()> {
602        let router = router_with_judge(custom_judge(ClassifyTrigger::UserTurn), None)?;
603        let replies = Arc::new(Mutex::new(
604            [
605                Some(r#"{"decision":{"target":"capable"}}"#),
606                None,
607                Some("not JSON"),
608                Some(r#"{"decision":{"target":"efficient"}}"#),
609            ]
610            .into_iter(),
611        ));
612        let serve = {
613            let replies = replies.clone();
614            move |target: ModelId, _request: Request| {
615                let completion = if target.as_str() == JUDGE {
616                    replies
617                        .lock()
618                        .next()
619                        .expect("unexpected judge call")
620                        .map(str::to_string)
621                } else {
622                    Some(target.to_string())
623                };
624                async move {
625                    completion
626                        .map(crate::core::testing::reply)
627                        .ok_or_else(|| LlmClientError::General("judge unavailable".into()))
628                }
629            }
630        };
631        for (request, expected) in [
632            (user_turn_request(), "strong"),
633            (turn_request(false), "strong"),
634            (user_turn_request(), "strong"),
635            (user_turn_request(), "strong"),
636            (user_turn_request(), "weak"),
637        ] {
638            let (selected, _) =
639                test_drive_with_models(router.clone(), request, runtime_models(), serve.clone())
640                    .await?;
641            assert_eq!(selected.as_str(), expected);
642        }
643        assert!(replies.lock().next().is_none());
644        Ok(())
645    }
646
647    /// A route may point its judge at the same target it serves capable turns on.
648    /// The tier then cannot be recovered by looking the served model up in the
649    /// runtime groups — one id, two categories — so it comes off the verdict itself.
650    #[tokio::test]
651    async fn a_judge_sharing_the_capable_model_still_latches_the_tier() -> Result<()> {
652        let models: HashMap<Category, Vec<ModelId>> = [
653            (Category::Judge, vec![ModelId::from("strong")]),
654            (Category::Capable, vec![ModelId::from("strong")]),
655            (Category::Efficient, vec![ModelId::from("weak")]),
656            (
657                Category::Any,
658                vec![ModelId::from("strong"), ModelId::from("weak")],
659            ),
660        ]
661        .into();
662        // The judge runs first as a request-side processor, so the opening call is its own.
663        let calls = Arc::new(Mutex::new(0u32));
664        let serve = {
665            let calls = Arc::clone(&calls);
666            move |target: ModelId, _request: Request| {
667                let calls = Arc::clone(&calls);
668                async move {
669                    let mut calls = calls.lock();
670                    *calls += 1;
671                    let completion = if *calls == 1 {
672                        // p_solve below the threshold: the judge does not trust the
673                        // efficient tier, so the verdict is capable.
674                        r#"{"crux":"bounded task","primary_rule":"SUP-1","capability_boundary":"supported","p_solve":0.1}"#.to_string()
675                    } else {
676                        target.to_string()
677                    };
678                    Ok(crate::core::testing::reply(completion))
679                }
680            }
681        };
682        let router = router()?;
683
684        test_drive_with_models(
685            router.clone(),
686            user_turn_request(),
687            models.clone(),
688            serve.clone(),
689        )
690        .await?;
691        // A tool step is not a user turn, so nothing re-judges and the latched tier decides.
692        let (selected, _) =
693            test_drive_with_models(router, turn_request(false), models, serve).await?;
694
695        assert_eq!(selected, ModelId::from("strong"));
696        Ok(())
697    }
698
699    #[tokio::test]
700    async fn a_session_without_an_id_keys_on_the_message_hash() -> Result<()> {
701        let recorder = Arc::new(Recorder::default());
702        *recorder.judge_p_solve.lock() = 0.1;
703        let router = hash_keyed_router()?;
704
705        test_drive_with_models(
706            router.clone(),
707            unkeyed(user_turn_request()),
708            runtime_models(),
709            recorder.serve(),
710        )
711        .await?;
712        test_drive_with_models(
713            router.clone(),
714            unkeyed(turn_request(false)),
715            runtime_models(),
716            recorder.serve(),
717        )
718        .await?;
719
720        assert_eq!(
721            recorder.judge_calls(),
722            1,
723            "a tool step is not a user turn, session id or not"
724        );
725        assert_eq!(
726            recorder.routed()[1].target,
727            "strong",
728            "and the tier survives the tool step"
729        );
730        Ok(())
731    }
732
733    #[tokio::test]
734    async fn the_judge_sets_the_tier_once_a_turn_and_the_signals_run_within_it() -> Result<()> {
735        let recorder = Arc::new(Recorder::default());
736        *recorder.judge_p_solve.lock() = 0.1;
737        let router = router()?;
738
739        test_drive_with_models(
740            router.clone(),
741            user_turn_request(),
742            runtime_models(),
743            recorder.serve(),
744        )
745        .await?;
746        test_drive_with_models(
747            router.clone(),
748            turn_request(false),
749            runtime_models(),
750            recorder.serve(),
751        )
752        .await?;
753
754        let routed = recorder.routed();
755        assert_eq!(
756            routed[0].target, "strong",
757            "a quiet turn falls open to the verdict"
758        );
759        assert_eq!(
760            routed[1].target, "strong",
761            "which holds across the tool steps after it"
762        );
763        assert_eq!(
764            recorder.judge_calls(),
765            1,
766            "a tool step is not a new user turn"
767        );
768        Ok(())
769    }
770
771    #[tokio::test]
772    async fn caller_state_carries_the_judged_tier_without_a_session_id() -> Result<()> {
773        for trigger in [ClassifyTrigger::UserTurn, ClassifyTrigger::NewSession] {
774            let recorder = Arc::new(Recorder::default());
775            *recorder.judge_p_solve.lock() = 0.1;
776            let router = router_with_trigger(trigger)?;
777            let run = |request, state| {
778                crate::core::testing::test_drive_with_state(
779                    router.clone(),
780                    request,
781                    runtime_models(),
782                    state,
783                    recorder.serve(),
784                )
785            };
786
787            let first = run(unkeyed(user_turn_request()), State::default()).await?;
788            assert_eq!(first.selected_model_id()?, &ModelId::from("strong"));
789
790            let continued = run(unkeyed(turn_request(false)), first.state).await?;
791            assert_eq!(continued.selected_model_id()?, &ModelId::from("strong"));
792            assert_eq!(
793                continued.metadata.and_then(|m| m.evidence),
794                Some(serde_json::json!({"source": "retained"}))
795            );
796            assert_eq!(recorder.judge_calls(), 1, "{trigger:?}");
797        }
798        Ok(())
799    }
800}