1use 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
31struct 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 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 ClassifyTrigger::NewSession => {
64 identity.is_none_or(|identity| !self.tiers.lock().contains_key(identity))
65 && fall_open_tier(state).is_none()
66 }
67 ClassifyTrigger::EveryRequest => true,
69 }
70 }
71
72 fn retain(&self, identity: RoutingIdentity, tier: Tier) {
73 let mut tiers = self.tiers.lock();
74 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 self.retain(identity.clone(), self.default_tier);
107 }
108 }
109 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
122pub enum CompositeJudgeConfig {
124 Capability(TaskClassifierConfig),
126 Custom(CustomClassifierConfig),
128}
129
130pub struct CompositeRouter {
132 route: FallThrough,
133}
134
135impl CompositeRouter {
136 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 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 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 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 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 #[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 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 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 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}