use serde::{Deserialize, Serialize, Serializer, ser::SerializeStruct as _};
use serde_json::Value;
use crate::event::{Conversation, EventPurpose, ImageAttachment, LlmProvider};
#[derive(Debug, Clone, Copy, PartialEq, Deserialize, Serialize)]
#[serde(rename_all = "snake_case")]
#[non_exhaustive]
pub enum PluginCapability {
AgentEvents,
AgentRequest,
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(tag = "encoding", content = "content", rename_all = "snake_case")]
#[non_exhaustive]
pub enum DecodedContent {
Utf8(String),
Base64(String),
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "snake_case")]
#[non_exhaustive]
pub enum RequestParsingStatus {
Parsed,
UnknownProtocol,
InvalidPayload,
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "snake_case")]
#[non_exhaustive]
pub enum RequestMessageType {
Text,
Binary,
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(deny_unknown_fields)]
pub struct RequestSourceProcess {
pub pid: Option<u32>,
pub pid_version: Option<u32>,
pub name: Option<String>,
pub executable_path: Option<String>,
pub application_id: Option<String>,
pub entry_point: Option<String>,
pub working_directory: Option<String>,
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(deny_unknown_fields)]
pub struct RequestHarness {
pub id: String,
pub version: Option<String>,
pub turn_id: Option<String>,
pub subagent_id: Option<String>,
pub parent_subagent_id: Option<String>,
pub purpose: Option<EventPurpose>,
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(deny_unknown_fields)]
pub struct AgentRequestProjection {
pub protocol: String,
pub provider: LlmProvider,
pub model: Option<String>,
pub conversation: Conversation,
pub attachments: Vec<ImageAttachment>,
pub tools: Option<Value>,
pub previous_response_id: Option<String>,
}
#[derive(Deserialize, Serialize)]
#[serde(deny_unknown_fields)]
pub struct AgentRequestContext {
pub flow_id: String,
pub request_id: String,
pub ingress: String,
pub source_process: Option<RequestSourceProcess>,
pub destination: String,
pub destination_host: Option<String>,
pub server_name: Option<String>,
pub authority: Option<String>,
pub proxy_endpoint: Option<String>,
pub method: String,
pub path: String,
pub websocket: bool,
pub sequence: u64,
pub message_type: Option<RequestMessageType>,
pub headers: Vec<(String, String)>,
pub body: DecodedContent,
pub json: Option<Value>,
pub parsing_status: RequestParsingStatus,
pub harness: Option<RequestHarness>,
pub auth_token: Option<String>,
pub auth_token_writable: bool,
pub model_writable: bool,
pub agent: Option<AgentRequestProjection>,
}
impl std::fmt::Debug for AgentRequestContext {
fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter
.debug_struct("AgentRequestContext")
.field("request_id", &self.request_id)
.field("parsing_status", &self.parsing_status)
.finish_non_exhaustive()
}
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(deny_unknown_fields)]
pub struct InspectResponse {
pub request_id: String,
pub decision: RequestDecision,
}
#[derive(Serialize, PartialEq, Eq)]
#[serde(
tag = "op",
content = "value",
rename_all = "snake_case",
deny_unknown_fields
)]
#[non_exhaustive]
pub enum ModifyAction {
SetAuthToken(String),
RemoveAuthToken,
SetModel(String),
RemoveModel,
}
impl<'de> Deserialize<'de> for ModifyAction {
fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
#[derive(Deserialize)]
#[serde(tag = "op", rename_all = "snake_case", deny_unknown_fields)]
#[expect(
clippy::empty_enum_variants_with_brackets,
reason = "serde unit variants ignore extra fields; empty struct variants enforce the wire schema"
)]
enum WireAction {
SetAuthToken { value: String },
RemoveAuthToken {},
SetModel { value: String },
RemoveModel {},
}
Ok(match WireAction::deserialize(deserializer)? {
WireAction::SetAuthToken { value } => Self::SetAuthToken(value),
WireAction::RemoveAuthToken {} => Self::RemoveAuthToken,
WireAction::SetModel { value } => Self::SetModel(value),
WireAction::RemoveModel {} => Self::RemoveModel,
})
}
}
impl std::fmt::Debug for ModifyAction {
fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str(match self {
Self::SetAuthToken(_) => "SetAuthToken(<redacted>)",
Self::RemoveAuthToken => "RemoveAuthToken",
Self::SetModel(_) => "SetModel(<redacted>)",
Self::RemoveModel => "RemoveModel",
})
}
}
#[derive(Debug, PartialEq, Eq)]
#[non_exhaustive]
pub enum RequestDecision {
Allow,
Block(String),
Modify(Box<[ModifyAction]>),
}
impl RequestDecision {
#[must_use]
pub const fn into_response(self, request_id: String) -> InspectResponse {
InspectResponse {
request_id,
decision: self,
}
}
}
impl Serialize for RequestDecision {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
let fields = if matches!(self, Self::Allow) { 1 } else { 2 };
let mut object = serializer.serialize_struct("RequestDecision", fields)?;
match self {
Self::Allow => object.serialize_field("action", "allow")?,
Self::Block(reason) => {
object.serialize_field("action", "block")?;
object.serialize_field("reason", reason)?;
}
Self::Modify(actions) => {
object.serialize_field("action", "modify")?;
object.serialize_field("actions", actions)?;
}
}
object.end()
}
}
impl<'de> Deserialize<'de> for RequestDecision {
fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
#[derive(Deserialize)]
#[serde(tag = "action", rename_all = "snake_case", deny_unknown_fields)]
#[expect(
clippy::empty_enum_variants_with_brackets,
reason = "serde unit variants ignore extra fields; empty struct variants enforce the wire schema"
)]
enum WireDecision {
Allow {},
Block { reason: String },
Modify { actions: Box<[ModifyAction]> },
}
Ok(match WireDecision::deserialize(deserializer)? {
WireDecision::Allow {} => Self::Allow,
WireDecision::Block { reason } => Self::Block(reason),
WireDecision::Modify { actions } => Self::Modify(actions),
})
}
}
#[cfg(test)]
mod tests {
use super::*;
use serde_json::json;
#[test]
fn decisions_round_trip_explicit_actions_without_context() {
for value in [
json!({"action":"allow"}),
json!({"action":"block","reason":"policy"}),
json!({"action":"modify","actions":[]}),
json!({"action":"modify","actions":[{"op":"set_auth_token","value":"private-token"},{"op":"remove_auth_token"},{"op":"set_model","value":"new"},{"op":"remove_model"}]}),
] {
let decision: RequestDecision = serde_json::from_value(value.clone()).unwrap();
assert!(!format!("{decision:?}").contains("private-token"));
assert_eq!(serde_json::to_value(decision).unwrap(), value);
}
for invalid in [
json!({"action":"allow","actions":[]}),
json!({"action":"block"}),
json!({"action":"modify","actions":[{"op":"set_auth_token"}]}),
json!({"action":"modify","actions":[{"op":"set_auth_token","value":null}]}),
json!({"action":"modify","actions":[{"op":"remove_model","value":"bad"}]}),
json!({"action":"modify","actions":[{"op":"remove_model","value":null}]}),
json!({"action":"modify","actions":[{"op":"replace_body","value":"bad"}]}),
] {
assert!(
serde_json::from_value::<RequestDecision>(invalid.clone()).is_err(),
"unexpectedly accepted {invalid}"
);
}
}
}