Struct AgentCard 

pub struct AgentCard {

    pub name: String,
    pub url: Option<String>,
    pub description: String,
    pub version: String,
    pub supported_interfaces: Vec<AgentInterface>,
    pub default_input_modes: Vec<String>,
    pub default_output_modes: Vec<String>,
    pub skills: Vec<AgentSkill>,
    pub capabilities: AgentCapabilities,
    pub provider: Option<AgentProvider>,
    pub icon_url: Option<String>,
    pub documentation_url: Option<String>,
    pub security_schemes: Option<HashMap<String, SecurityScheme>>,
    pub security_requirements: Option<Vec<SecurityRequirement>>,
    pub signatures: Option<Vec<AgentCardSignature>>,
}

The root discovery document for an A2A agent.

Served at /.well-known/agent-card.json. Clients fetch this document to discover the agent’s interfaces, capabilities, skills, and security requirements before establishing a session.

In v1.0, protocol_version and url moved to AgentInterface, and supported_interfaces replaces the old url/preferred_transport/ additional_interfaces fields.

Fields

name: String

Display name of the agent.

url: Option<String>

Primary URL of the agent — accepted on input, never emitted.

This is the v0.3 top-level URL. The v1.0 lf.a2a.v1 AgentCard has no url field at all; supported_interfaces replaced it. Emitting it made this SDK’s card fail the specification’s own JSON schema — 'url' does not match any of the regexes: … — which is what CARD-EXT-001 reports (see docs/official-tck-findings.md §13).

It is still parsed, because a card published by a v0.3 peer carries it and dropping the field would fail those cards outright. The reference implementation does the same, popping url and folding it into supportedInterfaces.

Read it if you have it; to publish an agent’s address, use supported_interfaces.

description: String

Human-readable description of the agent’s purpose.

version: String

Semantic version of this agent implementation.

supported_interfaces: Vec<AgentInterface>

Transport interfaces offered by this agent.

Spec requirement: Must contain at least one element — enforced by validate, not at parse time: ProtoJSON printers omit empty repeated fields, so parsing treats absence as empty and validation reports the real problem instead of a JSON type error.

default_input_modes: Vec<String>

Default MIME types accepted as input.

ProtoJSON printers omit empty repeated fields; absence means empty.

default_output_modes: Vec<String>

Default MIME types produced as output.

ProtoJSON printers omit empty repeated fields; absence means empty.

skills: Vec<AgentSkill>

Skills offered by this agent.

Spec requirement: Must contain at least one element. Parsing treats absence as empty (ProtoJSON omits empty repeated fields).

capabilities: AgentCapabilities

Capability flags.

provider: Option<AgentProvider>

The organization operating this agent.

icon_url: Option<String>

URL of the agent’s icon image.

documentation_url: Option<String>

URL of the agent’s documentation.

security_schemes: Option<HashMap<String, SecurityScheme>>

Named security scheme definitions (OpenAPI-style).

security_requirements: Option<Vec<SecurityRequirement>>

Global security requirements for the agent.

signatures: Option<Vec<AgentCardSignature>>

Cryptographic signatures over this card.

Implementations

impl AgentCard

pub const fn validate(&self) -> Result<(), &'static str>

Validates the agent card for completeness.

Errors

Returns an error if:

• name is empty
• supported_interfaces is empty (spec requires at least one interface)

impl AgentCard

pub fn new( name: impl Into<String>, version: impl Into<String>, interface: AgentInterface, ) -> AgentCard

A card carrying the three things AgentCard::validate requires and nothing else: a name, a version, and one interface.

description starts empty, the mode lists and skills start empty, every optional field starts None, and capabilities start unset (AgentCapabilities::none). Set what you need with the with_* methods below.

use a2a_protocol_types::agent_card::{AgentCard, AgentInterface};

let card = AgentCard::new(
    "my-agent",
    "1.0.0",
    AgentInterface::jsonrpc("http://localhost:3000"),
);

// Valid by construction — the three fields `validate` checks are the
// three `new` requires.
assert!(card.validate().is_ok());
assert_eq!(card.supported_interfaces.len(), 1);

pub fn with_description(self, description: impl Into<String>) -> AgentCard

