fauna-api 1.0.780

The Fauna SDK for Rust: accounts, Drive, groups, calendar, chats, payments, Parrot and live rooms.
Documentation
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};

/// One provider's settings in a garden.
#[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,
}

/// `Partial<Garden>` in the TypeScript SDK.
#[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>,
}

/// `Partial<Garden> & { provider?, providerConfig? }` in the TypeScript SDK.
#[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
    }
}

/// `Text | Embedding | Image | Video | Speech | Transcription | Voice | Decision`
/// in the TypeScript SDK: any Parrot model.
#[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
);

/// `{ inputPer1M?, outputPer1M?, perUnit?, unit? }` in the TypeScript SDK.
#[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>>,
    /// Decision models: image input and the limits the model accepts.
    #[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>,
}

/// Every model Parrot offers, by family.
#[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?)
}

/// A model id this SDK knows; one it doesn't reads as unset.
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())
}

/// `{ model, reasoning? }` in the TypeScript SDK.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct LastTextModel {
    pub model: Text,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub reasoning: Option<String>,
}

/// The models the caller used last, by family.
#[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>,
}

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?)
}

/// `{ input, output }` in the TypeScript SDK: text tokens spent.
#[derive(Debug, Clone, Copy, Default, PartialEq, Serialize, Deserialize)]
pub struct TokenCost {
    #[serde(default)]
    pub input: f64,
    #[serde(default)]
    pub output: f64,
}

/// `{ cost }` in the TypeScript SDK.
#[derive(Debug, Clone, Copy, Default, PartialEq, Serialize, Deserialize)]
pub struct Cost {
    #[serde(default)]
    pub cost: f64,
}

/// The caller's usage by family: `(model, day, spend)` rows.
#[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(())
}