use std::sync::Arc;
use chrono::{DateTime, SecondsFormat, Utc};
use serde::{Deserialize, Serialize};
use serde_json::{Map, Value, json};
use super::generative::{Content, File as FilePart, Part, Role, file_ref};
use super::room::{ChatRoom, RoomHooks, connect_room};
use super::share::{ChatTarget, OpenRoomOptions, open_room};
use crate::authentification::{CredentialsOrApiKey, Profile};
use crate::billing::PageQuery;
use crate::drive::{self, DriveAuthorization, FileDates};
use crate::error::Result;
use crate::groups::Group;
use crate::http::{client, ok};
use crate::shared::server::Presence;
use crate::termite::versioning::Repository;
#[derive(Default)]
pub struct OpenChatOptions {
pub chat_id: Option<String>,
pub messages: Option<Vec<Content>>,
pub share: Option<bool>,
pub hooks: Option<Arc<dyn RoomHooks>>,
}
#[derive(Clone)]
pub struct OpenedChat {
pub room: ChatRoom,
pub me: Presence,
pub reference: String,
pub code: Option<String>,
}
pub async fn open_chat(
authorization: &CredentialsOrApiKey,
options: OpenChatOptions,
) -> Result<OpenedChat> {
let opened = open_room(
authorization,
OpenRoomOptions {
chat_id: options.chat_id,
messages: options.messages,
share: options.share,
write: None,
},
)
.await?;
let target = match &opened.code {
Some(code) if !code.is_empty() => ChatTarget::Code { code: code.clone() },
_ => ChatTarget::Reference {
reference: opened.reference.clone(),
},
};
let (room, me) = connect_room(authorization, &target, options.hooks).await?;
Ok(OpenedChat {
room,
me,
reference: opened.reference,
code: opened.code,
})
}
#[derive(Debug, Clone, Default)]
pub struct CreateChatOptions {
pub human: Option<bool>,
pub system_prompt: Option<String>,
pub locked: Option<bool>,
pub repository: Option<Repository>,
}
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.as_ref().map(|repository| repository.id),
}))
.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)
}
fn hydrate_file_part(
authorization: &CredentialsOrApiKey,
part: &Value,
group: Option<&Group>,
) -> Part {
let name = part["name"].as_str().unwrap_or("file");
let content_type = part["contentType"]
.as_str()
.unwrap_or("application/octet-stream");
let mut meta = part.clone();
meta["name"] = Value::from(name);
meta["contentType"] = Value::from(content_type);
if let Some(access_code) = part["accessCode"].as_str().filter(|code| !code.is_empty()) {
return Part::File(FilePart {
file: drive::File::from_json(
&meta,
DriveAuthorization::AccessCode {
authorization: authorization.clone(),
access_code: access_code.to_string(),
},
),
});
}
if let Some(path) = part["path"].as_str().filter(|path| !path.is_empty()) {
return Part::File(FilePart {
file: drive::File::from_json(
&meta,
DriveAuthorization::Path {
authorization: authorization.clone(),
path: path.to_string(),
group: part["group"]
.as_str()
.map(str::to_string)
.or_else(|| group.map(|group| group.id.clone())),
},
),
});
}
Part::File(FilePart {
file: drive::from_bytes(
authorization.clone(),
name,
content_type,
Vec::new(),
FileDates::default(),
),
})
}
pub async fn read_chat(
authorization: &CredentialsOrApiKey,
id: &str,
group: Option<&Group>,
query: PageQuery,
) -> Result<Vec<Content>> {
let mut request = client()
.post(format!("{}/chat/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, "cursor": query.cursor, "max": query.max }))
.send()
.await?;
let json: Value = ok(response).await?.json().await?;
let mut messages = Vec::new();
for message in json.as_array().into_iter().flatten() {
let parts = message["parts"]
.as_array()
.into_iter()
.flatten()
.filter_map(|part| {
if part["type"] == "FILE" {
Some(hydrate_file_part(authorization, part, group))
} else {
Part::from_json(part)
}
})
.collect();
messages.push(Content {
parts,
role: serde_json::from_value(message["role"].clone()).unwrap_or(Role::User),
author: Profile::from_json(&message["author"]),
model: message["model"].as_str().map(str::to_string),
created_at: crate::tickets::parse_date(&message["createdAt"]).unwrap_or_default(),
via: match &message["via"] {
Value::Null => None,
Value::String(via) if via.is_empty() => None,
Value::String(via) => Some(via.clone()),
via => Some(via.to_string()),
},
});
}
Ok(messages)
}
pub async fn write_chat(
authorization: &CredentialsOrApiKey,
id: &str,
messages: &[Content],
group: Option<&Group>,
) -> Result<()> {
let mut serialized_messages = Vec::with_capacity(messages.len());
for message in messages {
let mut serialized_parts = Vec::with_capacity(message.parts.len());
for part in &message.parts {
match part {
Part::File(part) if !part.file.online() => {
let file = &part.file;
let dest = format!("tmp/{}-{}", uuid::Uuid::new_v4(), file.name());
let bytes = file.clone().download(false, None).await?;
let mut ready = drive::from_bytes(
authorization.clone(),
&dest,
&file.content_type,
bytes,
FileDates::default(),
);
ready.upload(None).await?;
serialized_parts.push(file_ref(&ready));
}
part => serialized_parts.push(part.wire()),
}
}
let mut wire = Map::new();
wire.insert("parts".to_string(), Value::Array(serialized_parts));
wire.insert("role".to_string(), serde_json::to_value(message.role)?);
if let Some(author) = &message.author {
wire.insert("author".to_string(), serde_json::to_value(author)?);
}
if let Some(model) = &message.model {
wire.insert("model".to_string(), Value::from(model.as_str()));
}
wire.insert(
"createdAt".to_string(),
Value::from(
message
.created_at
.to_rfc3339_opts(SecondsFormat::Millis, true),
),
);
serialized_messages.push(Value::Object(wire));
}
let mut request = client()
.post(format!("{}/chat/write", 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, "messages": serialized_messages }))
.send()
.await?;
ok(response).await?;
Ok(())
}