Skip to main content

a2a_protocol_client/methods/
send_message.rs

1// SPDX-License-Identifier: Apache-2.0
2// Copyright 2026 Tom F.
3
4//! `SendMessage` and `SendStreamingMessage` client methods.
5
6use a2a_protocol_types::{MessageSendParams, SendMessageResponse};
7
8use crate::client::A2aClient;
9use crate::error::{ClientError, ClientResult};
10use crate::interceptor::{ClientRequest, ClientResponse};
11use crate::streaming::EventStream;
12
13impl A2aClient {
14    /// Sends a message to the agent and waits for a complete response.
15    ///
16    /// Calls the `SendMessage` JSON-RPC method. The agent may respond with
17    /// either a completed [`Task`] or an immediate [`Message`].
18    ///
19    /// # Errors
20    ///
21    /// Returns [`ClientError`] on transport, serialization, or protocol errors.
22    ///
23    /// [`Task`]: a2a_protocol_types::Task
24    /// [`Message`]: a2a_protocol_types::Message
25    pub async fn send_message(
26        &self,
27        params: MessageSendParams,
28    ) -> ClientResult<SendMessageResponse> {
29        const METHOD: &str = "SendMessage";
30
31        let params_value = serde_json::to_value(&params).map_err(ClientError::Serialization)?;
32
33        let mut req = ClientRequest::new(METHOD, params_value);
34        self.interceptors.run_before(&mut req).await?;
35
36        let result = self
37            .transport
38            .send_request(METHOD, req.params, &req.extra_headers)
39            .await?;
40
41        let resp = ClientResponse {
42            method: METHOD.to_owned(),
43            result,
44            status_code: 200,
45        };
46        self.interceptors.run_after(&resp).await?;
47
48        serde_json::from_value::<SendMessageResponse>(resp.result)
49            .map_err(ClientError::Serialization)
50    }
51
52    /// Sends a message and returns a streaming [`EventStream`] of progress
53    /// events.
54    ///
55    /// Calls the `SendStreamingMessage` JSON-RPC method. The agent responds
56    /// with an SSE stream of [`a2a_protocol_types::StreamResponse`] events.
57    ///
58    /// # Errors
59    ///
60    /// Returns [`ClientError`] on transport or protocol errors.
61    pub async fn stream_message(&self, params: MessageSendParams) -> ClientResult<EventStream> {
62        const METHOD: &str = "SendStreamingMessage";
63
64        let params_value = serde_json::to_value(&params).map_err(ClientError::Serialization)?;
65
66        let mut req = ClientRequest::new(METHOD, params_value);
67        self.interceptors.run_before(&mut req).await?;
68
69        self.transport
70            .send_streaming_request(METHOD, req.params, &req.extra_headers)
71            .await
72    }
73}