feat: LiquidAI and decisions and system one implementations

src/server/decisions.rs

@@ -0,0 +1,160 @@
+use crate::CloudflareCredentials;
+use crate::openai;
+use crate::server::AppState;
+use crate::server::Provider;
+use crate::server::Upstream;
+use crate::server::take_random_by_swapping;
+use axum::Json;
+use axum::extract::State;
+use axum::http::StatusCode;
+use axum::response::IntoResponse;
+use axum::response::Response;
+use axum_extra::routing::TypedPath;
+use ecow::EcoString;
+use headers::Header;
+use headers::authorization::Bearer;
+use mitsein::vec1::Vec1;
+use reqwest::Certificate;
+use secrecy::ExposeSecret;
+use serde::Deserialize;
+use serde_with::DeserializeFromStr;
+use serde_with::SerializeDisplay;
+use std::collections::VecDeque;
+use strum::EnumString;
+use strum::VariantArray;
+
+#[derive(Deserialize, TypedPath)]
+#[typed_path("/v1/decisions")]
+pub struct V1DecisionsPath;
+
+#[derive(
+    Clone, Debug, EnumString, DeserializeFromStr, strum::Display, SerializeDisplay, VariantArray,
+)]
+#[strum(serialize_all = "lowercase")]
+pub enum Shortcut {}
+
+impl Shortcut {
+    fn suggestions(&self) -> Vec<(Provider, EcoString)> {
+        use Provider as P;
+        use Shortcut as S;
+
+        match self {
+            _ => unreachable!()
+        }
+    }
+}
+
+pub struct DecisionsResponse(openai::embeddings::CreateEmbeddingResponse<String>);
+
+impl IntoResponse for DecisionsResponse {
+    fn into_response(self) -> Response {
+        let Self(embeddings) = self;
+
+        Json(embeddings).into_response()
+    }
+}
+
+pub enum DecisionsError {
+    NoneSucceeded,
+}
+
+impl IntoResponse for DecisionsError {
+    fn into_response(self) -> Response {
+        match self {
+            DecisionsError::NoneSucceeded => StatusCode::SERVICE_UNAVAILABLE.into_response(),
+        }
+    }
+}
+
+#[tracing::instrument(skip(state, request))]
+pub async fn create_decision(
+    _: V1DecisionsPath,
+    State(state): State<AppState>,
+    Json(request): Json<openai::decisions::DecisionRequest<Shortcut>>,
+) -> Result<DecisionsResponse, DecisionsError> {
+    let shortcut = request.model.clone();
+    let mut model_upstreams = VecDeque::new();
+
+    for (provider, model) in shortcut.suggestions() {
+        let upstreams: Vec<Upstream> = match provider {
+            Provider::CloudflareWorkersAi => unreachable!(),
+            Provider::GoogleAiStudio => unreachable!(),
+            Provider::Groq => unreachable!(),
+            Provider::HuggingFace => unreachable!(),
+            Provider::LiquidAi => unreachable!(),
+            Provider::Mistral => unreachable!(),
+            Provider::OpenRouter => unreachable!(),
+            Provider::ZAi => unreachable!(),
+        };
+
+        if let Ok(upstreams) = Vec1::try_from(upstreams) {
+            model_upstreams.push_back((model, upstreams));
+        }
+    }
+
+    while let Some((model, upstreams)) = model_upstreams.pop_front() {
+        let (upstream, upstreams) = take_random_by_swapping(upstreams, &mut rand::rng());
+        if let Some(upstreams) = upstreams {
+            model_upstreams.push_back((model.clone(), upstreams));
+        }
+
+        tracing::info!(?model, ?upstream);
+
+        let openai::decisions::DecisionRequest { model: _shortcut, input, questions } = request.clone();
+
+        let request = openai::decisions::DecisionRequest { model, input, questions };
+
+        let client = reqwest::Client::builder()
+            .tls_certs_only(
+                webpki_root_certs::TLS_SERVER_ROOT_CERTS
+                    .iter()
+                    .filter_map(|cert| Certificate::from_der(cert).ok()),
+            )
+            .build()
+            .expect("TODO");
+
+        let mut upstream_request = client.post(upstream.url).json(&request);
+
+        if let Some(api_key) = upstream.api_key {
+            let authorization =
+                headers::Authorization::bearer(api_key.expose_secret()).expect("TODO");
+            upstream_request = upstream_request.header(headers::Authorization::<Bearer>::name(), {
+                let mut vec = vec![];
+
+                authorization.encode(&mut vec);
+
+                let [one] = vec.try_into().expect("TODO");
+
+                one
+            });
+        }
+
+        let upstream_response = match upstream_request.send().await {
+            Ok(upstream_response) => upstream_response,
+            Err(upstream_error) => {
+                tracing::error!(?upstream_error);
+                continue;
+            }
+        };
+
+        if let Err(upstream_error) = upstream_response.error_for_status_ref() {
+            tracing::error!(?upstream_error);
+            match upstream_response.text().await {
+                Ok(body) => tracing::error!(?body),
+                Err(body_error) => tracing::error!(?body_error),
+            };
+            continue;
+        };
+
+        let response = match upstream_response.json().await {
+            Ok(response) => response,
+            Err(json_error) => {
+                tracing::error!(?json_error);
+                continue;
+            }
+        };
+
+        return Ok(DecisionsResponse(response));
+    }
+    Err(DecisionsError::NoneSucceeded)
+}