Struct PaymentPolicy 

pub struct PaymentPolicy {

    pub id: PaymentPolicyId,
    pub organization_id: String,
    pub payment_account_id: PaymentAccountId,
    pub subject_type: String,
    pub subject_id: String,
    pub allowed_capabilities: Vec<String>,
    pub allowed_hosts: Vec<String>,
    pub rail_preference: Vec<PaymentRail>,
    pub max_amount_usd_per_request: Option<f64>,
    pub max_amount_usd_per_turn: Option<f64>,
    pub max_amount_usd_per_day: Option<f64>,
    pub require_approval_above_usd: Option<f64>,
    pub status: PaymentStatus,
    pub metadata: Value,
    pub created_at: DateTime<Utc>,
    pub updated_at: DateTime<Utc>,
}

A payment policy — the binding between a paying account and a subject (agent identity, session) that controls which paid calls are authorized and at what spend caps.

Fields

id: PaymentPolicyId

Prefixed public identifier. See ID Schema.

organization_id: String

Owning organization’s prefixed public identifier.

payment_account_id: PaymentAccountId

Payment account this policy authorizes spending from.

subject_type: String

Class of subject this policy binds to (e.g. agent_identity, session).

subject_id: String

Prefixed identifier of the bound subject.

allowed_capabilities: Vec<String>

Capability IDs this policy permits paid calls for. Empty list means no capability gating.

allowed_hosts: Vec<String>

HTTP host allowlist for paid outbound calls. Empty list means no host gating.

rail_preference: Vec<PaymentRail>

Preferred settlement rails in priority order; the authority picks the first available.

max_amount_usd_per_request: Option<f64>

Maximum amount (USD) any single paid request may settle for. Enforced by the payment authority at policy selection. None means no per-request cap.

max_amount_usd_per_turn: Option<f64>

Maximum cumulative amount (USD) per agent turn. Advisory only — not yet enforced. Stored on the policy for forward compatibility; the payment authority currently checks only max_amount_usd_per_request. None means no per-turn cap.

max_amount_usd_per_day: Option<f64>

Maximum cumulative amount (USD) per UTC day. Advisory only — not yet enforced. Stored on the policy for forward compatibility; the payment authority currently checks only max_amount_usd_per_request. None means no per-day cap.

require_approval_above_usd: Option<f64>

Threshold (USD) above which a request would require explicit human approval. Advisory only — not yet enforced. Stored on the policy for forward compatibility; no approval gate is wired up yet. None disables the (future) gate.

status: PaymentStatus

Current lifecycle status of this policy.

metadata: Value

Free-form metadata attached to this policy.

created_at: DateTime<Utc>

Timestamp when this policy was created (RFC 3339).

updated_at: DateTime<Utc>

Timestamp when this policy was last updated (RFC 3339).

Trait Implementations

impl Clone for PaymentPolicy

fn clone(&self) -> PaymentPolicy

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PaymentPolicy

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for PaymentPolicy

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for PaymentPolicy

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

where __S: Serializer,

Serialize this value into the given Serde serializer.