agixt_sdk/client/
agents.rs

1use crate::error::Result;
2use serde::{Deserialize, Serialize};
3use std::collections::HashMap;
4
5#[derive(Debug, Serialize, Deserialize)]
6pub struct Agent {
7    pub settings: HashMap<String, serde_json::Value>,
8    pub commands: HashMap<String, serde_json::Value>,
9}
10
11#[derive(Debug, Serialize)]
12pub struct AgentRequest {
13    pub agent_name: String,
14    #[serde(skip_serializing_if = "HashMap::is_empty")]
15    pub settings: HashMap<String, serde_json::Value>,
16    #[serde(skip_serializing_if = "HashMap::is_empty")]
17    pub commands: HashMap<String, serde_json::Value>,
18    #[serde(skip_serializing_if = "Vec::is_empty")]
19    pub training_urls: Vec<String>,
20}
21
22impl super::AGiXTSDK {
23    /// Add a new agent
24    pub async fn add_agent(
25        &self,
26        agent_name: &str,
27        settings: Option<HashMap<String, serde_json::Value>>,
28        commands: Option<HashMap<String, serde_json::Value>>,
29        training_urls: Option<Vec<String>>,
30    ) -> Result<serde_json::Value> {
31        let request = AgentRequest {
32            agent_name: agent_name.to_string(),
33            settings: settings.unwrap_or_default(),
34            commands: commands.unwrap_or_default(),
35            training_urls: training_urls.unwrap_or_default(),
36        };
37
38        let response = self
39            .client
40            .post(&format!("{}/api/agent", self.base_uri))
41            .headers(self.headers.lock().await.clone())
42            .json(&request)
43            .send()
44            .await?;
45
46        let status = response.status();
47        let text = response.text().await?;
48
49        if self.verbose {
50            self.parse_response(status, &text).await?;
51        }
52
53        Ok(serde_json::from_str(&text)?)
54    }
55
56    /// Import an existing agent
57    pub async fn import_agent(
58        &self,
59        agent_name: &str,
60        settings: Option<HashMap<String, serde_json::Value>>,
61        commands: Option<HashMap<String, serde_json::Value>>,
62    ) -> Result<serde_json::Value> {
63        let request = serde_json::json!({
64            "agent_name": agent_name,
65            "settings": settings.unwrap_or_default(),
66            "commands": commands.unwrap_or_default(),
67        });
68
69        let response = self
70            .client
71            .post(&format!("{}/api/agent/import", self.base_uri))
72            .headers(self.headers.lock().await.clone())
73            .json(&request)
74            .send()
75            .await?;
76
77        let status = response.status();
78        let text = response.text().await?;
79
80        if self.verbose {
81            self.parse_response(status, &text).await?;
82        }
83
84        Ok(serde_json::from_str(&text)?)
85    }
86
87    /// Rename an agent
88    pub async fn rename_agent(&self, agent_name: &str, new_name: &str) -> Result<serde_json::Value> {
89        let response = self
90            .client
91            .patch(&format!("{}/api/agent/{}", self.base_uri, agent_name))
92            .headers(self.headers.lock().await.clone())
93            .json(&serde_json::json!({ "new_name": new_name }))
94            .send()
95            .await?;
96
97        let status = response.status();
98        let text = response.text().await?;
99
100        if self.verbose {
101            self.parse_response(status, &text).await?;
102        }
103
104        Ok(serde_json::from_str(&text)?)
105    }
106
107    /// Update agent settings
108    pub async fn update_agent_settings(
109        &self,
110        agent_name: &str,
111        settings: HashMap<String, serde_json::Value>,
112    ) -> Result<String> {
113        let response = self
114            .client
115            .put(&format!("{}/api/agent/{}", self.base_uri, agent_name))
116            .headers(self.headers.lock().await.clone())
117            .json(&serde_json::json!({
118                "settings": settings,
119                "agent_name": agent_name,
120            }))
121            .send()
122            .await?;
123
124        let status = response.status();
125        let text = response.text().await?;
126
127        if self.verbose {
128            self.parse_response(status, &text).await?;
129        }
130
131        #[derive(Deserialize)]
132        struct MessageResponse {
133            message: String,
134        }
135
136        let result: MessageResponse = serde_json::from_str(&text)?;
137        Ok(result.message)
138    }
139
140    /// Update agent commands
141    pub async fn update_agent_commands(
142        &self,
143        agent_name: &str,
144        commands: HashMap<String, serde_json::Value>,
145    ) -> Result<String> {
146        let response = self
147            .client
148            .put(&format!("{}/api/agent/{}/commands", self.base_uri, agent_name))
149            .headers(self.headers.lock().await.clone())
150            .json(&serde_json::json!({
151                "commands": commands,
152                "agent_name": agent_name,
153            }))
154            .send()
155            .await?;
156
157        let status = response.status();
158        let text = response.text().await?;
159
160        if self.verbose {
161            self.parse_response(status, &text).await?;
162        }
163
164        #[derive(Deserialize)]
165        struct MessageResponse {
166            message: String,
167        }
168
169        let result: MessageResponse = serde_json::from_str(&text)?;
170        Ok(result.message)
171    }
172
173    /// Delete an agent
174    pub async fn delete_agent(&self, agent_name: &str) -> Result<String> {
175        let response = self
176            .client
177            .delete(&format!("{}/api/agent/{}", self.base_uri, agent_name))
178            .headers(self.headers.lock().await.clone())
179            .send()
180            .await?;
181
182        let status = response.status();
183        let text = response.text().await?;
184
185        if self.verbose {
186            self.parse_response(status, &text).await?;
187        }
188
189        #[derive(Deserialize)]
190        struct MessageResponse {
191            message: String,
192        }
193
194        let result: MessageResponse = serde_json::from_str(&text)?;
195        Ok(result.message)
196    }
197
198    /// Get list of all agents
199    pub async fn get_agents(&self) -> Result<Vec<HashMap<String, serde_json::Value>>> {
200        let response = self
201            .client
202            .get(&format!("{}/api/agent", self.base_uri))
203            .headers(self.headers.lock().await.clone())
204            .send()
205            .await?;
206
207        let status = response.status();
208        let text = response.text().await?;
209
210        if self.verbose {
211            self.parse_response(status, &text).await?;
212        }
213
214        #[derive(Deserialize)]
215        struct AgentsResponse {
216            agents: Vec<HashMap<String, serde_json::Value>>,
217        }
218
219        let result: AgentsResponse = serde_json::from_str(&text)?;
220        Ok(result.agents)
221    }
222
223    /// Get agent configuration
224    pub async fn get_agent_config(&self, agent_name: &str) -> Result<HashMap<String, serde_json::Value>> {
225        let response = self
226            .client
227            .get(&format!("{}/api/agent/{}", self.base_uri, agent_name))
228            .headers(self.headers.lock().await.clone())
229            .send()
230            .await?;
231
232        let status = response.status();
233        let text = response.text().await?;
234
235        if self.verbose {
236            self.parse_response(status, &text).await?;
237        }
238
239        #[derive(Deserialize)]
240        struct AgentResponse {
241            agent: HashMap<String, serde_json::Value>,
242        }
243
244        let result: AgentResponse = serde_json::from_str(&text)?;
245        Ok(result.agent)
246    }
247}
248
249#[cfg(test)]
250mod tests {
251    use crate::AGiXTSDK;
252    use mockito;
253
254    #[tokio::test]
255    async fn test_add_agent() {
256        let mut mock_server = mockito::Server::new();
257        let _mock = mock_server
258            .mock("POST", "/api/agent")
259            .with_status(200)
260            .with_header("content-type", "application/json")
261            .with_body(r#"{"message": "Agent created successfully"}"#)
262            .create();
263
264        let client = AGiXTSDK::new(Some(mock_server.url()), None, false);
265        let result = client.add_agent("test_agent", None, None, None).await.unwrap();
266        
267        assert_eq!(result["message"], "Agent created successfully");
268    }
269}
agixt_sdk/client/agents.rs

agixt_sdk/client/
agents.rs
