use std::collections::HashMap;
use std::ops::Deref;
use serde::de::DeserializeOwned;
use serde::{Deserialize, Deserializer, Serialize};
use serde_json::Value;
use super::generative::{Decision, Embedding, Image, Speech, Text, Transcription, Video, Voice};
use crate::authentification::CredentialsOrApiKey;
use crate::error::Result;
use crate::http::{client, encode, ok};
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ProviderConfig {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub api_key: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub system_prompt: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub temperature: Option<f64>,
}
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct Garden {
#[serde(default)]
pub providers: HashMap<String, ProviderConfig>,
#[serde(default)]
pub memories: u32,
}
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct PartialGarden {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub providers: Option<HashMap<String, ProviderConfig>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub memories: Option<u32>,
}
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct GardenUpdate {
#[serde(flatten)]
pub garden: PartialGarden,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub provider: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub provider_config: Option<ProviderConfig>,
}
impl Deref for GardenUpdate {
type Target = PartialGarden;
fn deref(&self) -> &PartialGarden {
&self.garden
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(untagged)]
pub enum TextOrEmbeddingOrImageOrVideoOrSpeechOrTranscriptionOrVoiceOrDecision {
Text(Text),
Embedding(Embedding),
Image(Image),
Video(Video),
Speech(Speech),
Transcription(Transcription),
Voice(Voice),
Decision(Decision),
}
impl TextOrEmbeddingOrImageOrVideoOrSpeechOrTranscriptionOrVoiceOrDecision {
fn as_str(self) -> &'static str {
match self {
Self::Text(model) => model.as_str(),
Self::Embedding(model) => model.as_str(),
Self::Image(model) => model.as_str(),
Self::Video(model) => model.as_str(),
Self::Speech(model) => model.as_str(),
Self::Transcription(model) => model.as_str(),
Self::Voice(model) => model.as_str(),
Self::Decision(model) => model.as_str(),
}
}
}
macro_rules! any_model {
($($variant:ident),*) => {
$(
impl From<$variant> for TextOrEmbeddingOrImageOrVideoOrSpeechOrTranscriptionOrVoiceOrDecision {
fn from(model: $variant) -> Self {
Self::$variant(model)
}
}
)*
};
}
any_model!(
Text,
Embedding,
Image,
Video,
Speech,
Transcription,
Voice,
Decision
);
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct Price {
#[serde(
default,
rename = "inputPer1M",
skip_serializing_if = "Option::is_none"
)]
pub input_per_1m: Option<f64>,
#[serde(
default,
rename = "outputPer1M",
skip_serializing_if = "Option::is_none"
)]
pub output_per_1m: Option<f64>,
#[serde(default, rename = "perUnit", skip_serializing_if = "Option::is_none")]
pub per_unit: Option<f64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub unit: Option<String>,
}
pub async fn get_price(
model: impl Into<TextOrEmbeddingOrImageOrVideoOrSpeechOrTranscriptionOrVoiceOrDecision>,
) -> Result<Price> {
let response = client()
.get(format!(
"{}/routing/price/{}",
super::get_url(),
encode(model.into().as_str())
))
.send()
.await?;
Ok(ok(response).await?.json().await?)
}
pub async fn get_dimensions(model: Embedding) -> Result<u32> {
let response = client()
.get(format!(
"{}/routing/dimensions/{}",
super::get_url(),
encode(model.as_str())
))
.send()
.await?;
let text = ok(response).await?.text().await?;
Ok(text.trim().parse::<f64>().unwrap_or(f64::NAN) as u32)
}
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CatalogModel {
pub model: String,
pub name: String,
pub provider: String,
#[serde(rename = "baseURL")]
pub base_url: String,
pub icon: String,
#[serde(
default,
rename = "inputPer1M",
skip_serializing_if = "Option::is_none"
)]
pub input_per_1m: Option<f64>,
#[serde(
default,
rename = "outputPer1M",
skip_serializing_if = "Option::is_none"
)]
pub output_per_1m: Option<f64>,
#[serde(
default,
rename = "cachedInputPer1M",
skip_serializing_if = "Option::is_none"
)]
pub cached_input_per_1m: Option<f64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub per_unit: Option<f64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub unit: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub kind: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub dimensions: Option<u32>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub reasoning: Option<Vec<String>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub images: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub max_questions: Option<u32>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub max_options: Option<u32>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub input_context_window: Option<u64>,
}
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct Catalog {
#[serde(default)]
pub text: Vec<CatalogModel>,
#[serde(default)]
pub embedding: Vec<CatalogModel>,
#[serde(default)]
pub image: Vec<CatalogModel>,
#[serde(default)]
pub video: Vec<CatalogModel>,
#[serde(default)]
pub speech: Vec<CatalogModel>,
#[serde(default)]
pub transcription: Vec<CatalogModel>,
#[serde(default)]
pub voice: Vec<CatalogModel>,
#[serde(default)]
pub decision: Vec<CatalogModel>,
}
pub async fn get_all() -> Result<Catalog> {
let response = client()
.get(format!("{}/routing/all", super::get_url()))
.header("Content-Type", "application/json")
.send()
.await?;
Ok(ok(response).await?.json().await?)
}
fn known<'de, D: Deserializer<'de>, T: DeserializeOwned>(
deserializer: D,
) -> std::result::Result<Option<T>, D::Error> {
Ok(serde_json::from_value(Value::deserialize(deserializer)?).ok())
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct LastTextModel {
pub model: Text,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub reasoning: Option<String>,
}
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct LastUsedModels {
#[serde(
default,
deserialize_with = "known",
skip_serializing_if = "Option::is_none"
)]
pub text: Option<LastTextModel>,
#[serde(
default,
deserialize_with = "known",
skip_serializing_if = "Option::is_none"
)]
pub embedding: Option<Embedding>,
#[serde(
default,
deserialize_with = "known",
skip_serializing_if = "Option::is_none"
)]
pub image: Option<Image>,
#[serde(
default,
deserialize_with = "known",
skip_serializing_if = "Option::is_none"
)]
pub video: Option<Video>,
#[serde(
default,
deserialize_with = "known",
skip_serializing_if = "Option::is_none"
)]
pub speech: Option<Speech>,
#[serde(
default,
deserialize_with = "known",
skip_serializing_if = "Option::is_none"
)]
pub transcription: Option<Transcription>,
#[serde(
default,
deserialize_with = "known",
skip_serializing_if = "Option::is_none"
)]
pub voice: Option<Voice>,
#[serde(
default,
deserialize_with = "known",
skip_serializing_if = "Option::is_none"
)]
pub decision: Option<Decision>,
}
pub async fn get_last_used_models(authorization: &CredentialsOrApiKey) -> Result<LastUsedModels> {
let response = client()
.get(format!("{}/routing/last", super::get_url()))
.header(
"Authorization",
match authorization {
CredentialsOrApiKey::Credentials(credentials) => {
format!("Token {}", credentials.token)
}
CredentialsOrApiKey::ApiKey(key) => format!("ApiKey {}", key.id),
},
)
.send()
.await?;
Ok(ok(response).await?.json().await?)
}
pub async fn set_last_used_models(
authorization: &CredentialsOrApiKey,
models: &LastUsedModels,
) -> Result<()> {
let response = client()
.put(format!("{}/routing/last", super::get_url()))
.header(
"Authorization",
match authorization {
CredentialsOrApiKey::Credentials(credentials) => {
format!("Token {}", credentials.token)
}
CredentialsOrApiKey::ApiKey(key) => format!("ApiKey {}", key.id),
},
)
.json(models)
.send()
.await?;
ok(response).await?;
Ok(())
}
#[derive(Debug, Clone, Copy, Default, PartialEq, Serialize, Deserialize)]
pub struct TokenCost {
#[serde(default)]
pub input: f64,
#[serde(default)]
pub output: f64,
}
#[derive(Debug, Clone, Copy, Default, PartialEq, Serialize, Deserialize)]
pub struct Cost {
#[serde(default)]
pub cost: f64,
}
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ModelUsage {
#[serde(default)]
pub text: Vec<(String, String, TokenCost)>,
#[serde(default)]
pub embedding: Vec<(String, String, Cost)>,
#[serde(default)]
pub image: Vec<(String, String, Cost)>,
#[serde(default)]
pub video: Vec<(String, String, Cost)>,
#[serde(default)]
pub speech: Vec<(String, String, Cost)>,
#[serde(default)]
pub transcription: Vec<(String, String, Cost)>,
#[serde(default)]
pub voice: Vec<(String, String, Cost)>,
#[serde(default)]
pub decision: Vec<(String, String, Cost)>,
}
pub async fn get_usage(authorization: &CredentialsOrApiKey) -> Result<ModelUsage> {
let response = client()
.get(format!("{}/routing/usage", super::get_url()))
.header(
"Authorization",
match authorization {
CredentialsOrApiKey::Credentials(credentials) => {
format!("Token {}", credentials.token)
}
CredentialsOrApiKey::ApiKey(key) => format!("ApiKey {}", key.id),
},
)
.send()
.await?;
Ok(ok(response).await?.json().await?)
}
pub async fn get_garden(authorization: &CredentialsOrApiKey) -> Result<Garden> {
let response = client()
.get(format!("{}/routing/garden", super::get_url()))
.header(
"Authorization",
match authorization {
CredentialsOrApiKey::Credentials(credentials) => {
format!("Token {}", credentials.token)
}
CredentialsOrApiKey::ApiKey(key) => format!("ApiKey {}", key.id),
},
)
.send()
.await?;
Ok(ok(response).await?.json().await?)
}
pub async fn set_garden(authorization: &CredentialsOrApiKey, update: &GardenUpdate) -> Result<()> {
let response = client()
.put(format!("{}/routing/garden", super::get_url()))
.header(
"Authorization",
match authorization {
CredentialsOrApiKey::Credentials(credentials) => {
format!("Token {}", credentials.token)
}
CredentialsOrApiKey::ApiKey(key) => format!("ApiKey {}", key.id),
},
)
.json(update)
.send()
.await?;
ok(response).await?;
Ok(())
}