Struct Task 

pub struct Task {
    pub id: TaskId,
    pub context_id: ContextId,
    pub status: TaskStatus,
    pub history: Option<Vec<Message>>,
    pub artifacts: Option<Vec<Artifact>>,
    pub metadata: Option<Value>,
}

A unit of work managed by an A2A agent.

The wire kind field ("task") is injected by enclosing discriminated unions such as crate::events::StreamResponse and crate::responses::SendMessageResponse. Standalone Task values received over the wire may include kind; serde silently tolerates unknown fields, so no action is needed on the receiving side.

Fields

id: TaskId

Unique task identifier.

context_id: ContextId

Conversation context this task belongs to.

status: TaskStatus

Current status of the task.

history: Option<Vec<Message>>

Historical messages exchanged during this task.

artifacts: Option<Vec<Artifact>>

Artifacts produced by this task.

metadata: Option<Value>

Arbitrary metadata.

Implementations

impl Task

pub fn new( id: impl Into<TaskId>, context_id: impl Into<ContextId>, status: TaskStatus, ) -> Task

A task in status, with no history, artifacts or metadata — what a custom store or a test builds.

The struct is not #[non_exhaustive], so a literal still compiles; this is the form that keeps compiling when a field is added (N16).

use a2a_protocol_types::task::{Task, TaskState, TaskStatus};

let task = Task::new("t1", "c1", TaskStatus::new(TaskState::Working));
assert_eq!(task.id.as_ref(), "t1");
assert!(task.artifacts.is_none());

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

Returns the text of the first text Part in this task’s artifacts, or None if it produced no text.

Reading the answer out of a finished task is what a caller does with every delegated result, and Task previously had no inherent methods at all, so each caller wrote the walk by hand. Six files under examples/ had written the same artifacts → first → text chain.

This skips artifacts with no text rather than stopping at the first, which is where it differs from the hand-written chain: a task whose first artifact is a file and whose second is text yields that text here and None from artifacts.first().and_then(Artifact::text). It is the same rule Message::text already applies across parts.

It reads artifacts only. A failure reason lives on the status message instead, at task.status.message.

use a2a_protocol_types::artifact::Artifact;
use a2a_protocol_types::message::Part;
use a2a_protocol_types::task::{ContextId, Task, TaskState, TaskStatus};

let task = Task {
    id: "t1".into(),
    context_id: ContextId::new("c1"),
    status: TaskStatus::new(TaskState::Completed),
    history: None,
    artifacts: Some(vec![
        Artifact::new("chart", vec![Part::url("https://example.com/c.png")]),
        Artifact::new("summary", vec![Part::text("revenue rose 4%")]),
    ]),
    metadata: None,
};

assert_eq!(task.text(), Some("revenue rose 4%"));

pub fn failure_class(&self) -> Option<FailureClass>

Why this task failed, when the agent classified it.

Reads the class off the status message, so a caller can branch on a value rather than on prose:

match task.failure_class() {
    Some(c) if c.is_retryable() => { /* back off and try again */ }
    Some(c) if c.needs_human()  => { /* escalate, do not retry */ }
    _ => { /* give up, or inspect `task.status.message` */ }
}

None means the agent classified nothing — an older peer, or one that does not implement the extension. It does not mean the task succeeded; status says that.

pub fn texts(&self) -> impl Iterator<Item = &str>

Returns the text of every text Part across every artifact, in order.

Use this when a task may produce several textual artifacts and Task::text would silently drop all but the first.

Trait Implementations

impl Clone for Task

fn clone(&self) -> Task

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Task

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Task

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Task

impl PartialEq for Task

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for Task

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 Task

impl TryFrom<Task> for Task

type Error = ConvertError

The type returned in the event of a conversion error.

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

Performs the conversion.

impl TryFrom<Task> for Task

type Error = ConvertError

The type returned in the event of a conversion error.

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

Performs the conversion.