use std::collections::HashMap;
use std::sync::Arc;
use std::time::Duration;
use reqwest::header::{HeaderMap, HeaderValue, CONTENT_TYPE};
use crate::agents::AgentsModule;
use crate::ai::AIModule;
use crate::api_keys::APIKeysModule;
use crate::error::CencoriError;
use crate::memory::MemoryModule;
use crate::metrics::MetricsModule;
use crate::projects::ProjectsModule;
use crate::sessions::SessionsModule;
use crate::telemetry::TelemetryModule;
use crate::vision::VisionModule;
use crate::voice::VoiceModule;
use crate::documents::DocumentsModule;
use serde_json::Value;
const DEFAULT_BASE_URL: &str = "https://api.cencori.com";
const MAX_RETRIES: u32 = 3;
#[derive(Debug, Clone)]
pub struct InnerClient {
pub(crate) api_key: String,
pub(crate) base_url: String,
#[allow(dead_code)]
pub(crate) headers: HashMap<String, String>,
pub(crate) http_client: reqwest::Client,
pub(crate) blocking_client: reqwest::blocking::Client,
}
impl InnerClient {
fn new(
api_key: String,
base_url: String,
headers: HashMap<String, String>,
timeout: Duration,
) -> Result<Self, CencoriError> {
let mut default_headers = HeaderMap::new();
default_headers.insert(CONTENT_TYPE, HeaderValue::from_static("application/json"));
let api_key_header_val = HeaderValue::from_str(&api_key)
.map_err(|e| CencoriError::config(format!("Invalid API key header: {e}")))?;
default_headers.insert("CENCORI_API_KEY", api_key_header_val);
for (key, val) in &headers {
if let Ok(v) = HeaderValue::from_str(val) {
if let Ok(header_name) = reqwest::header::HeaderName::from_bytes(key.as_bytes()) {
default_headers.insert(header_name, v);
}
}
}
let http_client = reqwest::Client::builder()
.default_headers(default_headers.clone())
.timeout(timeout)
.build()
.map_err(CencoriError::Http)?;
let blocking_client = reqwest::blocking::Client::builder()
.default_headers(default_headers)
.timeout(timeout)
.build()
.map_err(CencoriError::Http)?;
Ok(Self {
api_key,
base_url,
headers,
http_client,
blocking_client,
})
}
pub(crate) fn url(&self, endpoint: &str) -> String {
format!("{}{}", self.base_url, endpoint)
}
}
#[derive(Debug, Clone)]
pub struct ComputeModule;
impl ComputeModule {
pub fn run(&self, _function_name: &str) -> Result<(), CencoriError> {
Err(CencoriError::NotImplemented(
"Compute module coming soon".into(),
))
}
pub async fn async_run(&self, _function_name: &str) -> Result<(), CencoriError> {
Err(CencoriError::NotImplemented(
"Compute module coming soon".into(),
))
}
}
#[derive(Debug, Clone)]
pub struct WorkflowModule;
impl WorkflowModule {
pub fn trigger(&self, _workflow_id: &str) -> Result<(), CencoriError> {
Err(CencoriError::NotImplemented(
"Workflow module coming soon".into(),
))
}
pub async fn async_trigger(&self, _workflow_id: &str) -> Result<(), CencoriError> {
Err(CencoriError::NotImplemented(
"Workflow module coming soon".into(),
))
}
}
#[derive(Debug, Clone, Default)]
pub struct StorageModule {
pub vectors: VectorsSubmodule,
}
impl StorageModule {
pub fn new() -> Self {
Self::default()
}
}
#[derive(Debug, Clone, Default)]
pub struct VectorsSubmodule;
impl VectorsSubmodule {
pub fn search(&self, _query: &str) -> Result<(), CencoriError> {
Err(CencoriError::NotImplemented(
"Storage module coming soon".into(),
))
}
pub fn upsert(&self, _vectors: Value) -> Result<(), CencoriError> {
Err(CencoriError::NotImplemented(
"Storage module coming soon".into(),
))
}
}
#[derive(Debug, Clone)]
pub struct Cencori {
pub(crate) inner: Arc<InnerClient>,
pub ai: AIModule,
pub vision: VisionModule,
pub voice: VoiceModule,
pub documents: DocumentsModule,
pub agents: AgentsModule,
pub projects: ProjectsModule,
pub api_keys: APIKeysModule,
pub metrics: MetricsModule,
pub memory: MemoryModule,
pub telemetry: TelemetryModule,
pub sessions: SessionsModule,
pub compute: ComputeModule,
pub workflow: WorkflowModule,
pub storage: StorageModule,
}
impl Cencori {
pub fn new(
api_key: Option<&str>,
base_url: Option<&str>,
timeout_secs: Option<f64>,
) -> Result<Self, CencoriError> {
let api_key = match api_key {
Some(k) => k.to_string(),
None => std::env::var("CENCORI_API_KEY").map_err(|_| {
CencoriError::config(
"Cencori API key is required. Pass it via Cencori::new(\"csk_...\", None, None) \
or set the CENCORI_API_KEY environment variable.",
)
})?,
};
let base_url = base_url
.unwrap_or(DEFAULT_BASE_URL)
.trim_end_matches('/')
.to_string();
let timeout_secs = timeout_secs.unwrap_or(30.0);
let timeout = Duration::from_secs_f64(timeout_secs);
let inner = Arc::new(InnerClient::new(
api_key,
base_url,
HashMap::new(),
timeout,
)?);
Ok(Self {
ai: AIModule::new(Arc::clone(&inner)),
vision: VisionModule::new(Arc::clone(&inner)),
voice: VoiceModule::new(Arc::clone(&inner)),
documents: DocumentsModule::new(Arc::clone(&inner)),
agents: AgentsModule::new(Arc::clone(&inner)),
projects: ProjectsModule::new(Arc::clone(&inner)),
api_keys: APIKeysModule::new(Arc::clone(&inner)),
metrics: MetricsModule::new(Arc::clone(&inner)),
memory: MemoryModule::new(Arc::clone(&inner)),
telemetry: TelemetryModule::new(Arc::clone(&inner)),
sessions: SessionsModule::new(Arc::clone(&inner)),
compute: ComputeModule,
workflow: WorkflowModule,
storage: StorageModule::new(),
inner,
})
}
pub fn get_base_url(&self) -> &str {
&self.inner.base_url
}
pub fn get_api_key(&self) -> &str {
&self.inner.api_key
}
pub fn get_config(&self) -> std::collections::HashMap<String, String> {
let key = &self.inner.api_key;
let hint = if key.len() > 10 {
format!("{}...{}", &key[..6], &key[key.len() - 4..])
} else {
"...".to_string()
};
let mut config = std::collections::HashMap::new();
config.insert("base_url".to_string(), self.inner.base_url.clone());
config.insert("api_key_hint".to_string(), hint);
config
}
}
pub(crate) fn parse_response(
status: reqwest::StatusCode,
body_str: &str,
) -> Result<Value, CencoriError> {
if status == 401 {
return Err(CencoriError::Authentication);
}
if status == 429 {
return Err(CencoriError::RateLimit);
}
let body: Value = serde_json::from_str(body_str).map_err(CencoriError::Json)?;
if status == 400 {
if let Some(reasons) = body.get("reasons").and_then(|r| r.as_array()) {
let reasons: Vec<String> = reasons
.iter()
.filter_map(|r| r.as_str().map(String::from))
.collect();
return Err(CencoriError::safety(reasons));
}
}
if !status.is_success() {
let message = body
.get("error")
.and_then(|e| e.as_str())
.unwrap_or("Request failed")
.to_string();
return Err(CencoriError::api(status.as_u16(), message));
}
Ok(body)
}