Switchyard lets LLM applications route traffic across models and providers while preserving native OpenAI and Anthropic API compatibility - enabling flexible model selection, benchmarking, and cost/performance optimization.
Rust
fix(libsy): classify subagent requests after tool results (#695)
Elyas Mehtabuddin074d9d0c383d
diff --git a/crates/libsy/src/algorithms/subagent.rs b/crates/libsy/src/algorithms/subagent.rsindex 7fdc2c1bd..a4b340a4c 100644--- a/crates/libsy/src/algorithms/subagent.rs+++ b/crates/libsy/src/algorithms/subagent.rs@@ -109,21 +109,13 @@ mod tests {use std::sync::atomic::{AtomicUsize, Ordering};use async_trait::async_trait;- use parking_lot::Mutex;- use serde_json::json;- use switchyard_protocol::{- Category, ContentBlock, InstructionBlock, Message, Metadata, ModelId, Request, Response,- Role, text_request,- };+ use switchyard_protocol::{Category, Metadata, ModelId, Request, Response, text_request};use super::{SubagentRouter, SubagentRouterConfig};use crate::algorithms::passthrough::Passthrough;use crate::core::classifier::{Classification, Classifier, Score};- use crate::core::testing::{echo, reply, test_drive_with_models};- use crate::{- ClassifyTrigger, CustomClassifierConfig, CustomClassifierPolicy, Driver,- LlmClassifierConfig, LlmTaskClassifier, RuntimeModels, State,- };+ use crate::core::testing::{echo, test_drive_with_models};+ use crate::{ClassifyTrigger, Driver, RuntimeModels, State};struct ScriptedClassifier {calls: AtomicUsize,@@ -244,90 +236,4 @@ mod tests {assert_eq!(fixed, "worker");Ok(())}-- #[tokio::test]- async fn custom_classifier_receives_only_the_delegated_prompt() -> crate::Result<()> {- let classifier = LlmTaskClassifier::new(LlmClassifierConfig::Custom {- default_target: Category::Capable,- config: CustomClassifierConfig::new(- "classify the delegated task",- json!({- "type": "object",- "properties": {- "target": {"type": "string", "enum": ["capable", "efficient"]}- },- "required": ["target"],- "additionalProperties": false- }),- CustomClassifierPolicy::target_selector("/target"),- ),- })?;- let router = configured(Arc::new(classifier))?;- let mut request = child("child-1");- request.llm_request.instructions = vec![InstructionBlock {- role: Role::System,- content: Message::text(Role::System, "child system instructions").content,- }];- request.llm_request.messages = vec![- Message::text(Role::User, "harness context"),- Message {- role: Role::User,- content: vec![- ContentBlock::Text {- text: "<system-reminder>tool context</system-reminder>".to_string(),- },- ContentBlock::Text {- text: "review this parser".to_string(),- },- ],- },- ];- let calls = Arc::new(Mutex::new(Vec::new()));- let served_calls = calls.clone();-- let models = RuntimeModels::new([(Category::Any, vec![ModelId::from("parent")])].into())- .with_subagent(- [- (Category::Judge, vec![ModelId::from("judge")]),- (Category::Capable, vec![ModelId::from("worker")]),- (Category::Efficient, vec![ModelId::from("reviewer")]),- (- Category::Any,- vec![ModelId::from("worker"), ModelId::from("reviewer")],- ),- ]- .into(),- );- let (selected, _) =- test_drive_with_models(router, request, models, move |target, request| {- let calls = served_calls.clone();- async move {- let completion = if target == "judge" {- r#"{"target":"efficient"}"#- } else {- "child answer"- };- calls.lock().push((target, request));- Ok(reply(completion))- }- })- .await?;-- assert_eq!(selected, "reviewer");- let calls = calls.lock();- assert_eq!(calls.len(), 2);- assert_eq!(calls[0].0, "judge");- assert_eq!(- calls[0].1.llm_request.instructions[0].content,- Message::text(Role::System, "classify the delegated task").content- );- assert_eq!(- calls[0].1.llm_request.messages,- vec![Message::text(Role::User, "review this parser")]- );- assert_eq!(calls[1].0, "reviewer");- assert_eq!(calls[1].1.llm_request.instructions.len(), 1);- assert_eq!(calls[1].1.llm_request.messages.len(), 2);- Ok(())- }}diff --git a/crates/libsy/src/algorithms/util/subagent.rs b/crates/libsy/src/algorithms/util/subagent.rsindex a7c9c5482..d3783d551 100644--- a/crates/libsy/src/algorithms/util/subagent.rs+++ b/crates/libsy/src/algorithms/util/subagent.rs@@ -41,21 +41,22 @@ impl<S> SubagentGate<S> {}}-/// Builds the prompt-only request shown to a delegated-work classifier.+/// Builds a classifier request containing only the delegated task text.fn delegated_prompt_request(request: &Request) -> Option<Request> {- // Coding harnesses append the parent's task after their injected user context and reminders.+ // Agent clients put the delegated task after added context and reminders.+ // A user message containing only tool-result blocks has no top-level text.+ // Find the latest nonblank user text without using text inside tool results.let prompt = request.llm_request.messages.iter().rev()- .find(|message| message.role == Role::User)?- .content- .iter()- .rev()- .find_map(|block| match block {- ContentBlock::Text { text } if !text.trim().is_empty() => Some(text.clone()),- _ => None,+ .filter(|message| message.role == Role::User)+ .find_map(|message| {+ message.content.iter().rev().find_map(|block| match block {+ ContentBlock::Text { text } if !text.trim().is_empty() => Some(text.clone()),+ _ => None,+ })})?;Some(Request {@@ -153,34 +154,8 @@ wheremod tests {use super::*;use crate::core::testing::empty_driver;- use parking_lot::Mutex;use switchyard_protocol::{slice_to_header_map, text_request};- #[derive(Default)]- struct CapturingClassifier {- requests: Mutex<Vec<Request>>,- }-- #[async_trait]- impl Classifier<()> for CapturingClassifier {- async fn score(- &self,- _state: &mut (),- request: &mut Request,- _driver: &Driver,- ) -> Result<(Classification, Option<Response>)> {- self.requests.lock().push(request.clone());- Ok((- Classification::Scores(vec![Score {- confidence: 1.0,- target: ModelId::from("worker"),- category: None,- }]),- None,- ))- }- }-fn request(headers: &[(&str, &str)]) -> Request {let metadata =(!headers.is_empty()).then(|| Metadata::from_headers(&slice_to_header_map(headers)));@@ -258,22 +233,4 @@ mod tests {}Ok(())}-- #[tokio::test]- async fn gate_abstains_when_delegated_work_has_no_text_prompt() -> Result<()> {- let classifier = Arc::new(CapturingClassifier::default());- let gate = SubagentGate::new(classifier.clone());- let mut request = request(&[("x-openai-subagent", "collab_spawn")]);- request.llm_request.messages = vec![Message::text(Role::Assistant, "no user prompt")];-- let mut state = ();- let (classification, response) = gate- .score(&mut state, &mut request, &empty_driver())- .await?;-- assert!(classification.argmax(false)?.is_none());- assert!(response.is_none());- assert!(classifier.requests.lock().is_empty());- Ok(())- }}diff --git a/crates/switchyard-server/tests/server.rs b/crates/switchyard-server/tests/server.rsindex e775ab426..847baf408 100644--- a/crates/switchyard-server/tests/server.rs+++ b/crates/switchyard-server/tests/server.rs@@ -2749,6 +2749,146 @@ target = "shared"Ok(())}+// Tool results and blank user messages must not replace the classifier's task text.+#[tokio::test]+async fn subagent_tool_continuations_are_classified_on_every_request_across_apis() -> TestResult {+ let upstream = MockUpstream::start().await?;+ let app = build_switchyard_router(load_test_config(&format!(+ r#"+schema_version = 1+[llm_clients.upstream]+format = "openai_chat"+base_url = "{base_url}"+[targets]+classifier = {{ id = "model/classifier", llm_client = "upstream" }}+strong = {{ id = "model/strong", llm_client = "upstream" }}+weak = {{ id = "model/weak", llm_client = "upstream" }}+[routes.agent]+id = "agent"+type = "passthrough"+target = "weak"+[routes.agent.subagents]+type = "llm_classifier"+mode = "custom"+classify_trigger = "every_request"+models = {{ judge = ["classifier"], capable = ["strong"], efficient = ["weak"], any = ["strong", "weak"] }}+default_target = "efficient"+prompt = "classify the delegated task"+response_schema = '''{{"type":"object","properties":{{"decision":{{"type":"object","properties":{{"target":{{"type":"string","enum":["capable","efficient"]}}}},"required":["target"],"additionalProperties":false}}}},"required":["decision"],"additionalProperties":false}}'''+[routes.agent.subagents.policy]+type = "target_selector"+selector = "/decision/target"+"#,+ base_url = upstream.base_url+ ))?);+ let headers = [+ ("x-claude-code-session-id", "root-session"),+ ("x-claude-code-agent-id", "child-agent"),+ ];+ for (path, key, mut body, tool_turn) in [+ (+ "/v1/chat/completions",+ "messages",+ json!({"model":"agent","messages":[+ {"role":"system","content":"child system instructions"},+ {"role":"user","content":"harness context"},+ {"role":"user","content":[{"type":"text","text":"injected context"},{"type":"text","text":"opening task: route to capable"}]}+ ]}),+ vec![+ json!({"role":"assistant","tool_calls":[{"id":"call_1","type":"function","function":{"name":"read_file","arguments":"{}"}}]}),+ json!({"role":"tool","tool_call_id":"call_1","content":"tool output"}),+ ],+ ),+ (+ "/v1/messages",+ "messages",+ json!({"model":"agent","max_tokens":16,"system":"child system instructions","messages":[+ {"role":"user","content":"harness context"},+ {"role":"user","content":[{"type":"text","text":"injected context"},{"type":"text","text":"opening task: route to capable"}]}+ ]}),+ vec![+ json!({"role":"assistant","content":[{"type":"tool_use","id":"call_1","name":"read_file","input":{}}]}),+ json!({"role":"user","content":[{"type":"tool_result","tool_use_id":"call_1","content":"tool output"}]}),+ ],+ ),+ (+ "/v1/responses",+ "input",+ json!({"model":"agent","instructions":"child system instructions","input":[+ {"role":"user","content":"harness context"},+ {"role":"user","content":[{"type":"input_text","text":"injected context"},{"type":"input_text","text":"opening task: route to capable"}]}+ ]}),+ vec![+ json!({"type":"function_call","call_id":"call_1","name":"read_file","arguments":"{}"}),+ json!({"type":"function_call_output","call_id":"call_1","output":"tool output"}),+ ],+ ),+ ] {+ for (step, (additions, expected_prompt)) in [+ (vec![], "opening task: route to capable"),+ (tool_turn.clone(), "opening task: route to capable"),+ (+ vec![json!({"role":"user","content":" \n\t"})],+ "opening task: route to capable",+ ),+ (+ vec![json!({"role":"user","content":"continue task: route to capable"})],+ "continue task: route to capable",+ ),+ ]+ .into_iter()+ .enumerate()+ {+ body[key]+ .as_array_mut()+ .ok_or("missing request messages")?+ .extend(additions);+ let response =+ send_with_headers(&app, "POST", path, Some(body.clone()), &headers).await?;+ assert_eq!(response.status, StatusCode::OK);+ assert_eq!(+ response.headers["x-model-router-selected-model"],+ "model/strong"+ );+ let calls = upstream.calls.lock().await;+ let judge = &calls[calls.len() - 2];+ assert_eq!(judge["model"], "model/classifier");+ assert_eq!(+ judge["messages"],+ json!([+ {"role":"system","content":"classify the delegated task"},+ {"role":"user","content":expected_prompt}+ ])+ );+ let answer = calls.last().ok_or("missing answer request")?.to_string();+ for preserved in [+ "child system instructions",+ "harness context",+ "injected context",+ "opening task: route to capable",+ expected_prompt,+ ] {+ assert!(answer.contains(preserved));+ }+ if step > 0 {+ assert!(answer.contains("tool output"));+ assert!(answer.contains("call_1"));+ }+ }+ let mut text_free = body;+ text_free[key] = json!(tool_turn);+ let response = send_with_headers(&app, "POST", path, Some(text_free), &headers).await?;+ assert_eq!(response.status, StatusCode::OK);+ assert_eq!(+ response.headers["x-model-router-selected-model"],+ "model/weak"+ );+ }+ let stats = send(&app, "GET", "/v1/stats", None).await?.json()?;+ assert_eq!(stats["classifier"]["total_requests"], 12);+ Ok(())+}+#[tokio::test]async fn all_inbound_formats_run_libsy_and_return_the_caller_format() -> TestResult {let (upstream, app) = test_app(&[(ROUTE_MODEL, &["model/a"])]).await?;