agentic 0.0.4

Support library for building Agentic MCP and Agent2Agent based systems
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
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162

use super::types::Tool;
use crate::mcp::{Cursor, GenericMeta, IntoMcpRequest, MessageContent, PaginationParams, ProgressToken, RequestMeta};
use serde::{Deserialize, Serialize};
use serde_json::Value;
use serde_with::skip_serializing_none;
use std::collections::HashMap;

// region:    --- ListToolsRequest

/// Sent from the client to request a list of tools the server has.
///
/// TS Ref: `ListToolsRequest`
#[skip_serializing_none]
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
#[serde(rename_all = "camelCase")]
pub struct ListToolsParams {
	#[serde(rename = "_meta")]
	pub meta: Option<RequestMeta>,

	/// Cursor for pagination
	#[serde(flatten)]
	pub pagination: PaginationParams,
}

/// Builders
impl ListToolsParams {
	/// Same as default (for API consistency)
	pub fn new() -> Self {
		Self::default()
	}

	pub fn with_meta(mut self, meta: RequestMeta) -> Self {
		self.meta = Some(meta);
		self
	}

	pub fn with_pagination(mut self, pagination: PaginationParams) -> Self {
		self.pagination = pagination;
		self
	}

	pub fn with_cursor(mut self, cursor: impl Into<Cursor>) -> Self {
		self.pagination.cursor = Some(cursor.into());
		self
	}
}

impl IntoMcpRequest<ListToolsParams> for ListToolsParams {
	const METHOD: &'static str = "tools/list";
	type McpResult = ListToolsResult;
}

/// The server's response to a tools/list request from the client.
///
/// TS Ref: `ListToolsResult`
#[skip_serializing_none]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ListToolsResult {
	/// Optional metadata
	#[serde(rename = "_meta")]
	pub meta: Option<GenericMeta>,

	/// An opaque token representing the pagination position after the last returned result.
	/// If present, there may be more results available.
	pub next_cursor: Option<Cursor>,

	/// The list of tools
	pub tools: Vec<Tool>,
}

// endregion: --- ListToolsRequest

// region:    --- CallToolRequest

/// Used by the client to invoke a tool provided by the server.
///
/// TS Ref: `CallToolRequest`
#[skip_serializing_none]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CallToolParams {
	#[serde(rename = "_meta")]
	pub meta: Option<RequestMeta>,

	/// The name of the tool.
	pub name: String,

	/// Arguments to use for the tool call.
	/// Note: The TS type uses `unknown`, so `Value` is appropriate here.
	pub arguments: Option<HashMap<String, Value>>,
}

/// Builders
impl CallToolParams {
	pub fn new(name: impl Into<String>) -> Self {
		Self {
			meta: None,
			name: name.into(),
			arguments: None,
		}
	}

	pub fn with_meta(mut self, meta: RequestMeta) -> Self {
		self.meta = Some(meta);
		self
	}

	pub fn with_progress_token(mut self, progress_token: impl Into<ProgressToken>) -> Self {
		self.meta.get_or_insert_with(RequestMeta::default).progress_token = Some(progress_token.into());
		self
	}

	pub fn with_arguments(mut self, arguments: HashMap<String, Value>) -> Self {
		self.arguments = Some(arguments);
		self
	}

	pub fn append_argument(mut self, name: impl Into<String>, value: impl Into<Value>) -> Self {
		self.arguments
			.get_or_insert_with(HashMap::new)
			.insert(name.into(), value.into());

		self
	}
}

impl IntoMcpRequest<CallToolParams> for CallToolParams {
	const METHOD: &'static str = "tools/call";
	type McpResult = CallToolResult;
}

/// The server's response to a tool call.
///
/// Any errors that originate from the tool SHOULD be reported inside the result
/// object, with `isError` set to true, _not_ as an MCP protocol-level error
/// response. Otherwise, the LLM would not be able to see that an error occurred
/// and self-correct.
///
/// However, any errors in _finding_ the tool, an error indicating that the
/// server does not support tool calls, or any other exceptional conditions,
/// should be reported as an MCP error response.
///
/// TS Ref: `CallToolResult`
#[skip_serializing_none]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CallToolResult {
	/// Optional metadata
	#[serde(rename = "_meta")]
	pub meta: Option<GenericMeta>,

	/// The content resulting from the tool call.
	/// Reusing `MessageContent` as it covers Text, Image, Audio, and EmbeddedResource.
	pub content: Vec<MessageContent>,

	/// Whether the tool call ended in an error.
	/// If not set, this is assumed to be false (the call was successful).
	pub is_error: Option<bool>,
}

// endregion: --- CallToolRequest