Struct RemoteEvidence 

pub struct RemoteEvidence {

    pub attempt_id: String,
    pub step: String,
    pub instance: Vec<String>,
    pub exchange: ExchangeReference,
    pub requested_identity: Option<String>,
    pub served: ServedIdentity,
    pub binding: ArtifactId,
    pub protocol: String,
    pub endpoint_class: String,
    pub code: Option<RemoteCode>,
    pub remote_state: RemoteState,
    pub charge_provenance: ChargeProvenance,
    pub batch: Option<BatchMembership>,
    pub principal_digest: Option<String>,
}

One remote attempt’s evidence reference in rustev.run/2 (spec 020, 3.2, I-4). It names the exchange record, never embeds it: no request or response body, credential, secret address, unredacted principal reference, provider reasoning or header.

Fields

attempt_id: String

step: String

The decision step and logical request (instance) the attempt served.

instance: Vec<String>

exchange: ExchangeReference

requested_identity: Option<String>

What the adapter asked for; None when it names no model.

served: ServedIdentity

binding: ArtifactId

The adapter binding (its artifact), the protocol or foreign mapping version, and the endpoint class (never a secret URL).

protocol: String

endpoint_class: String

code: Option<RemoteCode>

The remote error code of a failed attempt.

remote_state: RemoteState

The attempt’s final remote state, as the run record has it.

charge_provenance: ChargeProvenance

batch: Option<BatchMembership>

Present when the attempt was a member of a batched exchange.

principal_digest: Option<String>

The principal reference’s evidence digest, only when one was sent.

Implementations

impl RemoteEvidence

pub fn is_bounded(&self) -> bool

Every string within MAX_TEXT_BYTES, the instance within MAX_REMOTE_EVIDENCE_INSTANCE ids, and the canonical bytes within MAX_REMOTE_EVIDENCE_ENTRY_BYTES.

pub fn bounded(self) -> Self

The entry cut to its bounds: strings to MAX_TEXT_BYTES, and when the canonical bytes are still beyond the entry bound (strings that escape to several bytes each), to 32 bytes. Deterministic.

Trait Implementations

impl Clone for RemoteEvidence

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RemoteEvidence

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for RemoteEvidence

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for RemoteEvidence

impl JsonSchema for RemoteEvidence

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl PartialEq for RemoteEvidence

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for RemoteEvidence

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for RemoteEvidence