Struct Moderations 

pub struct Moderations { /* private fields */ }

Client for interacting with the OpenAI Moderations API.

This struct provides methods to classify text content for potential policy violations. Use Moderations::new() to create a new instance.

Example

use openai_tools::moderations::request::{Moderations, ModerationModel};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let moderations = Moderations::new()?;

    // Check content with a specific model
    let response = moderations
        .moderate_text("Some text to check", Some(ModerationModel::OmniModerationLatest))
        .await?;

    for result in &response.results {
        println!("Flagged: {}", result.flagged);
    }

    Ok(())
}

Implementations

impl Moderations

pub fn new() -> Result<Self>

Creates a new Moderations client for OpenAI API.

Initializes the client by loading the OpenAI API key from the environment variable OPENAI_API_KEY. Supports .env file loading via dotenvy.

Returns

• Ok(Moderations) - A new Moderations client ready for use
• Err(OpenAIToolError) - If the API key is not found in the environment

Example

use openai_tools::moderations::request::Moderations;

let moderations = Moderations::new().expect("API key should be set");

pub fn with_auth(auth: AuthProvider) -> Self

Creates a new Moderations client with a custom authentication provider

pub fn azure() -> Result<Self>

Creates a new Moderations client for Azure OpenAI API

pub fn detect_provider() -> Result<Self>

Creates a new Moderations client by auto-detecting the provider

pub fn with_url<S: Into<String>>(base_url: S, api_key: S) -> Self

Creates a new Moderations client with URL-based provider detection

pub fn from_url<S: Into<String>>(url: S) -> Result<Self>

Creates a new Moderations client from URL using environment variables

pub fn auth(&self) -> &AuthProvider

Returns the authentication provider

pub fn timeout(&mut self, timeout: Duration) -> &mut Self

Sets the request timeout duration.

Arguments

• timeout - The maximum time to wait for a response

Returns

A mutable reference to self for method chaining

pub async fn moderate_text( &self, text: &str, model: Option<ModerationModel>, ) -> Result<ModerationResponse>

Moderates a single text string.

Classifies the input text to determine if it violates OpenAI’s content policy.

Arguments

• text - The text content to moderate
• model - Optional model to use (defaults to omni-moderation-latest)

Returns

• Ok(ModerationResponse) - The moderation results
• Err(OpenAIToolError) - If the request fails or response parsing fails

Example

use openai_tools::moderations::request::Moderations;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let moderations = Moderations::new()?;
    let response = moderations.moderate_text("Hello, world!", None).await?;

    let result = &response.results[0];
    if result.flagged {
        println!("Content was flagged!");
        println!("Hate score: {}", result.category_scores.hate);
    }
    Ok(())
}

pub async fn moderate_texts( &self, texts: Vec<String>, model: Option<ModerationModel>, ) -> Result<ModerationResponse>

Moderates multiple text strings.

Classifies multiple input texts in a single request.

Arguments

• texts - Vector of text strings to moderate
• model - Optional model to use (defaults to omni-moderation-latest)

Returns

• Ok(ModerationResponse) - The moderation results (one result per input)
• Err(OpenAIToolError) - If the request fails or response parsing fails

Example

use openai_tools::moderations::request::Moderations;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let moderations = Moderations::new()?;
    let texts = vec![
        "First text to check".to_string(),
        "Second text to check".to_string(),
    ];
    let response = moderations.moderate_texts(texts, None).await?;

    for (i, result) in response.results.iter().enumerate() {
        println!("Text {}: flagged = {}", i + 1, result.flagged);
    }
    Ok(())
}