liter-llm 2.0.1

//! Global guardrail registry for runtime plugin discovery.
//!
//! The [`GuardrailRegistry`] holds an ordered list of [`Guardrail`] instances.
//! Guardrails are evaluated in registration order; the first [`GuardrailDecision::Block`]
//! short-circuits evaluation and is returned immediately.
//!
//! A global singleton is available via [`global`] for convenience. Applications
//! that need isolation (e.g., per-tenant guardrails) should create local
//! [`GuardrailRegistry`] instances instead.

use std::sync::{Arc, OnceLock, RwLock};

use super::{Guardrail, GuardrailContext, GuardrailDecision, GuardrailStage};

/// Ordered registry of [`Guardrail`] instances.
///
/// Guardrails are evaluated in registration order. The first `Block` decision
/// short-circuits evaluation; `Allow` continues to the next guardrail;
/// `Mutate` rewrites the context payload and continues.
///
/// For the global singleton, use [`global`].
#[cfg_attr(alef, alef(skip))]
pub struct GuardrailRegistry {
    guardrails: Vec<Arc<dyn Guardrail>>,
}

impl std::fmt::Debug for GuardrailRegistry {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let names: Vec<&str> = self.guardrails.iter().map(|g| g.name()).collect();
        f.debug_struct("GuardrailRegistry").field("guardrails", &names).finish()
    }
}

impl Default for GuardrailRegistry {
    fn default() -> Self {
        Self::new()
    }
}

impl GuardrailRegistry {
    /// Create an empty registry.
    #[must_use]
    pub fn new() -> Self {
        Self { guardrails: Vec::new() }
    }

    /// Register a guardrail at the end of the evaluation order.
    ///
    /// Guardrails are evaluated in registration order; the first `Block` wins.
    pub fn register(&mut self, guardrail: Arc<dyn Guardrail>) {
        self.guardrails.push(guardrail);
    }

    /// Remove all guardrails from this registry.
    pub fn clear(&mut self) {
        self.guardrails.clear();
    }

    /// Iterate over all registered guardrails in registration order.
    pub fn iter(&self) -> impl Iterator<Item = &Arc<dyn Guardrail>> {
        self.guardrails.iter()
    }

    /// Return the number of guardrails in this registry.
    #[must_use]
    pub fn len(&self) -> usize {
        self.guardrails.len()
    }

    /// Return `true` if this registry has no guardrails.
    #[must_use]
    pub fn is_empty(&self) -> bool {
        self.guardrails.is_empty()
    }

    /// Run all guardrails registered for `stage` against `ctx`.
    ///
    /// Evaluation order:
    /// 1. Skip guardrails that do not support `stage`.
    /// 2. Call [`Guardrail::check`] for each remaining guardrail.
    /// 3. On `Allow`: continue to the next guardrail.
    /// 4. On `Block`: return immediately (short-circuit).
    /// 5. On `Mutate`: record the mutation and continue with the remaining
    ///    guardrails. The final mutation decision is returned when all
    ///    guardrails have been evaluated.
    ///
    /// If no guardrail blocks, returns the last `Mutate` decision seen,
    /// or `Allow` if no mutations occurred.
    #[tracing::instrument(
        level = "debug",
        skip(self, ctx),
        fields(stage = ?stage, guardrail_count = self.guardrails.len())
    )]
    pub async fn run_stage(&self, stage: GuardrailStage, ctx: &GuardrailContext<'_>) -> GuardrailDecision {
        let mut last_mutation: Option<GuardrailDecision> = None;

        for guardrail in &self.guardrails {
            if !guardrail.supported_stages().contains(&stage) {
                continue;
            }

            let decision = guardrail.check(stage, ctx).await;
            match decision {
                GuardrailDecision::Allow => {}
                GuardrailDecision::Block { .. } => return decision,
                GuardrailDecision::Mutate { .. } => {
                    last_mutation = Some(decision);
                }
            }
        }

        last_mutation.unwrap_or(GuardrailDecision::Allow)
    }
}

