spatio_sdk/apis/
conversations_api.rs

1/*
2 * SpatioAPI
3 *
4 * The REST API that owns every resource in your Spatio workspace: notes, sheets, slides, tasks, calendar events, mail, chat, files, and contacts. SpatioMCP wraps this API; Spatio Desktop reads from it. You can call it directly from your own code.  All requests must be authenticated with a Personal Access Token (`Authorization: Bearer pat_...`) or an OAuth 2.1 access token, and use HTTPS.  Official SDKs (MIT, generated from this spec on every release):  - TypeScript: https://github.com/spatio-labs/spatio-ts (`npm install @spatio-labs/spatio-ts`) - Python: https://github.com/spatio-labs/spatio-py (`pip install spatio-sdk`) - Go: https://github.com/spatio-labs/spatio-go (`go get github.com/spatio-labs/spatio-go`)  This specification is generated from the platform-service Go source on every push to `main`. The spec, not hand-written documentation, is the source of truth: server stubs and SDKs are generated from it, and any drift between the spec and the running service fails CI. 
5 *
6 * The version of the OpenAPI document: v1
7 * Contact: hello@spatio.app
8 * Generated by: https://openapi-generator.tech
9 */
10
11
12use reqwest;
13use serde::{Deserialize, Serialize, de::Error as _};
14use crate::{apis::ResponseContent, models};
15use super::{Error, configuration, ContentType};
16
17
18/// struct for typed errors of method [`create_conversation`]
19#[derive(Debug, Clone, Serialize, Deserialize)]
20#[serde(untagged)]
21pub enum CreateConversationError {
22    Status401(models::ApiError),
23    UnknownValue(serde_json::Value),
24}
25
26/// struct for typed errors of method [`delete_conversation`]
27#[derive(Debug, Clone, Serialize, Deserialize)]
28#[serde(untagged)]
29pub enum DeleteConversationError {
30    Status401(models::ApiError),
31    UnknownValue(serde_json::Value),
32}
33
34/// struct for typed errors of method [`get_conversation`]
35#[derive(Debug, Clone, Serialize, Deserialize)]
36#[serde(untagged)]
37pub enum GetConversationError {
38    Status401(models::ApiError),
39    Status404(models::ApiError),
40    UnknownValue(serde_json::Value),
41}
42
43/// struct for typed errors of method [`get_latest_conversation_for_context`]
44#[derive(Debug, Clone, Serialize, Deserialize)]
45#[serde(untagged)]
46pub enum GetLatestConversationForContextError {
47    Status401(models::ApiError),
48    Status404(models::ApiError),
49    UnknownValue(serde_json::Value),
50}
51
52/// struct for typed errors of method [`list_conversation_messages`]
53#[derive(Debug, Clone, Serialize, Deserialize)]
54#[serde(untagged)]
55pub enum ListConversationMessagesError {
56    Status401(models::ApiError),
57    UnknownValue(serde_json::Value),
58}
59
60/// struct for typed errors of method [`list_conversations`]
61#[derive(Debug, Clone, Serialize, Deserialize)]
62#[serde(untagged)]
63pub enum ListConversationsError {
64    Status401(models::ApiError),
65    UnknownValue(serde_json::Value),
66}
67
68/// struct for typed errors of method [`save_conversation_message`]
69#[derive(Debug, Clone, Serialize, Deserialize)]
70#[serde(untagged)]
71pub enum SaveConversationMessageError {
72    Status401(models::ApiError),
73    UnknownValue(serde_json::Value),
74}
75
76/// struct for typed errors of method [`update_conversation`]
77#[derive(Debug, Clone, Serialize, Deserialize)]
78#[serde(untagged)]
79pub enum UpdateConversationError {
80    Status401(models::ApiError),
81    UnknownValue(serde_json::Value),
82}
83
84/// struct for typed errors of method [`update_conversation_message_metadata`]
85#[derive(Debug, Clone, Serialize, Deserialize)]
86#[serde(untagged)]
87pub enum UpdateConversationMessageMetadataError {
88    Status401(models::ApiError),
89    UnknownValue(serde_json::Value),
90}
91
92
93pub async fn create_conversation(configuration: &configuration::Configuration, create_conversation_request: Option<models::CreateConversationRequest>) -> Result<models::Conversation, Error<CreateConversationError>> {
94    // add a prefix to parameters to efficiently prevent name collisions
95    let p_body_create_conversation_request = create_conversation_request;
96
97    let uri_str = format!("{}/v1/conversations", configuration.base_path);
98    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
99
100    if let Some(ref user_agent) = configuration.user_agent {
101        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
102    }
103    if let Some(ref token) = configuration.bearer_access_token {
104        req_builder = req_builder.bearer_auth(token.to_owned());
105    };
106    req_builder = req_builder.json(&p_body_create_conversation_request);
107
108    let req = req_builder.build()?;
109    let resp = configuration.client.execute(req).await?;
110
111    let status = resp.status();
112    let content_type = resp
113        .headers()
114        .get("content-type")
115        .and_then(|v| v.to_str().ok())
116        .unwrap_or("application/octet-stream");
117    let content_type = super::ContentType::from(content_type);
118
119    if !status.is_client_error() && !status.is_server_error() {
120        let content = resp.text().await?;
121        match content_type {
122            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
123            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::Conversation`"))),
124            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::Conversation`")))),
125        }
126    } else {
127        let content = resp.text().await?;
128        let entity: Option<CreateConversationError> = serde_json::from_str(&content).ok();
129        Err(Error::ResponseError(ResponseContent { status, content, entity }))
130    }
131}
132
133pub async fn delete_conversation(configuration: &configuration::Configuration, id: &str) -> Result<(), Error<DeleteConversationError>> {
134    // add a prefix to parameters to efficiently prevent name collisions
135    let p_path_id = id;
136
137    let uri_str = format!("{}/v1/conversations/{id}", configuration.base_path, id=crate::apis::urlencode(p_path_id));
138    let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str);
139
140    if let Some(ref user_agent) = configuration.user_agent {
141        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
142    }
143    if let Some(ref token) = configuration.bearer_access_token {
144        req_builder = req_builder.bearer_auth(token.to_owned());
145    };
146
147    let req = req_builder.build()?;
148    let resp = configuration.client.execute(req).await?;
149
150    let status = resp.status();
151
152    if !status.is_client_error() && !status.is_server_error() {
153        Ok(())
154    } else {
155        let content = resp.text().await?;
156        let entity: Option<DeleteConversationError> = serde_json::from_str(&content).ok();
157        Err(Error::ResponseError(ResponseContent { status, content, entity }))
158    }
159}
160
161pub async fn get_conversation(configuration: &configuration::Configuration, id: &str) -> Result<models::Conversation, Error<GetConversationError>> {
162    // add a prefix to parameters to efficiently prevent name collisions
163    let p_path_id = id;
164
165    let uri_str = format!("{}/v1/conversations/{id}", configuration.base_path, id=crate::apis::urlencode(p_path_id));
166    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
167
168    if let Some(ref user_agent) = configuration.user_agent {
169        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
170    }
171    if let Some(ref token) = configuration.bearer_access_token {
172        req_builder = req_builder.bearer_auth(token.to_owned());
173    };
174
175    let req = req_builder.build()?;
176    let resp = configuration.client.execute(req).await?;
177
178    let status = resp.status();
179    let content_type = resp
180        .headers()
181        .get("content-type")
182        .and_then(|v| v.to_str().ok())
183        .unwrap_or("application/octet-stream");
184    let content_type = super::ContentType::from(content_type);
185
186    if !status.is_client_error() && !status.is_server_error() {
187        let content = resp.text().await?;
188        match content_type {
189            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
190            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::Conversation`"))),
191            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::Conversation`")))),
192        }
193    } else {
194        let content = resp.text().await?;
195        let entity: Option<GetConversationError> = serde_json::from_str(&content).ok();
196        Err(Error::ResponseError(ResponseContent { status, content, entity }))
197    }
198}
199
200pub async fn get_latest_conversation_for_context(configuration: &configuration::Configuration, context: &str) -> Result<models::Conversation, Error<GetLatestConversationForContextError>> {
201    // add a prefix to parameters to efficiently prevent name collisions
202    let p_query_context = context;
203
204    let uri_str = format!("{}/v1/conversations/latest", configuration.base_path);
205    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
206
207    req_builder = req_builder.query(&[("context", &p_query_context.to_string())]);
208    if let Some(ref user_agent) = configuration.user_agent {
209        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
210    }
211    if let Some(ref token) = configuration.bearer_access_token {
212        req_builder = req_builder.bearer_auth(token.to_owned());
213    };
214
215    let req = req_builder.build()?;
216    let resp = configuration.client.execute(req).await?;
217
218    let status = resp.status();
219    let content_type = resp
220        .headers()
221        .get("content-type")
222        .and_then(|v| v.to_str().ok())
223        .unwrap_or("application/octet-stream");
224    let content_type = super::ContentType::from(content_type);
225
226    if !status.is_client_error() && !status.is_server_error() {
227        let content = resp.text().await?;
228        match content_type {
229            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
230            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::Conversation`"))),
231            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::Conversation`")))),
232        }
233    } else {
234        let content = resp.text().await?;
235        let entity: Option<GetLatestConversationForContextError> = serde_json::from_str(&content).ok();
236        Err(Error::ResponseError(ResponseContent { status, content, entity }))
237    }
238}
239
240pub async fn list_conversation_messages(configuration: &configuration::Configuration, id: &str, limit: Option<i32>, before: Option<&str>) -> Result<Vec<models::ConversationMessage>, Error<ListConversationMessagesError>> {
241    // add a prefix to parameters to efficiently prevent name collisions
242    let p_path_id = id;
243    let p_query_limit = limit;
244    let p_query_before = before;
245
246    let uri_str = format!("{}/v1/conversations/{id}/messages", configuration.base_path, id=crate::apis::urlencode(p_path_id));
247    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
248
249    if let Some(ref param_value) = p_query_limit {
250        req_builder = req_builder.query(&[("limit", &param_value.to_string())]);
251    }
252    if let Some(ref param_value) = p_query_before {
253        req_builder = req_builder.query(&[("before", &param_value.to_string())]);
254    }
255    if let Some(ref user_agent) = configuration.user_agent {
256        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
257    }
258    if let Some(ref token) = configuration.bearer_access_token {
259        req_builder = req_builder.bearer_auth(token.to_owned());
260    };
261
262    let req = req_builder.build()?;
263    let resp = configuration.client.execute(req).await?;
264
265    let status = resp.status();
266    let content_type = resp
267        .headers()
268        .get("content-type")
269        .and_then(|v| v.to_str().ok())
270        .unwrap_or("application/octet-stream");
271    let content_type = super::ContentType::from(content_type);
272
273    if !status.is_client_error() && !status.is_server_error() {
274        let content = resp.text().await?;
275        match content_type {
276            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
277            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec&lt;models::ConversationMessage&gt;`"))),
278            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::ConversationMessage&gt;`")))),
279        }
280    } else {
281        let content = resp.text().await?;
282        let entity: Option<ListConversationMessagesError> = serde_json::from_str(&content).ok();
283        Err(Error::ResponseError(ResponseContent { status, content, entity }))
284    }
285}
286
287pub async fn list_conversations(configuration: &configuration::Configuration, context: Option<&str>, limit: Option<i32>) -> Result<Vec<models::Conversation>, Error<ListConversationsError>> {
288    // add a prefix to parameters to efficiently prevent name collisions
289    let p_query_context = context;
290    let p_query_limit = limit;
291
292    let uri_str = format!("{}/v1/conversations", configuration.base_path);
293    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
294
295    if let Some(ref param_value) = p_query_context {
296        req_builder = req_builder.query(&[("context", &param_value.to_string())]);
297    }
298    if let Some(ref param_value) = p_query_limit {
299        req_builder = req_builder.query(&[("limit", &param_value.to_string())]);
300    }
301    if let Some(ref user_agent) = configuration.user_agent {
302        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
303    }
304    if let Some(ref token) = configuration.bearer_access_token {
305        req_builder = req_builder.bearer_auth(token.to_owned());
306    };
307
308    let req = req_builder.build()?;
309    let resp = configuration.client.execute(req).await?;
310
311    let status = resp.status();
312    let content_type = resp
313        .headers()
314        .get("content-type")
315        .and_then(|v| v.to_str().ok())
316        .unwrap_or("application/octet-stream");
317    let content_type = super::ContentType::from(content_type);
318
319    if !status.is_client_error() && !status.is_server_error() {
320        let content = resp.text().await?;
321        match content_type {
322            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
323            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec&lt;models::Conversation&gt;`"))),
324            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::Conversation&gt;`")))),
325        }
326    } else {
327        let content = resp.text().await?;
328        let entity: Option<ListConversationsError> = serde_json::from_str(&content).ok();
329        Err(Error::ResponseError(ResponseContent { status, content, entity }))
330    }
331}
332
333pub async fn save_conversation_message(configuration: &configuration::Configuration, id: &str, save_message_request: models::SaveMessageRequest) -> Result<models::ConversationMessage, Error<SaveConversationMessageError>> {
334    // add a prefix to parameters to efficiently prevent name collisions
335    let p_path_id = id;
336    let p_body_save_message_request = save_message_request;
337
338    let uri_str = format!("{}/v1/conversations/{id}/messages", configuration.base_path, id=crate::apis::urlencode(p_path_id));
339    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
340
341    if let Some(ref user_agent) = configuration.user_agent {
342        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
343    }
344    if let Some(ref token) = configuration.bearer_access_token {
345        req_builder = req_builder.bearer_auth(token.to_owned());
346    };
347    req_builder = req_builder.json(&p_body_save_message_request);
348
349    let req = req_builder.build()?;
350    let resp = configuration.client.execute(req).await?;
351
352    let status = resp.status();
353    let content_type = resp
354        .headers()
355        .get("content-type")
356        .and_then(|v| v.to_str().ok())
357        .unwrap_or("application/octet-stream");
358    let content_type = super::ContentType::from(content_type);
359
360    if !status.is_client_error() && !status.is_server_error() {
361        let content = resp.text().await?;
362        match content_type {
363            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
364            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ConversationMessage`"))),
365            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ConversationMessage`")))),
366        }
367    } else {
368        let content = resp.text().await?;
369        let entity: Option<SaveConversationMessageError> = serde_json::from_str(&content).ok();
370        Err(Error::ResponseError(ResponseContent { status, content, entity }))
371    }
372}
373
374pub async fn update_conversation(configuration: &configuration::Configuration, id: &str, update_conversation_request: models::UpdateConversationRequest) -> Result<models::Conversation, Error<UpdateConversationError>> {
375    // add a prefix to parameters to efficiently prevent name collisions
376    let p_path_id = id;
377    let p_body_update_conversation_request = update_conversation_request;
378
379    let uri_str = format!("{}/v1/conversations/{id}", configuration.base_path, id=crate::apis::urlencode(p_path_id));
380    let mut req_builder = configuration.client.request(reqwest::Method::PATCH, &uri_str);
381
382    if let Some(ref user_agent) = configuration.user_agent {
383        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
384    }
385    if let Some(ref token) = configuration.bearer_access_token {
386        req_builder = req_builder.bearer_auth(token.to_owned());
387    };
388    req_builder = req_builder.json(&p_body_update_conversation_request);
389
390    let req = req_builder.build()?;
391    let resp = configuration.client.execute(req).await?;
392
393    let status = resp.status();
394    let content_type = resp
395        .headers()
396        .get("content-type")
397        .and_then(|v| v.to_str().ok())
398        .unwrap_or("application/octet-stream");
399    let content_type = super::ContentType::from(content_type);
400
401    if !status.is_client_error() && !status.is_server_error() {
402        let content = resp.text().await?;
403        match content_type {
404            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
405            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::Conversation`"))),
406            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::Conversation`")))),
407        }
408    } else {
409        let content = resp.text().await?;
410        let entity: Option<UpdateConversationError> = serde_json::from_str(&content).ok();
411        Err(Error::ResponseError(ResponseContent { status, content, entity }))
412    }
413}
414
415pub async fn update_conversation_message_metadata(configuration: &configuration::Configuration, id: &str, update_message_metadata_request: models::UpdateMessageMetadataRequest) -> Result<models::ConversationMessage, Error<UpdateConversationMessageMetadataError>> {
416    // add a prefix to parameters to efficiently prevent name collisions
417    let p_path_id = id;
418    let p_body_update_message_metadata_request = update_message_metadata_request;
419
420    let uri_str = format!("{}/v1/conversations/{id}/messages", configuration.base_path, id=crate::apis::urlencode(p_path_id));
421    let mut req_builder = configuration.client.request(reqwest::Method::PATCH, &uri_str);
422
423    if let Some(ref user_agent) = configuration.user_agent {
424        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
425    }
426    if let Some(ref token) = configuration.bearer_access_token {
427        req_builder = req_builder.bearer_auth(token.to_owned());
428    };
429    req_builder = req_builder.json(&p_body_update_message_metadata_request);
430
431    let req = req_builder.build()?;
432    let resp = configuration.client.execute(req).await?;
433
434    let status = resp.status();
435    let content_type = resp
436        .headers()
437        .get("content-type")
438        .and_then(|v| v.to_str().ok())
439        .unwrap_or("application/octet-stream");
440    let content_type = super::ContentType::from(content_type);
441
442    if !status.is_client_error() && !status.is_server_error() {
443        let content = resp.text().await?;
444        match content_type {
445            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
446            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ConversationMessage`"))),
447            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ConversationMessage`")))),
448        }
449    } else {
450        let content = resp.text().await?;
451        let entity: Option<UpdateConversationMessageMetadataError> = serde_json::from_str(&content).ok();
452        Err(Error::ResponseError(ResponseContent { status, content, entity }))
453    }
454}
455
spatio_sdk/apis/conversations_api.rs

spatio_sdk/apis/
conversations_api.rs
