use super::client::Client;
use crate::models::types::ChatRequest;
use crate::sanitize::{sanitize, strip_ephemeral, MinimalSanitizeConfig, SanitizeError};
use crate::shared::Result;
use serde_json::Value;
impl Client {
pub fn set_defensive_sanitize(&self, cfg: MinimalSanitizeConfig) {
let stored = if cfg.is_empty() { None } else { Some(cfg) };
*self.inner().defensive_cfg.write().unwrap() = stored;
}
pub fn set_auto_strip_ephemeral_history(&self, on: bool) {
self.inner()
.auto_strip_ephemeral
.store(on, std::sync::atomic::Ordering::Relaxed);
}
pub(crate) fn apply_request_sanitizers(&self, req: &mut ChatRequest) -> Result<()> {
let cfg = self.inner().defensive_cfg.read().unwrap().clone();
let strip = self
.inner()
.auto_strip_ephemeral
.load(std::sync::atomic::Ordering::Relaxed);
if cfg.is_none() && !strip {
return Ok(());
}
if let Some(raw) = req.raw_messages.take() {
let mut msgs = normalize_raw_messages(raw).map_err(|e| {
crate::shared::Error::other(format!("sanitize: normalize raw messages: {e}"))
})?;
if let Some(c) = &cfg {
msgs = sanitize(msgs, c)?;
}
if strip {
msgs = strip_ephemeral(msgs);
}
req.raw_messages = Some(Value::Array(msgs));
return Ok(());
}
if let Some(c) = &cfg {
let max = c.max_messages_turns.unwrap_or(0);
let len = req.messages.as_ref().map(|m| m.len()).unwrap_or(0) as u64;
if max > 0 && len > max {
return Err(SanitizeError::HistoryTooDeep.into());
}
}
Ok(())
}
}
fn normalize_raw_messages(rm: Value) -> std::result::Result<Vec<Value>, String> {
match rm {
Value::Array(a) => Ok(a),
_ => Err("raw messages must be a JSON array".to_string()),
}
}
impl From<SanitizeError> for crate::shared::Error {
fn from(e: SanitizeError) -> Self {
crate::shared::Error::other(e.to_string())
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::core::{Client, Config};
use crate::sanitize::BlockType;
use serde_json::json;
fn client() -> Client {
Client::new(Config::default()).unwrap()
}
#[test]
fn unconfigured_is_noop() {
let c = client();
let mut req = ChatRequest {
raw_messages: Some(json!([{ "role": "user", "content": [
{ "type": "text", "text": "x", "acosmi_ephemeral": true }
]}])),
..Default::default()
};
let before = req.raw_messages.clone();
c.apply_request_sanitizers(&mut req).unwrap();
assert_eq!(req.raw_messages, before); }
#[test]
fn auto_strip_branch_applies() {
let c = client();
c.set_auto_strip_ephemeral_history(true);
let mut req = ChatRequest {
raw_messages: Some(json!([{ "role": "assistant", "content": [
{ "type": "thinking", "thinking": "t", "acosmi_ephemeral": true },
{ "type": "text", "text": "ephemeral", "acosmi_ephemeral": true },
{ "type": "text", "text": "kept" }
]}])),
..Default::default()
};
c.apply_request_sanitizers(&mut req).unwrap();
let content = req.raw_messages.as_ref().unwrap()[0]["content"]
.as_array()
.unwrap();
let types: Vec<&str> = content
.iter()
.map(|b| b["type"].as_str().unwrap())
.collect();
assert_eq!(types, vec!["thinking", "text"]); }
#[test]
fn defensive_cfg_media_oversize_errors() {
let c = client();
c.set_defensive_sanitize(MinimalSanitizeConfig {
max_image_bytes: Some(2),
..Default::default()
});
let mut req = ChatRequest {
raw_messages: Some(json!([{ "role": "user", "content": [
{ "type": "image", "source": { "type": "base64", "data": "AAAA" } }
]}])),
..Default::default()
};
assert!(c.apply_request_sanitizers(&mut req).is_err());
}
#[test]
fn defensive_cfg_deny_list_strips() {
let c = client();
c.set_defensive_sanitize(MinimalSanitizeConfig {
permanent_deny_blocks: vec![BlockType::Image],
..Default::default()
});
let mut req = ChatRequest {
raw_messages: Some(json!([{ "role": "user", "content": [
{ "type": "image", "source": { "type": "url", "url": "http://x/y" } },
{ "type": "text", "text": "kept" }
]}])),
..Default::default()
};
c.apply_request_sanitizers(&mut req).unwrap();
let content = req.raw_messages.as_ref().unwrap()[0]["content"]
.as_array()
.unwrap();
assert_eq!(content.len(), 1);
assert_eq!(content[0]["type"], "text");
}
#[test]
fn empty_cfg_disables() {
let c = client();
c.set_defensive_sanitize(MinimalSanitizeConfig::default()); let mut req = ChatRequest {
raw_messages: Some(json!([{ "role": "user", "content": [
{ "type": "text", "text": "x", "acosmi_ephemeral": true }
]}])),
..Default::default()
};
let before = req.raw_messages.clone();
c.apply_request_sanitizers(&mut req).unwrap();
assert_eq!(req.raw_messages, before);
}
#[test]
fn pure_messages_depth_check() {
use crate::models::types::ChatMessage;
let c = client();
c.set_defensive_sanitize(MinimalSanitizeConfig {
max_messages_turns: Some(1),
..Default::default()
});
let mut req = ChatRequest {
messages: Some(vec![ChatMessage::default(), ChatMessage::default()]),
..Default::default()
};
assert!(c.apply_request_sanitizers(&mut req).is_err());
}
#[test]
fn normalize_non_array_errors() {
let c = client();
c.set_auto_strip_ephemeral_history(true);
let mut req = ChatRequest {
raw_messages: Some(json!({ "not": "an array" })),
..Default::default()
};
assert!(c.apply_request_sanitizers(&mut req).is_err());
}
}