Struct RedactionPolicy 

pub struct RedactionPolicy {
    pub input_level: RedactionLevel,
    pub output_level: RedactionLevel,
    pub error_level: RedactionLevel,
    pub sensitive_key_patterns: Vec<String>,
    pub sensitive_value_prefixes: Vec<String>,
    pub detector: Arc<dyn PiiDetector>,
}

Configurable redaction rules for tool audit records and observability payloads.

Each field category (input, output, error) has its own RedactionLevel. At Baseline the policy composes two layers:

1. Structural — sensitive_key_patterns triggers wholesale replacement of JSON object values by key name, and sensitive_value_prefixes does the same for strings that start with a known prefix.
2. Entity-level — detector scans every remaining string leaf for emails, PANs, CPFs, CNPJs, etc. and masks the spans it finds in place.

The detector is a runtime object not persisted across serialisation; on deserialise it is rebound to the process-wide BaselineDetector.

Fields

input_level: RedactionLevel

Redaction level for tool input values.

output_level: RedactionLevel

Redaction level for tool output values.

error_level: RedactionLevel

Redaction level for error detail strings.

sensitive_key_patterns: Vec<String>

Key substrings that trigger redaction at baseline level. Stored lowercase; matched case-insensitively.

sensitive_value_prefixes: Vec<String>

String patterns in values that trigger redaction at baseline level (e.g. "Bearer ", "sk-"). Case-sensitive prefix match.

detector: Arc<dyn PiiDetector>

Entity-level PII detector applied at baseline. Defaults to BaselineDetector; assign directly to plug in a custom implementation.

Implementations

impl RedactionPolicy

pub fn baseline() -> RedactionPolicy

Baseline redaction policy suitable for production audit logs and observability exports.

Redacts JSON object keys that look like credentials and string values that look like tokens wholesale, and masks entity-level PII (emails, PANs, CPFs, CNPJs, Pix UUIDs, E.164 phones, IPs, JWTs) detected anywhere in remaining string leaves. Preserves non-sensitive structural data for debugging.

All three levels (input_level, output_level, error_level) default to Baseline. Error strings routinely embed user data in stack traces (NotFound: user cpf=…), so masking them is the safer default — callers that need raw errors can explicitly set error_level: RedactionLevel::None on a baseline policy.

pub fn with_keys(keys: impl IntoIterator<Item = String>) -> RedactionPolicy

Baseline policy plus additional sensitive key patterns.

Custom keys augment the baseline list — they do not replace it. Patterns are normalised to lowercase to keep the case-insensitive matching contract intact.

use agent_sdk_foundation::privacy::RedactionPolicy;
let policy = RedactionPolicy::with_keys(["chave_pix".to_owned()]);
assert!(policy.sensitive_key_patterns.iter().any(|p| p == "password"));
assert!(policy.sensitive_key_patterns.iter().any(|p| p == "chave_pix"));

pub fn extend(&mut self, keys: impl IntoIterator<Item = String>)

Append additional sensitive key patterns to this policy.

Patterns are normalised to lowercase. Duplicates (relative to the existing list) are silently dropped.

pub fn none() -> RedactionPolicy

No-redaction policy — stores all values as-is.

Suitable only for development and testing. Never use in production audit logs.

pub fn full() -> RedactionPolicy

Full-redaction policy — replaces all input/output/error content.

Suitable for high-security environments where no tool data should be stored in audit logs.

pub fn redact(&self, value: &Value) -> Value

Inherent shorthand for redact_value.

Returns a fresh serde_json::Value with the policy applied. Use redact_in_place instead when the caller already owns the value and wants to avoid the clone.

pub fn redact_in_place(&self, value: &mut Value)

Apply the policy’s input_level rules to value in place.

Mutates value directly: object/array contents are walked and string leaves are replaced with masked strings without cloning the entire tree.

Trait Implementations

impl Clone for RedactionPolicy

fn clone(&self) -> RedactionPolicy

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RedactionPolicy

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

Formats the value using the given formatter.

impl Default for RedactionPolicy

fn default() -> RedactionPolicy

Returns Self::baseline() — never an empty policy.

This is loud on purpose: code that derives Default on a struct containing RedactionPolicy gets the baseline (sensitive-key list + entity detector) automatically rather than an empty pass-through that would silently leak PII. Code that wants a genuinely empty policy must opt in via RedactionPolicy::none.

impl<'de> Deserialize<'de> for RedactionPolicy

fn deserialize<__D>( __deserializer: __D, ) -> Result<RedactionPolicy, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for RedactionPolicy

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

where __S: Serializer,

Serialize this value into the given Serde serializer.