agixt_sdk/client/
providers.rs

1//! Provider operations using /v1 endpoints.
2
3use crate::error::Result;
4use std::collections::HashMap;
5
6impl super::AGiXTSDK {
7    // ==================== Providers ====================
8
9    /// Get list of available providers.
10    pub async fn get_providers(&self) -> Result<Vec<serde_json::Value>> {
11        let response = self
12            .client
13            .get(&format!("{}/v1/provider", self.base_uri))
14            .headers(self.headers.lock().await.clone())
15            .send()
16            .await?;
17
18        let status = response.status();
19        let text = response.text().await?;
20
21        if self.verbose {
22            self.parse_response(status, &text).await?;
23        }
24
25        // Handle both list (v1) and dict (legacy) responses
26        let data: serde_json::Value = serde_json::from_str(&text)?;
27        if let Some(arr) = data.as_array() {
28            return Ok(arr.clone());
29        }
30        if let Some(obj) = data.as_object() {
31            if let Some(providers) = obj.get("providers").and_then(|v| v.as_array()) {
32                return Ok(providers.clone());
33            }
34        }
35        Ok(vec![])
36    }
37
38    /// Get providers by service type.
39    pub async fn get_providers_by_service(&self, service: &str) -> Result<Vec<serde_json::Value>> {
40        let response = self
41            .client
42            .get(&format!("{}/v1/providers/service/{}", self.base_uri, service))
43            .headers(self.headers.lock().await.clone())
44            .send()
45            .await?;
46
47        let status = response.status();
48        let text = response.text().await?;
49
50        if self.verbose {
51            self.parse_response(status, &text).await?;
52        }
53
54        let data: serde_json::Value = serde_json::from_str(&text)?;
55        if let Some(arr) = data.as_array() {
56            return Ok(arr.clone());
57        }
58        if let Some(obj) = data.as_object() {
59            if let Some(providers) = obj.get("providers").and_then(|v| v.as_array()) {
60                return Ok(providers.clone());
61            }
62        }
63        Ok(vec![])
64    }
65
66    /// Get settings for a specific provider.
67    pub async fn get_provider_settings(&self, provider_name: &str) -> Result<HashMap<String, serde_json::Value>> {
68        let response = self
69            .client
70            .get(&format!("{}/v1/provider/{}", self.base_uri, provider_name))
71            .headers(self.headers.lock().await.clone())
72            .send()
73            .await?;
74
75        let status = response.status();
76        let text = response.text().await?;
77
78        if self.verbose {
79            self.parse_response(status, &text).await?;
80        }
81
82        #[derive(serde::Deserialize)]
83        struct SettingsResponse {
84            settings: HashMap<String, serde_json::Value>,
85        }
86
87        let result: SettingsResponse = serde_json::from_str(&text)?;
88        Ok(result.settings)
89    }
90
91    /// Get list of embedding providers.
92    pub async fn get_embed_providers(&self) -> Result<Vec<String>> {
93        let providers = self.get_providers().await?;
94        let mut embed_providers = Vec::new();
95        
96        for provider in providers {
97            if let Some(obj) = provider.as_object() {
98                if obj.get("supports_embeddings").and_then(|v| v.as_bool()).unwrap_or(false) {
99                    if let Some(name) = obj.get("name").and_then(|v| v.as_str()) {
100                        embed_providers.push(name.to_string());
101                    }
102                }
103            }
104        }
105        
106        Ok(embed_providers)
107    }
108
109    /// Get details of all embedders.
110    pub async fn get_embedders(&self) -> Result<HashMap<String, serde_json::Value>> {
111        let providers = self.get_providers().await?;
112        let mut embedders = HashMap::new();
113        
114        for provider in providers {
115            if let Some(obj) = provider.as_object() {
116                if obj.get("supports_embeddings").and_then(|v| v.as_bool()).unwrap_or(false) {
117                    if let Some(name) = obj.get("name").and_then(|v| v.as_str()) {
118                        embedders.insert(name.to_string(), provider.clone());
119                    }
120                }
121            }
122        }
123        
124        Ok(embedders)
125    }
126
127    // ==================== Extensions ====================
128
129    /// Get extension settings.
130    pub async fn get_extension_settings(&self) -> Result<serde_json::Value> {
131        let response = self
132            .client
133            .get(&format!("{}/v1/extensions/settings", self.base_uri))
134            .headers(self.headers.lock().await.clone())
135            .send()
136            .await?;
137
138        let status = response.status();
139        let text = response.text().await?;
140
141        if self.verbose {
142            self.parse_response(status, &text).await?;
143        }
144
145        #[derive(serde::Deserialize)]
146        struct ExtensionSettingsResponse {
147            extension_settings: serde_json::Value,
148        }
149
150        let result: ExtensionSettingsResponse = serde_json::from_str(&text)?;
151        Ok(result.extension_settings)
152    }
153
154    /// Get all available extensions.
155    pub async fn get_extensions(&self) -> Result<Vec<serde_json::Value>> {
156        let response = self
157            .client
158            .get(&format!("{}/v1/extensions", self.base_uri))
159            .headers(self.headers.lock().await.clone())
160            .send()
161            .await?;
162
163        let status = response.status();
164        let text = response.text().await?;
165
166        if self.verbose {
167            self.parse_response(status, &text).await?;
168        }
169
170        let data: serde_json::Value = serde_json::from_str(&text)?;
171        if let Some(arr) = data.as_array() {
172            return Ok(arr.clone());
173        }
174        if let Some(obj) = data.as_object() {
175            if let Some(extensions) = obj.get("extensions").and_then(|v| v.as_array()) {
176                return Ok(extensions.clone());
177            }
178        }
179        Ok(vec![])
180    }
181
182    /// Get arguments for a command.
183    pub async fn get_command_args(&self, command_name: &str) -> Result<serde_json::Value> {
184        let response = self
185            .client
186            .get(&format!("{}/v1/extensions/{}/args", self.base_uri, command_name))
187            .headers(self.headers.lock().await.clone())
188            .send()
189            .await?;
190
191        let status = response.status();
192        let text = response.text().await?;
193
194        if self.verbose {
195            self.parse_response(status, &text).await?;
196        }
197
198        #[derive(serde::Deserialize)]
199        struct CommandArgsResponse {
200            command_args: serde_json::Value,
201        }
202
203        let result: CommandArgsResponse = serde_json::from_str(&text)?;
204        Ok(result.command_args)
205    }
206}
agixt_sdk/client/providers.rs

agixt_sdk/client/
providers.rs