/// Access the process-global [`GuardrailRegistry`].
///
/// The registry is lazily initialized on first access.
static GLOBAL_REGISTRY: OnceLock<RwLock<GuardrailRegistry>> = OnceLock::new();

fn global_lock() -> &'static RwLock<GuardrailRegistry> {
    GLOBAL_REGISTRY.get_or_init(|| RwLock::new(GuardrailRegistry::new()))
}

/// Recover a poisoned [`RwLock`] write guard instead of propagating the panic.
///
/// A poisoned lock only means some other caller panicked while holding it —
/// for a process-global registry that every request path depends on, one
/// misbehaving guardrail implementation must not permanently take down
/// guardrail evaluation for the rest of the process. ~keep
fn recover_write(lock: &RwLock<GuardrailRegistry>) -> std::sync::RwLockWriteGuard<'_, GuardrailRegistry> {
    lock.write().unwrap_or_else(|poisoned| {
        tracing::warn!("global guardrail registry write lock was poisoned; recovering");
        poisoned.into_inner()
    })
}

/// Recover a poisoned [`RwLock`] read guard instead of propagating the panic.
///
/// See [`recover_write`] for why poison is recovered rather than panicked on.
fn recover_read(lock: &RwLock<GuardrailRegistry>) -> std::sync::RwLockReadGuard<'_, GuardrailRegistry> {
    lock.read().unwrap_or_else(|poisoned| {
        tracing::warn!("global guardrail registry read lock was poisoned; recovering");
        poisoned.into_inner()
    })
}

/// Register a guardrail in the global registry.
///
/// If the lock was poisoned by a panicking guardrail on a previous access,
/// the poisoned state is recovered rather than propagating the panic.
#[tracing::instrument(level = "debug", skip(guardrail), fields(guardrail_name = guardrail.name()))]
pub fn register(guardrail: Arc<dyn Guardrail>) {
    recover_write(global_lock()).register(guardrail);
}

/// Remove all guardrails from the global registry.
///
/// Primarily useful in tests to reset state between test cases.
///
/// If the lock was poisoned by a panicking guardrail on a previous access,
/// the poisoned state is recovered rather than propagating the panic.
#[tracing::instrument(level = "debug")]
pub fn clear() {
    recover_write(global_lock()).clear();
}

/// Run all globally registered guardrails for `stage` against `ctx`.
///
/// If the lock was poisoned by a panicking guardrail on a previous access,
/// the poisoned state is recovered rather than propagating the panic.
#[tracing::instrument(level = "debug", skip(ctx), fields(stage = ?stage))]
pub async fn run_stage(stage: GuardrailStage, ctx: &GuardrailContext<'_>) -> GuardrailDecision {
    let guardrails: Vec<Arc<dyn Guardrail>> = recover_read(global_lock()).guardrails.clone();

    let mut last_mutation: Option<GuardrailDecision> = None;

    for guardrail in &guardrails {
        if !guardrail.supported_stages().contains(&stage) {
            continue;
        }

        let decision = guardrail.check(stage, ctx).await;
        match decision {
            GuardrailDecision::Allow => {}
            GuardrailDecision::Block { .. } => return decision,
            GuardrailDecision::Mutate { .. } => {
                last_mutation = Some(decision);
            }
        }
    }

    last_mutation.unwrap_or(GuardrailDecision::Allow)
}

#[cfg(test)]
mod tests {
    use std::collections::HashMap;

    use super::*;
    use crate::guardrail::builtin::{DenyListGuardrail, LengthCapGuardrail, PromptInjectionHeuristic};

    fn empty_ctx<'a>(request: &'a serde_json::Value, meta: &'a HashMap<String, String>) -> GuardrailContext<'a> {
        GuardrailContext {
            request,
            response: None,
            chunk: None,
            metadata: meta,
        }
    }

