use std::sync::Arc;
use async_trait::async_trait;
use crate::Result;
use crate::core::algorithm::Driver;
use crate::core::classifier::{Classification, Classifier, Score};
use switchyard_protocol::{
ContentBlock, LlmRequest, Message, Metadata, ModelId, Request, Response, Role,
};
pub struct SubagentGate<S> {
inner: Arc<dyn Classifier<S>>,
}
impl<S> SubagentGate<S> {
pub fn new(inner: Arc<dyn Classifier<S>>) -> Self {
Self { inner }
}
}
fn delegated_prompt_request(request: &Request) -> Option<Request> {
let prompt = request
.llm_request
.messages
.iter()
.rev()
.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 {
llm_request: LlmRequest {
model: request.llm_request.model.clone(),
messages: vec![Message::text(Role::User, prompt)],
..LlmRequest::default()
},
raw_request: None,
metadata: request.metadata.clone(),
})
}
#[async_trait]
impl<S> Classifier<S> for SubagentGate<S>
where
S: Send + 'static,
{
async fn score(
&self,
state: &mut S,
request: &mut Request,
driver: &Driver,
) -> Result<(Classification, Option<Response>)> {
if !request
.metadata
.as_ref()
.is_some_and(Metadata::is_subagent_work)
{
return Ok((Classification::Scores(Vec::new()), None));
}
let Some(mut classifier_request) = delegated_prompt_request(request) else {
return Ok((Classification::Scores(Vec::new()), None));
};
self.inner
.score(state, &mut classifier_request, driver)
.await
}
}
pub struct SubagentOverride {
worker: ModelId,
}
impl SubagentOverride {
pub fn new(worker: impl Into<ModelId>) -> Self {
Self {
worker: worker.into(),
}
}
}
#[async_trait]
impl<S> Classifier<S> for SubagentOverride
where
S: Send + 'static,
{
async fn score(
&self,
_state: &mut S,
request: &mut Request,
driver: &Driver,
) -> Result<(Classification, Option<Response>)> {
let is_delegated_work = request
.metadata
.as_ref()
.is_some_and(Metadata::is_subagent_work);
if is_delegated_work {
driver.set_evidence(serde_json::json!({"source": "subagent"}));
}
Ok((
Classification::Scores(if is_delegated_work {
vec![Score {
confidence: 1.0,
target: self.worker.clone(),
category: None,
}]
} else {
Vec::new()
}),
None,
))
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::core::testing::empty_driver;
use switchyard_protocol::{slice_to_header_map, text_request};
fn request(headers: &[(&str, &str)]) -> Request {
let metadata =
(!headers.is_empty()).then(|| Metadata::from_headers(&slice_to_header_map(headers)));
Request {
llm_request: text_request(Some(ModelId::from("auto").to_string()), "hi"),
raw_request: None,
metadata,
}
}
async fn selected(headers: &[(&str, &str)]) -> Result<Option<ModelId>> {
let mut state = ();
let classification = SubagentOverride::new("worker")
.score(&mut state, &mut request(headers), &empty_driver())
.await?;
Ok(classification.0.argmax(false)?.map(|score| score.target))
}
#[tokio::test]
async fn requests_without_metadata_abstain() -> Result<()> {
assert_eq!(selected(&[]).await?, None);
Ok(())
}
#[tokio::test]
async fn subagent_work_scores_the_worker() -> Result<()> {
let claude = &[
("x-claude-code-session-id", "root"),
("x-claude-code-agent-id", "child-1"),
];
assert_eq!(selected(claude).await?, Some(ModelId::from("worker")));
assert_eq!(
selected(&[("x-openai-subagent", "review")]).await?,
Some(ModelId::from("worker"))
);
assert_eq!(
selected(&[("x-openai-subagent", "collab_spawn")]).await?,
Some(ModelId::from("worker"))
);
Ok(())
}
#[tokio::test]
async fn harness_maintenance_turns_abstain() -> Result<()> {
assert_eq!(selected(&[("x-openai-subagent", "compact")]).await?, None);
assert_eq!(
selected(&[("x-switchyard-is-subagent", "false")]).await?,
None
);
Ok(())
}
#[tokio::test]
async fn delegated_work_is_scored_definitively() -> Result<()> {
let mut state = ();
let classification = SubagentOverride::new("worker")
.score(
&mut state,
&mut request(&[("x-openai-subagent", "review")]),
&empty_driver(),
)
.await?;
match classification.0 {
Classification::Scores(scores) => {
assert_eq!(scores.len(), 1);
assert_eq!(scores[0].confidence, 1.0);
}
Classification::Ambiguous(_) => panic!("override must score definitively"),
}
Ok(())
}
}