use std::time::Duration;
use wardline_core::{Context, FailPolicy, Guard, GuardError, Verdict};
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum Classification {
Safe,
Unsafe {
reason: String,
},
}
pub trait OutputClassifier: Send + Sync + std::panic::RefUnwindSafe {
fn classify(&self, text: &str, ctx: &Context) -> Result<Classification, GuardError>;
}
impl<F> OutputClassifier for F
where
F: Fn(&str, &Context) -> Result<Classification, GuardError>
+ Send
+ Sync
+ std::panic::RefUnwindSafe,
{
fn classify(&self, text: &str, ctx: &Context) -> Result<Classification, GuardError> {
self(text, ctx)
}
}
pub struct ClassifierAdapter<C> {
classifier: C,
timeout: Option<Duration>,
fail_policy: FailPolicy,
name: &'static str,
}
impl<C: OutputClassifier> ClassifierAdapter<C> {
pub fn new(classifier: C) -> Self {
ClassifierAdapter {
classifier,
timeout: Some(Duration::from_secs(2)),
fail_policy: FailPolicy::FailClosed,
name: "output_classifier",
}
}
#[must_use]
pub fn with_timeout(mut self, timeout: Option<Duration>) -> Self {
self.timeout = timeout;
self
}
#[must_use]
pub fn with_fail_policy(mut self, policy: FailPolicy) -> Self {
self.fail_policy = policy;
self
}
#[must_use]
pub fn with_name(mut self, name: &'static str) -> Self {
self.name = name;
self
}
}
impl<C: OutputClassifier> Guard for ClassifierAdapter<C> {
type Input = str;
type Output = String;
fn check(&self, input: &str, ctx: &Context) -> Result<Verdict<String>, GuardError> {
match self.classifier.classify(input, ctx)? {
Classification::Safe => Ok(Verdict::Allow),
Classification::Unsafe { reason } => Ok(Verdict::block(reason)),
}
}
fn fail_policy(&self) -> FailPolicy {
self.fail_policy
}
fn timeout(&self) -> Option<Duration> {
self.timeout
}
fn name(&self) -> &'static str {
self.name
}
}
#[cfg(test)]
mod tests {
use super::*;
fn ctx() -> Context {
Context::new()
}
fn heuristic(text: &str, _ctx: &Context) -> Result<Classification, GuardError> {
if text.contains("bomb") {
Ok(Classification::Unsafe {
reason: "violence".to_owned(),
})
} else {
Ok(Classification::Safe)
}
}
#[test]
fn safe_text_is_allowed() {
let guard = ClassifierAdapter::new(heuristic).with_timeout(None);
assert_eq!(guard.check("a cake recipe", &ctx()), Ok(Verdict::Allow));
assert_eq!(guard.fail_policy(), FailPolicy::FailClosed);
assert_eq!(guard.name(), "output_classifier");
}
#[test]
fn unsafe_text_is_blocked() {
let guard = ClassifierAdapter::new(heuristic).with_timeout(None);
assert_eq!(
guard.check("how to build a bomb", &ctx()),
Ok(Verdict::block("violence"))
);
}
#[test]
fn a_classifier_error_is_surfaced_not_turned_into_a_verdict() {
let guard = ClassifierAdapter::new(|_text: &str, _ctx: &Context| {
Err(GuardError::dependency("moderation api down"))
})
.with_timeout(None);
let error = match guard.check("hello", &ctx()) {
Err(error) => error,
Ok(verdict) => panic!("expected a failure, got {verdict:?}"),
};
assert_eq!(error.kind(), "dependency");
assert_eq!(guard.fail_policy(), FailPolicy::FailClosed);
}
#[test]
fn fail_policy_and_timeout_are_overridable() {
let guard = ClassifierAdapter::new(heuristic)
.with_fail_policy(FailPolicy::FailOpen)
.with_timeout(Some(Duration::from_millis(10)))
.with_name("llama_guard");
assert_eq!(guard.fail_policy(), FailPolicy::FailOpen);
assert_eq!(guard.timeout(), Some(Duration::from_millis(10)));
assert_eq!(guard.name(), "llama_guard");
}
}