autogpt 0.4.4

🦀 A Pure Rust Framework For Building AGIs.
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

// Copyright 2026 Mahmoud Harmouch.
//
// Licensed under the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.

//! # MCP runtime types.
//!
//! Defines the data structures that describe discovered MCP tools, their schemas,
//! and the live connection status of each registered server.

use {
    serde::{Deserialize, Serialize},
    serde_json::Value,
    std::collections::HashMap,
    std::fmt::{self, Display, Formatter},
};

/// Live connection state of an MCP server.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum McpServerStatus {
    /// Server has not been connected yet.
    Disconnected,
    /// Connection is currently being established.
    Connecting,
    /// Server is reachable and tools have been discovered.
    Connected,
}

impl Display for McpServerStatus {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Self::Disconnected => write!(f, "DISCONNECTED"),
            Self::Connecting => write!(f, "CONNECTING"),
            Self::Connected => write!(f, "CONNECTED"),
        }
    }
}

/// JSON Schema style parameter definition for a single MCP tool input.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct McpToolParam {
    /// JSON Schema `type` string (e.g. `"string"`, `"integer"`, `"object"`).
    #[serde(rename = "type", default)]
    pub param_type: String,

    /// Human-readable description of the parameter.
    #[serde(default)]
    pub description: String,

    /// Whether this parameter must be provided.
    #[serde(default)]
    pub required: bool,

    /// Allowed enumeration values (when the parameter is an enum).
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub enum_values: Vec<Value>,
}

/// Complete description of a tool exposed by an MCP server.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct McpTool {
    /// Tool name as returned by the MCP server.
    pub name: String,

    /// Fully-qualified name used internally: `mcp_{server_name}_{tool_name}`.
    pub fqn: String,

    /// Human-readable description of what the tool does.
    #[serde(default)]
    pub description: String,

    /// Parameters accepted by this tool, keyed by parameter name.
    #[serde(default)]
    pub params: HashMap<String, McpToolParam>,

    /// Whether required-parameter validation is enforced client-side.
    #[serde(default)]
    pub validate_required: bool,
}

/// Summary information about a connected MCP server, including its live tools.
#[derive(Debug, Clone)]
pub struct McpServerInfo {
    /// Unique server name (matches the key in `settings.mcp`).
    pub name: String,

    /// Current connection state.
    pub status: McpServerStatus,

    /// Short description of the server's purpose (from config or introspection).
    pub description: String,

    /// Tools discovered from this server after successful connection.
    pub tools: Vec<McpTool>,

    /// Error message when the server is in `Disconnected` state due to a failure.
    pub error: Option<String>,
}

/// A request to call a specific MCP tool with the given arguments.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct McpToolCall {
    /// `fqn` of the target tool.
    pub tool_fqn: String,

    /// Arguments matching the tool's parameter schema.
    pub args: HashMap<String, Value>,
}

/// The result returned by executing an MCP tool call.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct McpToolResult {
    /// Whether the execution completed without protocol-level errors.
    pub success: bool,

    /// Primary textual output from the tool (may contain JSON).
    pub content: String,

    /// Optional structured data returned alongside text content.
    pub data: Option<Value>,

    /// Error description when `success` is `false`.
    pub error: Option<String>,
}

// Copyright 2026 Mahmoud Harmouch.
//
// Licensed under the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.