Guardrails

Validation and safety checks for agent outputs in PraisonAI Rust SDK

Guardrails validate and filter agent outputs to ensure safety, quality, and compliance.

Quick Start

1. Create a Guardrail

   use praisonai::{Guardrail, GuardrailResult};
   
   struct ContentFilter;
   
   impl Guardrail for ContentFilter {
       fn name(&self) -> &str { "content_filter" }
       fn description(&self) -> &str { "Filters inappropriate content" }
   
       fn validate(&self, content: &str) -> GuardrailResult {
           if content.contains("inappropriate") {
               GuardrailResult::failure("Content contains inappropriate material")
           } else {
               GuardrailResult::pass()
           }
       }
   }

2. Async Guardrail

   use praisonai::{AsyncGuardrail, GuardrailResult, async_trait};
   
   struct LlmFilter;
   
   #[async_trait]
   impl AsyncGuardrail for LlmFilter {
       fn name(&self) -> &str { "llm_filter" }
       fn description(&self) -> &str { "LLM-based content moderation" }
   
       async fn validate(&self, content: &str) -> GuardrailResult {
           // Call moderation API
           GuardrailResult::pass()
       }
   }

User Interaction Flow

GuardrailResult

Result of guardrail validation.

pub struct GuardrailResult {
    pub success: bool,
    pub result: Option<String>,
    pub error: Option<String>,
    pub metadata: HashMap<String, String>,
}

Factory Methods

) -> Self | Pass with modified content | | pass() | fn pass() -> Self | Pass without modification | | failure(error) | fn failure(impl Into

) -> Self | Fail with error message | | from_tuple(success, data) | fn from_tuple(bool, impl Into

) -> Self` | Create from tuple |

Instance Methods

, impl Into

) -> Self | Add metadata | | is_success() | fn is_success(&self) -> bool | Check if passed | | is_failure() | fn is_failure(&self) -> bool | Check if failed | | get_result_or(original) | fn get_result_or(&self, &str) -> String` | Get result or fallback |

Guardrail Trait

Synchronous validation interface.

pub trait Guardrail: Send + Sync {
    fn name(&self) -> &str;
    fn description(&self) -> &str;
    fn validate(&self, content: &str) -> GuardrailResult;
}

AsyncGuardrail Trait

Asynchronous validation interface.

#[async_trait]
pub trait AsyncGuardrail: Send + Sync {
    fn name(&self) -> &str;
    fn description(&self) -> &str;
    async fn validate(&self, content: &str) -> GuardrailResult;
}

GuardrailAction

Action to take when validation fails.

pub enum GuardrailAction {
    Stop,       // default - Stop execution
    Retry,      // Retry the task
    Warn,       // Continue with warning
    Skip,       // Skip and continue
    Fallback,   // Use fallback response
}

GuardrailConfig

Configuration for guardrail behavior.

pub struct GuardrailConfig {
    pub on_failure: GuardrailAction,
    pub max_retries: usize,
    pub fallback_response: Option<String>,
    pub log_results: bool,
    pub error_template: Option<String>,
}

Builder Methods

) -> Self | None | Set fallback | | log_results(b) | fn log_results(self, bool) -> Self | true | Enable logging | | error_template(t) | fn error_template(self, impl Into

) -> Self` | None | Custom error format |

Common Guardrail Patterns

Length Limiter

use praisonai::{Guardrail, GuardrailResult};

struct LengthGuardrail { max_length: usize }

impl Guardrail for LengthGuardrail {
    fn name(&self) -> &str { "length_limit" }
    fn description(&self) -> &str { "Limits response length" }

    fn validate(&self, content: &str) -> GuardrailResult {
        if content.len() > self.max_length {
            GuardrailResult::success(
                content.chars().take(self.max_length).collect::<String>()
            )
        } else {
            GuardrailResult::pass()
        }
    }
}

Profanity Filter

use praisonai::{Guardrail, GuardrailResult};

struct ProfanityFilter { blocked_words: Vec<String> }

impl Guardrail for ProfanityFilter {
    fn name(&self) -> &str { "profanity_filter" }
    fn description(&self) -> &str { "Blocks profane content" }

    fn validate(&self, content: &str) -> GuardrailResult {
        let lower = content.to_lowercase();
        for word in &self.blocked_words {
            if lower.contains(word) {
                return GuardrailResult::failure("Content contains blocked words");
            }
        }
        GuardrailResult::pass()
    }
}

Best Practices

Related