use std::sync::Arc;
use reqwest::header::CONTENT_TYPE;
use serde::{Deserialize, Serialize};
use serde_json::{json, Value};
use crate::client::{parse_response, InnerClient};
use crate::error::CencoriError;
#[derive(Debug, Clone, Default, Serialize)]
pub struct SpeakParams {
pub input: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub model: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub voice: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub provider: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub response_format: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub speed: Option<f64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub language: Option<String>,
}
impl SpeakParams {
pub fn new(input: impl Into<String>) -> Self {
Self { input: input.into(), ..Default::default() }
}
pub fn with_model(mut self, model: impl Into<String>) -> Self {
self.model = Some(model.into());
self
}
pub fn with_voice(mut self, voice: impl Into<String>) -> Self {
self.voice = Some(voice.into());
self
}
pub fn with_provider(mut self, provider: impl Into<String>) -> Self {
self.provider = Some(provider.into());
self
}
pub fn with_response_format(mut self, format: impl Into<String>) -> Self {
self.response_format = Some(format.into());
self
}
pub fn with_speed(mut self, speed: f64) -> Self {
self.speed = Some(speed);
self
}
pub fn with_language(mut self, language: impl Into<String>) -> Self {
self.language = Some(language.into());
self
}
}
#[derive(Debug, Clone)]
pub struct SpeakResult {
pub audio: Vec<u8>,
pub content_type: String,
pub provider: String,
}
#[derive(Debug, Clone, Default)]
pub struct TranscribeParams {
pub model: Option<String>,
pub provider: Option<String>,
pub language: Option<String>,
pub prompt: Option<String>,
pub temperature: Option<f64>,
pub diarize: bool,
pub response_format: Option<String>,
pub filename: Option<String>,
}
impl TranscribeParams {
pub fn new() -> Self {
Self::default()
}
pub fn with_model(mut self, model: impl Into<String>) -> Self {
self.model = Some(model.into());
self
}
pub fn with_provider(mut self, provider: impl Into<String>) -> Self {
self.provider = Some(provider.into());
self
}
pub fn with_language(mut self, language: impl Into<String>) -> Self {
self.language = Some(language.into());
self
}
pub fn with_prompt(mut self, prompt: impl Into<String>) -> Self {
self.prompt = Some(prompt.into());
self
}
pub fn with_temperature(mut self, temperature: f64) -> Self {
self.temperature = Some(temperature);
self
}
pub fn with_diarize(mut self, diarize: bool) -> Self {
self.diarize = diarize;
self
}
pub fn with_response_format(mut self, format: impl Into<String>) -> Self {
self.response_format = Some(format.into());
self
}
pub fn with_filename(mut self, filename: impl Into<String>) -> Self {
self.filename = Some(filename.into());
self
}
fn format(&self) -> String {
self.response_format.clone().unwrap_or_else(|| "json".to_string())
}
fn file_name(&self) -> String {
self.filename.clone().unwrap_or_else(|| "audio.mp3".to_string())
}
fn fields(&self) -> Vec<(&'static str, String)> {
let mut fields = vec![("response_format", self.format())];
if let Some(v) = &self.model {
fields.push(("model", v.clone()));
}
if let Some(v) = &self.provider {
fields.push(("provider", v.clone()));
}
if let Some(v) = &self.language {
fields.push(("language", v.clone()));
}
if let Some(v) = &self.prompt {
fields.push(("prompt", v.clone()));
}
if let Some(v) = self.temperature {
fields.push(("temperature", v.to_string()));
}
if self.diarize {
fields.push(("diarize", "true".to_string()));
}
fields
}
}
#[derive(Debug, Clone, Deserialize)]
pub struct TranscriptSegment {
#[serde(default)]
pub start: f64,
#[serde(default)]
pub end: f64,
#[serde(default)]
pub text: String,
#[serde(default)]
pub speaker: Option<String>,
}
#[derive(Debug, Clone, Deserialize)]
pub struct TranscriptWord {
#[serde(default)]
pub start: f64,
#[serde(default)]
pub end: f64,
#[serde(default)]
pub word: String,
#[serde(default)]
pub speaker: Option<String>,
}
#[derive(Debug, Clone, Deserialize, Default)]
pub struct TranscribeResult {
#[serde(default)]
pub text: String,
#[serde(default)]
pub language: Option<String>,
#[serde(default)]
pub duration: Option<f64>,
#[serde(default)]
pub provider: Option<String>,
#[serde(default)]
pub model: Option<String>,
#[serde(default)]
pub segments: Option<Vec<TranscriptSegment>>,
#[serde(default)]
pub words: Option<Vec<TranscriptWord>>,
}
const TEXT_FORMATS: [&str; 3] = ["text", "srt", "vtt"];
#[derive(Debug, Clone)]
pub struct VoiceModule {
pub(crate) inner: Arc<InnerClient>,
}
impl VoiceModule {
pub(crate) fn new(inner: Arc<InnerClient>) -> Self {
Self { inner }
}
pub fn speak(&self, params: &SpeakParams) -> Result<SpeakResult, CencoriError> {
if params.input.trim().is_empty() {
return Err(CencoriError::config("voice.speak requires non-empty input"));
}
let url = self.inner.url("/api/ai/audio/speech");
let response = self
.inner
.blocking_client
.post(&url)
.json(&json!(params))
.send()
.map_err(CencoriError::Http)?;
let status = response.status();
if !status.is_success() {
let body = response.text().map_err(CencoriError::Http)?;
return Err(parse_response(status, &body)
.err()
.unwrap_or_else(|| CencoriError::api(status.as_u16(), "Request failed")));
}
let content_type = header(&response, CONTENT_TYPE.as_str());
let provider = header(&response, "x-provider");
let audio = response.bytes().map_err(CencoriError::Http)?.to_vec();
Ok(SpeakResult { audio, content_type, provider })
}
pub fn transcribe(&self, audio: Vec<u8>, params: &TranscribeParams) -> Result<TranscribeResult, CencoriError> {
if audio.is_empty() {
return Err(CencoriError::config("voice.transcribe requires audio bytes"));
}
let mut form = reqwest::blocking::multipart::Form::new().part(
"file",
reqwest::blocking::multipart::Part::bytes(audio).file_name(params.file_name()),
);
for (name, value) in params.fields() {
form = form.text(name, value);
}
let url = self.inner.url("/api/ai/audio/transcriptions");
let response = self
.inner
.blocking_client
.post(&url)
.multipart(form)
.send()
.map_err(CencoriError::Http)?;
let status = response.status();
let body = response.text().map_err(CencoriError::Http)?;
parse_transcript(status, &body, ¶ms.format())
}
pub fn diarize(&self, audio: Vec<u8>, params: &TranscribeParams) -> Result<TranscribeResult, CencoriError> {
let mut p = params.clone();
p.diarize = true;
p.response_format = Some("verbose_json".to_string());
self.transcribe(audio, &p)
}
pub fn list_models(&self) -> Result<Value, CencoriError> {
let tts = self.get_models("/api/ai/audio/speech")?;
let stt = self.get_models("/api/ai/audio/transcriptions")?;
Ok(json!({ "tts": tts, "stt": stt }))
}
fn get_models(&self, path: &str) -> Result<Value, CencoriError> {
let url = self.inner.url(path);
let response = self.inner.blocking_client.get(&url).send().map_err(CencoriError::Http)?;
let status = response.status();
let body = response.text().map_err(CencoriError::Http)?;
let data = parse_response(status, &body)?;
Ok(data.get("models").cloned().unwrap_or_else(|| json!([])))
}
pub async fn async_speak(&self, params: &SpeakParams) -> Result<SpeakResult, CencoriError> {
if params.input.trim().is_empty() {
return Err(CencoriError::config("voice.speak requires non-empty input"));
}
let url = self.inner.url("/api/ai/audio/speech");
let response = self
.inner
.http_client
.post(&url)
.json(&json!(params))
.send()
.await
.map_err(CencoriError::Http)?;
let status = response.status();
if !status.is_success() {
let body = response.text().await.map_err(CencoriError::Http)?;
return Err(parse_response(status, &body)
.err()
.unwrap_or_else(|| CencoriError::api(status.as_u16(), "Request failed")));
}
let content_type = header(&response, CONTENT_TYPE.as_str());
let provider = header(&response, "x-provider");
let audio = response.bytes().await.map_err(CencoriError::Http)?.to_vec();
Ok(SpeakResult { audio, content_type, provider })
}
pub async fn async_transcribe(&self, audio: Vec<u8>, params: &TranscribeParams) -> Result<TranscribeResult, CencoriError> {
if audio.is_empty() {
return Err(CencoriError::config("voice.transcribe requires audio bytes"));
}
let mut form = reqwest::multipart::Form::new().part(
"file",
reqwest::multipart::Part::bytes(audio).file_name(params.file_name()),
);
for (name, value) in params.fields() {
form = form.text(name, value);
}
let url = self.inner.url("/api/ai/audio/transcriptions");
let response = self
.inner
.http_client
.post(&url)
.multipart(form)
.send()
.await
.map_err(CencoriError::Http)?;
let status = response.status();
let body = response.text().await.map_err(CencoriError::Http)?;
parse_transcript(status, &body, ¶ms.format())
}
pub async fn async_diarize(&self, audio: Vec<u8>, params: &TranscribeParams) -> Result<TranscribeResult, CencoriError> {
let mut p = params.clone();
p.diarize = true;
p.response_format = Some("verbose_json".to_string());
self.async_transcribe(audio, &p).await
}
}
fn header<T>(response: &T, name: &str) -> String
where
T: HasHeaders,
{
response.header_value(name)
}
trait HasHeaders {
fn header_value(&self, name: &str) -> String;
}
impl HasHeaders for reqwest::blocking::Response {
fn header_value(&self, name: &str) -> String {
self.headers().get(name).and_then(|v| v.to_str().ok()).unwrap_or("").to_string()
}
}
impl HasHeaders for reqwest::Response {
fn header_value(&self, name: &str) -> String {
self.headers().get(name).and_then(|v| v.to_str().ok()).unwrap_or("").to_string()
}
}
fn parse_transcript(status: reqwest::StatusCode, body: &str, format: &str) -> Result<TranscribeResult, CencoriError> {
if !status.is_success() {
return Err(parse_response(status, body)
.err()
.unwrap_or_else(|| CencoriError::api(status.as_u16(), "Request failed")));
}
if TEXT_FORMATS.contains(&format) {
return Ok(TranscribeResult { text: body.to_string(), ..Default::default() });
}
serde_json::from_str(body).map_err(CencoriError::Json)
}