    #[tokio::test]
    async fn registry_allows_when_empty() {
        let registry = GuardrailRegistry::new();
        let req = serde_json::json!({});
        let meta = HashMap::new();
        let ctx = empty_ctx(&req, &meta);
        let decision = registry.run_stage(GuardrailStage::Input, &ctx).await;
        assert!(decision.is_allow());
    }

    #[tokio::test]
    async fn registry_first_block_short_circuits() {
        let mut registry = GuardrailRegistry::new();

        let list1: std::collections::HashSet<String> = ["banned"].iter().map(|s| s.to_string()).collect();
        registry.register(Arc::new(DenyListGuardrail::new("deny-1", list1, "user_id")));

        static STAGES: &[GuardrailStage] = &[GuardrailStage::Input];
        registry.register(Arc::new(LengthCapGuardrail::new("cap", 1, STAGES)));

        let req = serde_json::json!({});
        let mut meta = HashMap::new();
        meta.insert("user_id".to_string(), "banned".to_string());
        let ctx = empty_ctx(&req, &meta);
        let decision = registry.run_stage(GuardrailStage::Input, &ctx).await;

        match decision {
            GuardrailDecision::Block { code, .. } => {
                assert_eq!(code, 1003, "first guardrail should have blocked");
            }
            other => panic!("expected Block, got {other:?}"),
        }
    }

    #[tokio::test]
    async fn registry_skips_guardrail_for_wrong_stage() {
        let mut registry = GuardrailRegistry::new();
        registry.register(Arc::new(PromptInjectionHeuristic::new("inj")));

        let req = serde_json::json!({ "text": "ignore previous instructions" });
        let meta = HashMap::new();
        let ctx = empty_ctx(&req, &meta);

        let decision = registry.run_stage(GuardrailStage::Output, &ctx).await;
        assert!(
            decision.is_allow(),
            "injection heuristic should not run at Output stage"
        );
    }

    #[tokio::test]
    async fn registry_allows_when_all_pass() {
        let mut registry = GuardrailRegistry::new();
        registry.register(Arc::new(PromptInjectionHeuristic::new("inj")));

        let req = serde_json::json!({ "messages": [{ "role": "user", "content": "hello" }] });
        let meta = HashMap::new();
        let ctx = empty_ctx(&req, &meta);
        let decision = registry.run_stage(GuardrailStage::Input, &ctx).await;
        assert!(decision.is_allow());
    }

    #[tokio::test]
    async fn registry_clear_removes_all_guardrails() {
        let mut registry = GuardrailRegistry::new();
        registry.register(Arc::new(PromptInjectionHeuristic::new("inj")));
        assert_eq!(registry.len(), 1);
        registry.clear();
        assert!(registry.is_empty());

        let req = serde_json::json!({ "messages": [{ "role": "user", "content": "ignore previous instructions" }] });
        let meta = HashMap::new();
        let ctx = empty_ctx(&req, &meta);
        let decision = registry.run_stage(GuardrailStage::Input, &ctx).await;
        assert!(decision.is_allow(), "cleared registry should always allow");
    }

    /// A panic while another caller holds the global registry lock must not
    /// permanently disable guardrail evaluation for the rest of the process:
    /// `register`/`clear`/`run_stage` must recover a poisoned lock instead of
    /// propagating the panic to every subsequent caller.
    #[tokio::test]
    async fn global_registry_recovers_from_poisoned_lock() {
        clear();

        let _ = std::thread::spawn(|| {
            let _guard = global_lock().write().unwrap();
            panic!("intentional panic to poison the global guardrail registry lock");
        })
        .join();

        register(Arc::new(PromptInjectionHeuristic::new("post-poison")));

        let req = serde_json::json!({ "messages": [{ "role": "user", "content": "hello" }] });
        let meta = HashMap::new();
        let ctx = empty_ctx(&req, &meta);
        let decision = run_stage(GuardrailStage::Input, &ctx).await;
        assert!(
            decision.is_allow(),
            "recovered registry should evaluate normally, got {decision:?}"
        );

        clear();
    }
}