use crate::Result;
use crate::core::algorithm::Driver;
use async_trait::async_trait;
use switchyard_protocol::{AggLlmResponse, Category, ModelId, Request};
pub enum Event<'a> {
Request {
request: &'a mut Request,
driver: &'a Driver,
},
Decision {
request: &'a mut Request,
selected_model_id: &'a ModelId,
category: Option<Category>,
driver: &'a Driver,
},
ModelResponse(&'a AggLlmResponse),
}
#[async_trait]
pub trait Processor<S = ()>: Send + Sync {
async fn process(&self, state: &mut S, event: Event<'_>) -> Result<()>;
}
#[cfg(test)]
mod tests {
use super::*;
use crate::core::testing::empty_driver;
use std::collections::HashMap;
use switchyard_protocol::{text_request, text_response};
type TestState = HashMap<&'static str, u32>;
fn event_key(event: &Event<'_>) -> &'static str {
match event {
Event::Request { .. } => "requests",
Event::Decision { .. } => "decisions",
Event::ModelResponse(_) => "model_responses",
}
}
fn count(state: &TestState, key: &'static str) -> u32 {
state.get(key).copied().unwrap_or_default()
}
struct CountingProcessor;
#[async_trait]
impl Processor<TestState> for CountingProcessor {
async fn process(&self, state: &mut TestState, event: Event<'_>) -> Result<()> {
*state.entry(event_key(&event)).or_default() += 1;
Ok(())
}
}
fn request() -> Request {
Request {
llm_request: text_request(Some("auto".to_string()), "hi"),
raw_request: None,
metadata: None,
}
}
#[tokio::test]
async fn processor_tallies_each_event_variant_into_state() -> Result<()> {
let processor = CountingProcessor;
let mut state = TestState::default();
let mut req = request();
let response = text_response(None, "ok");
let selected_model_id = ModelId::from("test/model");
processor
.process(
&mut state,
Event::Request {
request: &mut req,
driver: &empty_driver(),
},
)
.await?;
processor
.process(&mut state, Event::ModelResponse(&response))
.await?;
processor
.process(
&mut state,
Event::Decision {
request: &mut req,
selected_model_id: &selected_model_id,
category: None,
driver: &empty_driver(),
},
)
.await?;
assert_eq!(count(&state, "requests"), 1);
assert_eq!(count(&state, "decisions"), 1);
assert_eq!(count(&state, "model_responses"), 1);
Ok(())
}
#[tokio::test]
async fn process_accumulates_state_across_repeated_events() -> Result<()> {
let processor = CountingProcessor;
let mut state = TestState::default();
let mut req = request();
for _ in 0..3 {
processor
.process(
&mut state,
Event::Request {
request: &mut req,
driver: &empty_driver(),
},
)
.await?;
}
assert_eq!(count(&state, "requests"), 3);
Ok(())
}
struct RewritingProcessor;
#[async_trait]
impl Processor for RewritingProcessor {
async fn process(&self, _state: &mut (), event: Event<'_>) -> Result<()> {
match event {
Event::Request { request, .. } | Event::Decision { request, .. } => {
request.llm_request.model = Some("rewritten".to_string());
}
_ => {}
}
Ok(())
}
}
#[tokio::test]
async fn processor_rewrites_the_request_in_place() -> Result<()> {
let mut state = ();
let mut req = request();
assert_eq!(req.model_id(), Some("auto".into()));
RewritingProcessor
.process(
&mut state,
Event::Request {
request: &mut req,
driver: &empty_driver(),
},
)
.await?;
assert_eq!(req.model_id(), Some("rewritten".into()));
Ok(())
}
}