Struct Message 

pub struct Message {
    pub id: MessageId,
    pub role: MessageRole,
    pub parts: Vec<Part>,
    pub task_id: Option<TaskId>,
    pub context_id: Option<ContextId>,
    pub reference_task_ids: Option<Vec<TaskId>>,
    pub extensions: Option<Vec<String>>,
    pub metadata: Option<Value>,
}

A message exchanged between a client and an agent.

Fields

id: MessageId

Unique message identifier.

role: MessageRole

Role of the message originator.

parts: Vec<Part>

Message content parts.

Spec requirement: Must contain at least one element. The A2A protocol does not define behavior for empty parts lists.

Parsing treats absence as empty (ProtoJSON printers omit empty repeated fields; the gRPC binding already decodes it that way) — the server rejects empty parts with a structured invalid-params error instead of a JSON type error, uniformly across bindings.

task_id: Option<TaskId>

Task this message belongs to, if any.

context_id: Option<ContextId>

Conversation context this message belongs to, if any.

reference_task_ids: Option<Vec<TaskId>>

IDs of tasks referenced by this message.

extensions: Option<Vec<String>>

URIs of extensions used in this message.

metadata: Option<Value>

Arbitrary metadata.

Implementations

impl Message

pub fn new( id: impl Into<MessageId>, role: MessageRole, parts: Vec<Part>, ) -> Message

Creates a message with the given id, role and parts.

The five optional fields start as None; set the ones you need with the with_* methods below. Before these existed the only way to make a Message was a struct literal naming all eight fields, and this workspace contained 105 of them — a message carrying one line of text cost ten lines to write, five of which said None.

The id is a parameter rather than something this constructor invents, for the same reason Artifact::new takes one: this crate depends on serde and serde_json and nothing else, so it has no random source to mint one from, and a clock-derived id is not unique under concurrency. Servers in this workspace use uuid::Uuid::new_v4(); a client that already has a correlation id of its own should use that.

use a2a_protocol_types::message::{Message, MessageRole, Part};

let msg = Message::new("m1", MessageRole::User, vec![Part::text("hello")]);
assert_eq!(msg.text(), Some("hello"));
assert_eq!(msg.role, MessageRole::User);

pub fn user(id: impl Into<MessageId>, parts: Vec<Part>) -> Message

Creates a MessageRole::User message with the given parts.

use a2a_protocol_types::message::{Message, MessageRole, Part};

let msg = Message::user("m1", vec![Part::url("https://example.com/f.pdf")]);
assert_eq!(msg.role, MessageRole::User);

pub fn agent(id: impl Into<MessageId>, parts: Vec<Part>) -> Message

Creates a MessageRole::Agent message with the given parts.

use a2a_protocol_types::message::{Message, MessageRole, Part};

let msg = Message::agent("m1", vec![Part::text("done")]);
assert_eq!(msg.role, MessageRole::Agent);

pub fn user_text(id: impl Into<MessageId>, text: impl Into<String>) -> Message

Creates a MessageRole::User message carrying one text part.

The shape almost every caller wants: send this text to an agent.

use a2a_protocol_types::message::Message;

let msg = Message::user_text("m1", "what is the status of order 42?");
assert_eq!(msg.text(), Some("what is the status of order 42?"));
assert_eq!(msg.parts.len(), 1);

pub fn agent_text(id: impl Into<MessageId>, text: impl Into<String>) -> Message

Creates a MessageRole::Agent message carrying one text part.

use a2a_protocol_types::message::Message;

let msg = Message::agent_text("m2", "order 42 shipped on Tuesday");
assert_eq!(msg.text(), Some("order 42 shipped on Tuesday"));

pub fn with_task_id(self, task_id: impl Into<TaskId>) -> Message

Attaches this message to an existing task.

Sending a follow-up without this is what makes it a new task on the same context rather than a continuation of the old one.

use a2a_protocol_types::message::Message;
use a2a_protocol_types::task::TaskId;

let msg = Message::user_text("m2", "and the one after that?")
    .with_task_id("task-1");
assert_eq!(msg.task_id, Some(TaskId::new("task-1")));

pub fn with_context_id(self, context_id: impl Into<ContextId>) -> Message

Places this message in an existing conversation context.

use a2a_protocol_types::message::Message;
use a2a_protocol_types::task::ContextId;

let msg = Message::user_text("m2", "go on").with_context_id("ctx-1");
assert_eq!(msg.context_id, Some(ContextId::new("ctx-1")));

pub fn with_reference_task_ids<I, T>(self, task_ids: I) -> Message

where I: IntoIterator<Item = T>, T: Into<TaskId>,

Names earlier tasks this message refers to.

use a2a_protocol_types::message::Message;

let msg = Message::user_text("m3", "compare those two")
    .with_reference_task_ids(["task-1", "task-2"]);
assert_eq!(msg.reference_task_ids.map(|ids| ids.len()), Some(2));

pub fn with_extensions<I, S>(self, extensions: I) -> Message

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

Declares the extension URIs this message activates.

use a2a_protocol_types::message::Message;

let msg = Message::user_text("m1", "hi")
    .with_extensions(["https://example.com/ext/v1"]);
assert_eq!(msg.extensions.as_deref(), Some(&["https://example.com/ext/v1".to_owned()][..]));

pub fn with_metadata(self, metadata: Value) -> Message

Attaches opaque metadata to this message.

use a2a_protocol_types::message::Message;

let msg = Message::user_text("m1", "hi")
    .with_metadata(serde_json::json!({ "skill": "triage" }));
assert_eq!(msg.metadata.as_ref().and_then(|m| m["skill"].as_str()), Some("triage"));

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

Returns the text of the first text Part, or None if this message carries no text part.

Reading the caller’s text is the most common operation in agent code. This is the one-liner form of the parts.iter().find_map(..) match over PartContent::Text:

use a2a_protocol_types::message::{Message, Part};

let msg = Message::user(
    "m1",
    vec![Part::url("https://example.com/f.pdf"), Part::text("hello")],
);

assert_eq!(msg.text(), Some("hello"));

Non-text parts are skipped rather than ending the search, so a message that leads with a file attachment still yields its text.

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

Returns the text of every text Part, in order, skipping non-text parts.

Use this when a message may carry several text parts and Message::text would silently drop all but the first.

Trait Implementations

impl Clone for Message

fn clone(&self) -> Message

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Message

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Message

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Message

impl PartialEq for Message

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for Message

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 Message

impl TryFrom<Message> for Message

type Error = ConvertError

The type returned in the event of a conversion error.

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

Performs the conversion.

impl TryFrom<Message> for Message

type Error = ConvertError

The type returned in the event of a conversion error.

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

Performs the conversion.