Skip to content

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.rs
index 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.rs
index 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 @@ where
mod 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.rs
index 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?;