1use futures_util::stream::BoxStream;
2use serde::{Deserialize, Serialize};
3use serde_json::{Map, Value, json};
4
5use super::generative::{
6 Content, Image, StreamEvent, Text, TextResponse, ToolsOrTool, Video, Voice, VoiceEvent,
7};
8use super::socket;
9use crate::ant::persona::PartialDemographic;
10use crate::authentification::CredentialsOrApiKey;
11use crate::error::Result;
12use crate::groups::Group;
13use crate::http::{client, ok};
14
15#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
16pub struct Memory {
17 pub id: u64,
18 pub memory: String,
19 pub scope: String,
20 #[serde(default)]
21 pub embedding: Vec<f64>,
22}
23
24#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
25pub struct Memories {
26 pub nodes: Vec<Memory>,
27 pub edges: Vec<(u64, u64)>,
28 pub scopes: Vec<String>,
29}
30
31pub async fn observe(
34 authorization: &CredentialsOrApiKey,
35 content: &str,
36 group: Option<&Group>,
37) -> Result<Memory> {
38 let mut request = client()
39 .post(format!("{}/agent/memories", super::get_url()))
40 .header(
41 "Authorization",
42 match authorization {
43 CredentialsOrApiKey::Credentials(credentials) => {
44 format!("Token {}", credentials.token)
45 }
46 CredentialsOrApiKey::ApiKey(key) => format!("ApiKey {}", key.id),
47 },
48 );
49 if let Some(group) = group {
50 request = request.header("Group", &group.id);
51 }
52 let response = request.json(&json!({ "content": content })).send().await?;
53 Ok(ok(response).await?.json().await?)
54}
55
56pub async fn recall(
58 authorization: &CredentialsOrApiKey,
59 query: &str,
60 scope: Option<&str>,
61 group: Option<&Group>,
62) -> Result<Vec<Memory>> {
63 let mut request = client()
64 .post(format!("{}/agent/recall", super::get_url()))
65 .header(
66 "Authorization",
67 match authorization {
68 CredentialsOrApiKey::Credentials(credentials) => {
69 format!("Token {}", credentials.token)
70 }
71 CredentialsOrApiKey::ApiKey(key) => format!("ApiKey {}", key.id),
72 },
73 );
74 if let Some(group) = group {
75 request = request.header("Group", &group.id);
76 }
77 let mut body = Map::new();
78 body.insert("query".to_string(), Value::from(query));
79 if let Some(scope) = scope {
80 body.insert("scope".to_string(), Value::from(scope));
81 }
82 let response = request.json(&body).send().await?;
83 Ok(ok(response).await?.json().await?)
84}
85
86pub async fn export_memory(
88 authorization: &CredentialsOrApiKey,
89 group: Option<&Group>,
90) -> Result<Memories> {
91 let mut request = client()
92 .get(format!("{}/agent/memories", super::get_url()))
93 .header(
94 "Authorization",
95 match authorization {
96 CredentialsOrApiKey::Credentials(credentials) => {
97 format!("Token {}", credentials.token)
98 }
99 CredentialsOrApiKey::ApiKey(key) => format!("ApiKey {}", key.id),
100 },
101 );
102 if let Some(group) = group {
103 request = request.header("Group", &group.id);
104 }
105 let response = request.send().await?;
106 Ok(ok(response).await?.json().await?)
107}
108
109pub async fn remove_memory(
111 authorization: &CredentialsOrApiKey,
112 id: u64,
113 group: Option<&Group>,
114) -> Result<()> {
115 let mut request = client()
116 .delete(format!("{}/agent/memories/{id}", super::get_url()))
117 .header(
118 "Authorization",
119 match authorization {
120 CredentialsOrApiKey::Credentials(credentials) => {
121 format!("Token {}", credentials.token)
122 }
123 CredentialsOrApiKey::ApiKey(key) => format!("ApiKey {}", key.id),
124 },
125 );
126 if let Some(group) = group {
127 request = request.header("Group", &group.id);
128 }
129 ok(request.send().await?).await?;
130 Ok(())
131}
132
133pub async fn clear_memory(
135 authorization: &CredentialsOrApiKey,
136 group: Option<&Group>,
137) -> Result<()> {
138 let mut request = client()
139 .delete(format!("{}/agent/memories", super::get_url()))
140 .header(
141 "Authorization",
142 match authorization {
143 CredentialsOrApiKey::Credentials(credentials) => {
144 format!("Token {}", credentials.token)
145 }
146 CredentialsOrApiKey::ApiKey(key) => format!("ApiKey {}", key.id),
147 },
148 );
149 if let Some(group) = group {
150 request = request.header("Group", &group.id);
151 }
152 ok(request.send().await?).await?;
153 Ok(())
154}
155
156#[derive(Debug, Clone, Default)]
161pub struct TextOptions {
162 pub content: Option<Vec<Content>>,
163 pub tools: Option<ToolsOrTool>,
164 pub max_tools: Option<u32>,
165 pub memories: Option<u32>,
166 pub reasoning: Option<String>,
167 pub group: Option<Group>,
168}
169
170pub async fn generate_text(
174 authorization: &CredentialsOrApiKey,
175 model: Text,
176 options: TextOptions,
177) -> Result<BoxStream<'static, StreamEvent>> {
178 socket::stream_text(
179 authorization,
180 "/agent/text",
181 model.as_str(),
182 socket::TextOptions {
183 content: options.content,
184 tools: options.tools,
185 max_tools: options.max_tools,
186 memories: options.memories,
187 reasoning: options.reasoning,
188 group: options.group,
189 },
190 )
191 .await
192}
193
194pub async fn generate_text_sync(
195 authorization: &CredentialsOrApiKey,
196 model: Text,
197 options: TextOptions,
198) -> Result<TextResponse> {
199 socket::collect_text(generate_text(authorization, model, options).await?).await
200}
201
202#[derive(Default)]
204pub struct VoiceOptions {
205 pub content: Option<Vec<Content>>,
206 pub audio: Option<BoxStream<'static, Vec<u8>>>,
207 pub tools: Option<ToolsOrTool>,
208 pub max_tools: Option<u32>,
209 pub voice: Option<PartialDemographic>,
210 pub memories: Option<u32>,
211 pub group: Option<Group>,
212}
213
214pub async fn generate_voice(
216 authorization: &CredentialsOrApiKey,
217 model: Voice,
218 options: VoiceOptions,
219) -> Result<BoxStream<'static, VoiceEvent>> {
220 socket::stream_voice(
221 authorization,
222 "/agent/voice",
223 model.as_str(),
224 socket::VoiceOptions {
225 content: options.content,
226 audio: options.audio,
227 tools: options.tools,
228 max_tools: options.max_tools,
229 voice: options.voice,
230 memories: options.memories,
231 group: options.group,
232 },
233 )
234 .await
235}
236
237pub async fn generate_voice_sync(
238 authorization: &CredentialsOrApiKey,
239 model: Voice,
240 options: VoiceOptions,
241) -> Result<TextResponse> {
242 socket::collect_voice(
243 authorization,
244 generate_voice(authorization, model, options).await?,
245 )
246 .await
247}
248
249#[derive(Debug, Clone, Default)]
251pub struct ImageOptions {
252 pub content: Option<Vec<Content>>,
253 pub size: Option<[u32; 2]>,
254 pub memories: Option<u32>,
255 pub group: Option<Group>,
256}
257
258pub async fn generate_image(
259 authorization: &CredentialsOrApiKey,
260 model: Image,
261 options: ImageOptions,
262) -> Result<TextResponse> {
263 let mut extra = Map::new();
264 if let Some(size) = options.size {
265 extra.insert("size".to_string(), json!(size));
266 }
267 if let Some(memories) = options.memories {
268 extra.insert("memories".to_string(), Value::from(memories));
269 }
270 socket::generate_media(
271 authorization,
272 "/agent/image",
273 model.as_str(),
274 options.content,
275 options.group,
276 extra,
277 "image/png",
278 )
279 .await
280}
281
282#[derive(Debug, Clone, Default)]
284pub struct VideoOptions {
285 pub content: Option<Vec<Content>>,
286 pub duration: Option<f64>,
287 pub size: Option<[u32; 2]>,
288 pub memories: Option<u32>,
289 pub group: Option<Group>,
290}
291
292pub async fn generate_video(
293 authorization: &CredentialsOrApiKey,
294 model: Video,
295 options: VideoOptions,
296) -> Result<TextResponse> {
297 let mut extra = Map::new();
298 if let Some(duration) = options.duration {
299 extra.insert("duration".to_string(), Value::from(duration));
300 }
301 if let Some(size) = options.size {
302 extra.insert("size".to_string(), json!(size));
303 }
304 if let Some(memories) = options.memories {
305 extra.insert("memories".to_string(), Value::from(memories));
306 }
307 socket::generate_media(
308 authorization,
309 "/agent/video",
310 model.as_str(),
311 options.content,
312 options.group,
313 extra,
314 "video/mp4",
315 )
316 .await
317}