Sets the human-readable description.

use a2a_protocol_types::agent_card::{AgentCard, AgentInterface};

let card = AgentCard::new("a", "1.0.0", AgentInterface::jsonrpc("http://x"))
    .with_description("Does one thing well");
assert_eq!(card.description, "Does one thing well");

pub fn with_interface(self, interface: AgentInterface) -> AgentCard

Appends another interface.

Additive rather than replacing: a card advertising more than one binding is the normal case for an agent that serves both JSON-RPC and gRPC, and the first interface came from AgentCard::new.

use a2a_protocol_types::agent_card::{AgentCard, AgentInterface};

let card = AgentCard::new("a", "1.0.0", AgentInterface::jsonrpc("http://x/rpc"))
    .with_interface(AgentInterface::grpc("http://x:50051"));
assert_eq!(card.supported_interfaces.len(), 2);

pub fn with_input_modes<I, S>(self, modes: I) -> AgentCard

where I: IntoIterator<Item = S>, S: Into<String>,

Replaces the MIME types the agent accepts by default.

use a2a_protocol_types::agent_card::{AgentCard, AgentInterface};

let card = AgentCard::new("a", "1.0.0", AgentInterface::jsonrpc("http://x"))
    .with_input_modes(["text/plain"]);
assert_eq!(card.default_input_modes, ["text/plain"]);

pub fn with_output_modes<I, S>(self, modes: I) -> AgentCard

where I: IntoIterator<Item = S>, S: Into<String>,

Replaces the MIME types the agent produces by default.

use a2a_protocol_types::agent_card::{AgentCard, AgentInterface};

let card = AgentCard::new("a", "1.0.0", AgentInterface::jsonrpc("http://x"))
    .with_output_modes(["text/plain", "application/json"]);
assert_eq!(card.default_output_modes.len(), 2);

pub fn with_skill(self, skill: AgentSkill) -> AgentCard

Appends a skill.

use a2a_protocol_types::agent_card::{AgentCard, AgentInterface, AgentSkill};

let card = AgentCard::new("a", "1.0.0", AgentInterface::jsonrpc("http://x"))
    .with_skill(AgentSkill::new("echo", "Echo", "Repeats").with_tags(["text"]));
assert_eq!(card.skills.len(), 1);

pub fn with_capabilities(self, capabilities: AgentCapabilities) -> AgentCard

Replaces the declared capabilities.

use a2a_protocol_types::agent_card::{AgentCapabilities, AgentCard, AgentInterface};

let card = AgentCard::new("a", "1.0.0", AgentInterface::jsonrpc("http://x"))
    .with_capabilities(AgentCapabilities::none().with_streaming(true));
assert_eq!(card.capabilities.streaming, Some(true));

pub fn with_provider(self, provider: AgentProvider) -> AgentCard

Sets the organisation publishing this agent.

pub fn with_icon_url(self, url: impl Into<String>) -> AgentCard

Sets the agent’s icon URL.

pub fn with_documentation_url(self, url: impl Into<String>) -> AgentCard

Sets the agent’s documentation URL.

pub fn with_security_schemes( self, schemes: HashMap<String, SecurityScheme>, ) -> AgentCard

Sets the named security schemes this agent understands.

pub fn with_security_requirements( self, reqs: Vec<SecurityRequirement>, ) -> AgentCard

Sets the security requirements that apply to the whole agent.

pub fn with_signatures(self, signatures: Vec<AgentCardSignature>) -> AgentCard

Sets the cryptographic signatures over this card.

Trait Implementations

impl Clone for AgentCard

fn clone(&self) -> AgentCard

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<(), Error>

Formats the value using the given formatter.

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

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for AgentCard

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 TryFrom<AgentCard> for AgentCard

type Error = ConvertError

The type returned in the event of a conversion error.

fn try_from( value: AgentCard, ) -> Result<AgentCard, <AgentCard as TryFrom<AgentCard>>::Error>

Performs the conversion.

impl TryFrom<AgentCard> for AgentCard

type Error = ConvertError

The type returned in the event of a conversion error.

fn try_from( value: AgentCard, ) -> Result<AgentCard, <AgentCard as TryFrom<AgentCard>>::Error>

Performs the conversion.