Enum Decision 

pub enum Decision {
    Allow,
    Block {
        status: u16,
        body: Option<String>,
        headers: Option<HashMap<String, String>>,
    },
    Redirect {
        url: String,
        status: u16,
    },
    Challenge {
        challenge_type: String,
        params: HashMap<String, String>,
    },
}

Agent response decision indicating how to handle a request or response.

This enum represents the decision an agent makes when processing a request or response. It allows agents to allow, block, redirect, or challenge requests based on their processing logic.

Variants

• Allow: Continue normal processing without modification
• Block: Reject the request/response with a custom error response
• Redirect: Send the client to a different URL
• Challenge: Request additional verification from the client

Examples

use std::collections::HashMap;
use zentinel_agent_protocol::Decision;

// Allow request to proceed normally
let allow = Decision::Allow;

// Block with 403 and custom body
let block = Decision::Block {
    status: 403,
    body: Some("Access denied".to_string()),
    headers: None,
};

// Redirect to login page
let redirect = Decision::Redirect {
    url: "https://example.com/login".to_string(),
    status: 302,
};

// Challenge with CAPTCHA
let mut params = HashMap::new();
params.insert("type".to_string(), "recaptcha".to_string());
let challenge = Decision::Challenge {
    challenge_type: "captcha".to_string(),
    params,
};

Variants

Allow

Allow the request/response to continue without modification.

This is the default decision that indicates normal processing should proceed.

Block

Block the request/response with a custom error response.

The proxy will return the specified status code and optional body/headers instead of forwarding the request to the upstream or returning the original response.

Fields

status: u16

HTTP status code to return (typically 4xx or 5xx)

body: Option<String>

Optional response body content

headers: Option<HashMap<String, String>>

Optional response headers to include

Redirect

Redirect the client to a different URL.

The proxy will return a redirect response with the specified URL and status code.

Fields

url: String

Target URL for the redirect

status: u16

HTTP redirect status code (301, 302, 303, 307, or 308)

Challenge

Request additional verification from the client.

This can be used to implement CAPTCHA, multi-factor authentication, or other challenge-response mechanisms.

Fields

challenge_type: String

Type of challenge (e.g., “captcha”, “otp”, “totp”)

params: HashMap<String, String>

Challenge-specific parameters and configuration

Trait Implementations

impl Clone for Decision

fn clone(&self) -> Decision

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Decision

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Decision

fn default() -> Decision

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Decision

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Decision

fn eq(&self, other: &Decision) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Decision

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Decision

impl StructuralPartialEq for Decision