use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize};
use serde_json::{Value, json};
use crate::authentification::{CredentialsOrApiKey, Profile};
use crate::error::Result;
use crate::groups::Group;
use crate::http::{client, ok};
#[derive(Debug, Clone, Default)]
pub struct CreateChatOptions {
pub human: Option<bool>,
pub system_prompt: Option<String>,
pub locked: Option<bool>,
pub repository: Option<u64>,
}
pub async fn create_chat(
authorization: &CredentialsOrApiKey,
name: Option<&str>,
group: Option<&Group>,
options: CreateChatOptions,
) -> Result<String> {
let mut request = client()
.post(format!("{}/chat/create", super::get_url()))
.header(
"Authorization",
match authorization {
CredentialsOrApiKey::Credentials(credentials) => {
format!("Token {}", credentials.token)
}
CredentialsOrApiKey::ApiKey(key) => format!("ApiKey {}", key.id),
},
);
if let Some(group) = group {
request = request.header("Group", &group.id);
}
let response = request
.json(&json!({
"name": name.unwrap_or("New Chat"),
"human": options.human == Some(true),
"systemPrompt": options.system_prompt,
"locked": options.locked == Some(true),
"repository": options.repository,
}))
.send()
.await?;
let json: serde_json::Value = ok(response).await?.json().await?;
Ok(json["id"].as_str().unwrap_or_default().to_string())
}
pub async fn delete_chat(
authorization: &CredentialsOrApiKey,
id: &str,
group: Option<&Group>,
) -> Result<()> {
let mut request = client()
.post(format!("{}/chat/delete", super::get_url()))
.header(
"Authorization",
match authorization {
CredentialsOrApiKey::Credentials(credentials) => {
format!("Token {}", credentials.token)
}
CredentialsOrApiKey::ApiKey(key) => format!("ApiKey {}", key.id),
},
);
if let Some(group) = group {
request = request.header("Group", &group.id);
}
let response = request.json(&json!({ "id": id })).send().await?;
ok(response).await?;
Ok(())
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct LastMessage {
#[serde(default)]
pub parts: Vec<serde_json::Value>,
pub role: String,
pub created_at: DateTime<Utc>,
pub position: u32,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub author: Option<Profile>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub model: Option<String>,
}
impl LastMessage {
pub fn from_json(json: &Value) -> Option<LastMessage> {
if !json.is_object() {
return None;
}
let created_at = crate::tickets::parse_date(&json["createdAt"])?;
let position = json["position"].as_f64()?;
Some(LastMessage {
parts: json["parts"].as_array().cloned().unwrap_or_default(),
role: match &json["role"] {
Value::Null => String::new(),
Value::String(role) => role.clone(),
role => role.to_string(),
},
created_at,
position: position as u32,
author: Profile::from_json(&json["author"]),
model: json["model"]
.as_str()
.filter(|model| !model.is_empty())
.map(str::to_string),
})
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ChatSummary {
pub id: String,
pub name: String,
pub principal_id: String,
#[serde(default)]
pub human: bool,
#[serde(default)]
pub locked: bool,
#[serde(default)]
pub repository: Option<u64>,
pub created: i64,
pub updated: i64,
#[serde(default)]
pub last: Option<LastMessage>,
#[serde(default)]
pub unread: u32,
}
pub async fn list_chats(
authorization: &CredentialsOrApiKey,
group: Option<&Group>,
) -> Result<Vec<ChatSummary>> {
let mut request = client()
.get(format!("{}/chat/all", super::get_url()))
.header(
"Authorization",
match authorization {
CredentialsOrApiKey::Credentials(credentials) => {
format!("Token {}", credentials.token)
}
CredentialsOrApiKey::ApiKey(key) => format!("ApiKey {}", key.id),
},
);
if let Some(group) = group {
request = request.header("Group", &group.id);
}
let response = request.send().await?;
let rows: Vec<Value> = ok(response).await?.json().await?;
rows.into_iter()
.map(|mut row| {
let last = LastMessage::from_json(&row["last"]);
row["last"] = Value::Null;
let mut summary: ChatSummary = serde_json::from_value(row)?;
summary.last = last;
Ok(summary)
})
.collect()
}
pub async fn rename_chat(
authorization: &CredentialsOrApiKey,
id: &str,
name: &str,
group: Option<&Group>,
) -> Result<()> {
let mut request = client()
.post(format!("{}/chat/rename", super::get_url()))
.header(
"Authorization",
match authorization {
CredentialsOrApiKey::Credentials(credentials) => {
format!("Token {}", credentials.token)
}
CredentialsOrApiKey::ApiKey(key) => format!("ApiKey {}", key.id),
},
);
if let Some(group) = group {
request = request.header("Group", &group.id);
}
let response = request
.json(&json!({ "id": id, "name": name }))
.send()
.await?;
ok(response).await?;
Ok(())
}
pub async fn mark_read(
authorization: &CredentialsOrApiKey,
id: &str,
position: Option<u32>,
group: Option<&Group>,
) -> Result<u32> {
let mut request = client()
.post(format!("{}/chat/mark-read", super::get_url()))
.header(
"Authorization",
match authorization {
CredentialsOrApiKey::Credentials(credentials) => {
format!("Token {}", credentials.token)
}
CredentialsOrApiKey::ApiKey(key) => format!("ApiKey {}", key.id),
},
);
if let Some(group) = group {
request = request.header("Group", &group.id);
}
let response = request
.json(&json!({ "id": id, "position": position }))
.send()
.await?;
let json: Value = ok(response).await?.json().await?;
Ok(json["unread"].as_u64().unwrap_or_default() as u32)
}