Struct GovernedTransactionIntent 

pub struct GovernedTransactionIntent {
    pub id: String,
    pub server_id: String,
    pub tool_name: String,
    pub purpose: String,
    pub max_amount: Option<MonetaryAmount>,
    pub commerce: Option<GovernedCommerceContext>,
    pub metered_billing: Option<MeteredBillingContext>,
    pub runtime_attestation: Option<RuntimeAttestationEvidence>,
    pub call_chain: Option<GovernedCallChainContext>,
    pub autonomy: Option<GovernedAutonomyContext>,
    pub context: Option<Value>,
}

Canonical intent attached to a governed transaction request.

Fields

id: String

Unique intent identifier (UUIDv7 recommended).

server_id: String

Target tool server for this governed action.

tool_name: String

Target tool name for this governed action.

purpose: String

Human or policy-readable purpose for the governed action.

max_amount: Option<MonetaryAmount>

Optional maximum amount explicitly approved for this intent.

commerce: Option<GovernedCommerceContext>

Optional commerce approval context for seller-scoped payment rails.

metered_billing: Option<MeteredBillingContext>

Optional metered-billing quote and settlement context for non-rail tools.

runtime_attestation: Option<RuntimeAttestationEvidence>

Optional runtime attestation evidence bound to this governed request.

call_chain: Option<GovernedCallChainContext>

Optional delegated call-chain context for upstream transaction provenance.

autonomy: Option<GovernedAutonomyContext>

Optional explicit autonomy tier and delegation-bond attachment.

context: Option<Value>

Optional structured context for downstream policy or operator inspection.

Implementations

impl GovernedTransactionIntent

pub fn binding_hash(&self) -> Result<String, Error>

Compute a stable canonical hash for approval-token binding and receipts.

pub fn upstream_call_chain_proof( &self, ) -> Result<Option<GovernedUpstreamCallChainProof>, Error>

Extract the reserved upstream call-chain proof from the optional context object.

pub fn explicit_continuation_token( &self, ) -> Result<Option<CallChainContinuationToken>, Error>

Extract an explicitly attached continuation token without legacy fallback.

pub fn continuation_token( &self, ) -> Result<Option<CallChainContinuationToken>, Error>

Extract the stronger continuation token, falling back to the legacy upstream proof key.

Trait Implementations

impl Clone for GovernedTransactionIntent

fn clone(&self) -> GovernedTransactionIntent

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for GovernedTransactionIntent

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for GovernedTransactionIntent

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for GovernedTransactionIntent

fn eq(&self, other: &GovernedTransactionIntent) -> 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 GovernedTransactionIntent

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.

impl StructuralPartialEq for GovernedTransactionIntent