ra2a 0.10.1

A Rust implementation of the Agent2Agent (A2A) Protocol SDK
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

//! Internal JSON-RPC 2.0 wire types and protocol constants.
//!
//! These types are transport-layer details and NOT part of the public API.
//! Items are only used when `client` or `server` features are enabled.

use serde::{Deserialize, Serialize};

use crate::error::JsonRpcError;

/// JSON-RPC 2.0 protocol version.
pub(crate) const VERSION: &str = "2.0";

/// Method name for `message/send`.
pub(crate) const METHOD_MESSAGE_SEND: &str = "message/send";
/// Method name for `message/stream`.
pub(crate) const METHOD_MESSAGE_STREAM: &str = "message/stream";
/// Method name for `tasks/get`.
pub(crate) const METHOD_TASKS_GET: &str = "tasks/get";
/// Method name for `tasks/list`.
pub(crate) const METHOD_TASKS_LIST: &str = "tasks/list";
/// Method name for `tasks/cancel`.
pub(crate) const METHOD_TASKS_CANCEL: &str = "tasks/cancel";
/// Method name for `tasks/resubscribe`.
pub(crate) const METHOD_TASKS_RESUBSCRIBE: &str = "tasks/resubscribe";
/// Method name for `tasks/pushNotificationConfig/get`.
pub(crate) const METHOD_PUSH_CONFIG_GET: &str = "tasks/pushNotificationConfig/get";
/// Method name for `tasks/pushNotificationConfig/create`.
pub(crate) const METHOD_PUSH_CONFIG_CREATE: &str = "tasks/pushNotificationConfig/create";
/// Method name for `tasks/pushNotificationConfig/list`.
pub(crate) const METHOD_PUSH_CONFIG_LIST: &str = "tasks/pushNotificationConfig/list";
/// Method name for `tasks/pushNotificationConfig/delete`.
pub(crate) const METHOD_PUSH_CONFIG_DELETE: &str = "tasks/pushNotificationConfig/delete";
/// Method name for `agent/getAuthenticatedExtendedCard`.
pub(crate) const METHOD_GET_EXTENDED_AGENT_CARD: &str = "agent/getAuthenticatedExtendedCard";

/// A unique identifier for a JSON-RPC request.
///
/// Can be a string, a number, or null — per JSON-RPC 2.0 spec.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(untagged)]
pub(crate) enum RequestId {
    /// String identifier.
    String(String),
    /// Numeric identifier.
    Number(i64),
}

impl Default for RequestId {
    fn default() -> Self {
        Self::String(uuid::Uuid::new_v4().to_string())
    }
}

/// A JSON-RPC 2.0 request object.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub(crate) struct JsonRpcRequest<P> {
    /// Protocol version (always "2.0").
    pub jsonrpc: String,
    /// Request identifier.
    pub id: RequestId,
    /// Method name to invoke.
    pub method: String,
    /// Method parameters.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub params: Option<P>,
}

impl<P> JsonRpcRequest<P> {
    /// Creates a new JSON-RPC request.
    pub(crate) fn new(method: impl Into<String>, params: P) -> Self {
        Self {
            jsonrpc: VERSION.to_owned(),
            id: RequestId::default(),
            method: method.into(),
            params: Some(params),
        }
    }
}

/// A successful JSON-RPC 2.0 response.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub(crate) struct JsonRpcSuccessResponse<R> {
    /// Protocol version (always "2.0").
    pub jsonrpc: String,
    /// The request identifier.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub id: Option<RequestId>,
    /// The result payload.
    pub result: R,
}

impl<R> JsonRpcSuccessResponse<R> {
    /// Creates a new success response.
    pub(crate) fn new(id: Option<RequestId>, result: R) -> Self {
        Self {
            jsonrpc: VERSION.to_owned(),
            id,
            result,
        }
    }
}

/// A JSON-RPC 2.0 error response.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub(crate) struct JsonRpcErrorResponse {
    /// Protocol version (always "2.0").
    pub jsonrpc: String,
    /// The request identifier.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub id: Option<RequestId>,
    /// The error object.
    pub error: JsonRpcError,
}

impl JsonRpcErrorResponse {
    /// Creates a new error response.
    pub(crate) fn new(id: Option<RequestId>, error: JsonRpcError) -> Self {
        Self {
            jsonrpc: VERSION.to_owned(),
            id,
            error,
        }
    }
}

/// A JSON-RPC 2.0 response — either success or error.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub(crate) enum JsonRpcResponse<R> {
    /// A successful response.
    Success(JsonRpcSuccessResponse<R>),
    /// An error response.
    Error(JsonRpcErrorResponse),
}