gopher-mcp-rust 0.1.2-7

Rust SDK for Gopher Orch - AI Agent orchestration framework
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

//! Configuration types for creating agents.

/// Configuration for creating a GopherAgent.
#[derive(Debug, Clone, Default)]
pub struct Config {
    provider: String,
    model: String,
    api_key: Option<String>,
    server_config: Option<String>,
}

impl Config {
    /// Get the provider name.
    pub fn provider(&self) -> &str {
        &self.provider
    }

    /// Get the model name.
    pub fn model(&self) -> &str {
        &self.model
    }

    /// Get the API key (if set).
    pub fn api_key(&self) -> Option<&str> {
        self.api_key.as_deref()
    }

    /// Get the server config JSON (if set).
    pub fn server_config(&self) -> Option<&str> {
        self.server_config.as_deref()
    }

    /// Check if an API key is configured.
    pub fn has_api_key(&self) -> bool {
        self.api_key.as_ref().map_or(false, |k| !k.is_empty())
    }

    /// Check if a server config is configured.
    pub fn has_server_config(&self) -> bool {
        self.server_config.as_ref().map_or(false, |c| !c.is_empty())
    }
}

/// Builder for creating Config instances.
#[derive(Debug, Default)]
pub struct ConfigBuilder {
    config: Config,
}

impl ConfigBuilder {
    /// Create a new ConfigBuilder.
    pub fn new() -> Self {
        Self::default()
    }

    /// Set the provider name.
    pub fn with_provider<S: Into<String>>(mut self, provider: S) -> Self {
        self.config.provider = provider.into();
        self
    }

    /// Set the model name.
    pub fn with_model<S: Into<String>>(mut self, model: S) -> Self {
        self.config.model = model.into();
        self
    }

    /// Set the API key.
    pub fn with_api_key<S: Into<String>>(mut self, api_key: S) -> Self {
        self.config.api_key = Some(api_key.into());
        self
    }

    /// Set the server config JSON.
    pub fn with_server_config<S: Into<String>>(mut self, server_config: S) -> Self {
        self.config.server_config = Some(server_config.into());
        self
    }

    /// Build the Config.
    pub fn build(self) -> Config {
        self.config
    }
}

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

    #[test]
    fn test_builder_with_api_key() {
        let config = ConfigBuilder::new()
            .with_provider("AnthropicProvider")
            .with_model("claude-3-haiku-20240307")
            .with_api_key("test-api-key")
            .build();

        assert_eq!(config.provider(), "AnthropicProvider");
        assert_eq!(config.model(), "claude-3-haiku-20240307");
        assert!(config.has_api_key());
        assert!(!config.has_server_config());
        assert_eq!(config.api_key(), Some("test-api-key"));
    }

    #[test]
    fn test_builder_with_server_config() {
        let server_config = r#"{"succeeded": true}"#;
        let config = ConfigBuilder::new()
            .with_provider("AnthropicProvider")
            .with_model("claude-3-haiku-20240307")
            .with_server_config(server_config)
            .build();

        assert_eq!(config.provider(), "AnthropicProvider");
        assert_eq!(config.model(), "claude-3-haiku-20240307");
        assert!(!config.has_api_key());
        assert!(config.has_server_config());
        assert_eq!(config.server_config(), Some(server_config));
    }

    #[test]
    fn test_empty_config() {
        let config = ConfigBuilder::new().build();

        assert!(!config.has_api_key());
        assert!(!config.has_server_config());
        assert!(config.provider().is_empty());
        assert!(config.model().is_empty());
    }
}