Struct ChioHttpRequest 

pub struct ChioHttpRequest {

    pub request_id: String,
    pub method: HttpMethod,
    pub route_pattern: String,
    pub path: String,
    pub query: HashMap<String, String>,
    pub headers: HashMap<String, String>,
    pub caller: CallerIdentity,
    pub body_hash: Option<String>,
    pub body_length: u64,
    pub session_id: Option<String>,
    pub capability_id: Option<String>,
    pub tool_server: Option<String>,
    pub tool_name: Option<String>,
    pub arguments: Option<Value>,
    pub model_metadata: Option<ModelMetadata>,
    pub governed_intent: Option<Value>,
    pub approval_token: Option<Value>,
    pub approval_tokens: Option<Value>,
    pub threshold_approval_proposal: Option<Value>,
    pub supplemental_authorization: Option<Value>,
    pub execution_nonce: Option<SignedExecutionNonce>,
    pub timestamp: u64,
}

A protocol-agnostic HTTP request that Chio evaluates. This is the shared input type for all HTTP substrate adapters – reverse proxy, framework middleware, and sidecar alike.

Fields

request_id: String

Unique request identifier (UUIDv7 recommended).

method: HttpMethod

HTTP method.

route_pattern: String

The matched route pattern (e.g., “/pets/{petId}”), not the raw path. Used for policy matching.

path: String

The actual request path (e.g., “/pets/42”).

query: HashMap<String, String>

Query parameters.

headers: HashMap<String, String>

Selected request headers relevant to policy evaluation. Substrate adapters extract only the headers needed for guards (e.g., Content-Type, Content-Length) – never raw auth headers.

caller: CallerIdentity

The extracted caller identity.

body_hash: Option<String>

SHA-256 hash of the request body (for content binding in receipts). None for bodyless requests (GET, HEAD, OPTIONS).

body_length: u64

Content-Length of the request body in bytes.

session_id: Option<String>

Session ID this request belongs to.

capability_id: Option<String>

Capability token ID presented with this request, if any.

tool_server: Option<String>

Optional sidecar tool server identity for synthetic tool-call evaluations.

tool_name: Option<String>

Optional sidecar tool name for synthetic tool-call evaluations.

arguments: Option<Value>

Optional structured tool-call arguments for synthetic sidecar evaluations.

model_metadata: Option<ModelMetadata>

Optional model identity and safety tier for model-constrained grants.

governed_intent: Option<Value>

Governed intent is not supported by the HTTP authority projection. It is retained here so the boundary can reject it instead of silently ignoring a security-sensitive field.

approval_token: Option<Value>

Singular governed approval is unsupported on this projection.

approval_tokens: Option<Value>

Threshold governed approvals are unsupported on this projection.

threshold_approval_proposal: Option<Value>

Threshold proposal is unsupported on this projection.

supplemental_authorization: Option<Value>

Supplemental authorization is unsupported on this projection.

execution_nonce: Option<SignedExecutionNonce>

Optional signed nonce presented to complete a strict nonce preflight.

timestamp: u64

Unix timestamp (seconds) when the request was received.

Implementations

impl ChioHttpRequest

pub fn new( request_id: String, method: HttpMethod, route_pattern: String, path: String, caller: CallerIdentity, ) -> Self

Create a minimal request for testing or simple evaluations.

pub fn unsupported_authorization_extension(&self) -> Option<&'static str>

Return the first authorization extension this HTTP projection cannot enforce. Callers use this to deny explicitly at the authority boundary.

pub fn content_hash(&self) -> Result<String>

Compute a content hash binding this request to a receipt. Hashes the canonical JSON of the route pattern, method, body hash, and query parameters.

Trait Implementations

impl Clone for ChioHttpRequest

fn clone(&self) -> ChioHttpRequest

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ChioHttpRequest

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ChioHttpRequest

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for ChioHttpRequest

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

where __S: Serializer,

Serialize this value into the given Serde serializer.