Struct AgentCard 

pub struct AgentCard {
    pub name: String,
    pub description: String,
    pub version: String,
    pub capabilities: CardCapabilities,
    pub supported_interfaces: Vec<CardInterface>,
    pub default_input_modes: Vec<String>,
    pub default_output_modes: Vec<String>,
    pub skills: Vec<CardSkill>,
    pub security_schemes: BTreeMap<String, CardSecurityScheme>,
    pub security_requirements: Vec<CardSecurityRequirement>,
    pub signatures: Vec<CardSignature>,
}

An A2A Agent Card, derived from a manifest.

Fields

name: String

description: String

version: String

capabilities: CardCapabilities

supported_interfaces: Vec<CardInterface>

default_input_modes: Vec<String>

default_output_modes: Vec<String>

skills: Vec<CardSkill>

security_schemes: BTreeMap<String, CardSecurityScheme>

How to authenticate every non-card operation on this interface.

security_requirements: Vec<CardSecurityRequirement>

signatures: Vec<CardSignature>

Detached JWS signatures over this card.

Several are allowed so a publisher can rotate keys without a window in which nobody can verify the card.

Implementations

impl AgentCard

pub fn derive( manifest: &Manifest, url: impl Into<String>, ) -> Result<Self, ManifestError>

Derive a card from a declaration.

url is deployment wiring rather than a property of the agent — the same split as an API key: where an agent is reachable changes with the deployment, and an agent’s declaration must not change when its address does.

Errors

If the manifest’s digest cannot be computed.

pub fn manifest_digest(&self) -> Option<&str>

The digest of the manifest this card was derived from, when the card declares one.

Carried as a declared extension rather than a top-level field: the A2A schema forbids unknown properties on a card, so a spec-conforming peer could refuse the whole document over an extra key. The information survives — it is what lets a caller tell two cards with the same name and version apart when the declaration behind them changed. A version string is what an author remembered to bump; a digest is what the document actually says.

impl AgentCard

pub fn sign( &mut self, signer: &dyn CardSigner, ) -> Result<(), CardSignatureError>

Sign this card, appending the signature.

Appending rather than replacing: A2A allows several signatures so a publisher can rotate keys without a window in which nobody can verify the card. Replacing would create exactly that window.

Errors

If the card cannot be canonicalized.

pub fn verify( &self, verifier: &dyn CardVerifier, ) -> Result<KeyId, CardSignatureError>

Check that some signature on this card was made by a trusted key.

Errors

CardSignatureError::Unsigned when there are none, CardSignatureError::WrongAlgorithm for anything but ALG, and CardSignatureError::Untrusted when none verifies.

impl AgentCard

pub fn select_interface( &self, binding: &str, version: &str, ) -> Option<&CardInterface>

The interface a client should use, following the spec’s selection rules.

Ordered: the first entry that speaks the requested binding at a compatible version wins. The order is the publisher’s preference, and scanning for a “best” one instead would quietly override the operator of the agent being called.

Version is matched on Major.Minor, as the spec requires. An agent may publish the same binding at several versions, so ignoring the version would pick an endpoint that speaks a protocol this client does not.

pub fn endpoint(&self) -> Result<Endpoint, DiscoveryError>

An endpoint for this crate’s A2A client, taken from the card.

The tenant travels with it, which is the part a hand-written endpoint gets wrong: A2A says to echo the selected interface’s tenant on every request and to omit it when the interface omits it. A client that skips that can only ever reach an agent serving the default tenant.

Errors

DiscoveryError::NoUsableInterface when nothing on the card speaks JSON-RPC at this crate’s protocol version.

Trait Implementations

impl Clone for AgentCard

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 AgentCard

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for AgentCard

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for AgentCard

impl PartialEq for AgentCard

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for AgentCard

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 AgentCard