adk-tool 0.8.0

Tool system for Rust Agent Development Kit (ADK-Rust) agents (FunctionTool, MCP, Google Search)
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

//! Server status tracking.
//!
//! Defines the [`ServerStatus`] enum representing the current lifecycle state
//! of a managed MCP server.

use serde::{Deserialize, Serialize};

/// Current lifecycle state of a managed MCP server.
///
/// Transitions:
/// - `Stopped` → `Running` (on successful start)
/// - `Stopped` → `FailedToStart` (on start failure)
/// - `Running` → `Stopped` (on manual stop or shutdown)
/// - `Running` → `Crashed` (on health check failure or unexpected exit)
/// - `Running` → `Restarting` (during restart)
/// - `Crashed` → `Restarting` (on auto-restart)
/// - `Restarting` → `Running` (on successful restart)
/// - `Restarting` → `FailedToStart` (on restart failure)
/// - `Disabled` (set at construction, no transitions out unless re-configured)
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum ServerStatus {
    /// The server process is running and the MCP connection is active.
    Running,
    /// The server has been stopped (manually or via shutdown).
    Stopped,
    /// The server process exited unexpectedly or a health check failed.
    Crashed,
    /// The server is in the process of being restarted.
    Restarting,
    /// The server configuration has `disabled: true`; it will not be started.
    Disabled,
    /// The server failed to start (spawn failure, handshake failure, or max restarts exceeded).
    FailedToStart,
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_server_status_clone() {
        let status = ServerStatus::Running;
        let cloned = status;
        assert_eq!(status, cloned);
    }

    #[test]
    fn test_server_status_debug() {
        let status = ServerStatus::Crashed;
        let debug_str = format!("{status:?}");
        assert_eq!(debug_str, "Crashed");
    }

    #[test]
    fn test_server_status_eq() {
        assert_eq!(ServerStatus::Running, ServerStatus::Running);
        assert_ne!(ServerStatus::Running, ServerStatus::Stopped);
    }

    #[test]
    fn test_server_status_hash() {
        use std::collections::HashSet;
        let mut set = HashSet::new();
        set.insert(ServerStatus::Running);
        set.insert(ServerStatus::Stopped);
        set.insert(ServerStatus::Running); // duplicate
        assert_eq!(set.len(), 2);
    }

    #[test]
    fn test_server_status_serde_round_trip() {
        let statuses = [
            ServerStatus::Running,
            ServerStatus::Stopped,
            ServerStatus::Crashed,
            ServerStatus::Restarting,
            ServerStatus::Disabled,
            ServerStatus::FailedToStart,
        ];
        for status in &statuses {
            let json = serde_json::to_string(status).unwrap();
            let deserialized: ServerStatus = serde_json::from_str(&json).unwrap();
            assert_eq!(*status, deserialized);
        }
    }
}