b5da1940e1
Two parallel atomars in the kei-buddy phase-1 plan. Mirror each other's
architecture: trait + feature-gated backend modules + env-driven dispatch
+ wiremock tests for HTTP backends + subprocess-error test for local.
## kei-tts (text-to-speech)
LOC: 959 across 15 files (largest src/lib.rs 121).
Trait `TtsBackend` + 4 backends behind feature flags:
* elevenlabs — POST api.elevenlabs.io/v1/text-to-speech/{voice}/stream
* openai — POST api.openai.com/v1/audio/speech (tts-1, tts-1-hd)
* google — POST texttospeech.googleapis.com/v1/text:synthesize
(Wavenet voices, base64 audioContent)
* piper — local subprocess to piper-tts binary, raw PCM out
Default features: ["piper"]. all-backends feature gates the rest.
`from_env()` reads KEI_TTS_BACKEND (default piper). Returns Box<dyn TtsBackend>.
Tests: 9 passed (env routing + 3 wiremock backends + piper subprocess error).
## kei-stt (speech-to-text)
LOC: 935 across 13 files (largest whisper_local.rs 181).
Trait `SttBackend` + 3 backends:
* whisper-local — subprocess to `whisper` CLI / faster-whisper,
reads JSON output, parses segments
* deepgram — POST api.deepgram.com/v1/listen (Token auth header,
raw audio body, parses words → Segments)
* openai-whisper — POST api.openai.com/v1/audio/transcriptions
(multipart file + model=whisper-1 +
response_format=verbose_json)
Default features: ["whisper-local"]. all-backends gates the rest.
`from_env()` reads KEI_STT_BACKEND (default whisper-local).
Tests: 10 passed + 1 doc-test (env routing + 5 wiremock + 2 JSON parsers
+ 1 subprocess error + 1 auth-header check).
## Common architecture decisions
* `with_base_url(url)` constructor on each HTTP backend for wiremock
testability — same pattern as kei-llm-router and kei-notify-telegram.
* `tempfile` crate added to kei-stt for whisper-local audio scratch.
* `base64 = { version = "0.22", optional = true }` in kei-tts for
Google's base64-encoded audioContent.
## Verify-before-commit (RULE 0.13 §)
* cargo check -p kei-tts (default + all-backends): PASS
* cargo check -p kei-stt (default + all-backends): PASS
* cargo test -p kei-tts --features all-backends --lib: 9/0
* cargo test -p kei-stt --features all-backends --lib: 10/0
* cargo check --workspace: PASS
STATUS-TRUTH from both agents: shipped=functional, stubs=0,
behaviour-verified=yes.
## Follow-up (deferred, non-blocking)
* Real backend verification needs API keys for ElevenLabs / OpenAI /
Google / Deepgram and piper-tts binary + .onnx model on PATH.
* whisper-local language_detected always None — whisper CLI JSON
schema differs across versions, parse heuristic to be added.
* faster-whisper has different JSON schema from openai-whisper;
current parser covers openai-whisper convention only.
99 lines
3.2 KiB
Rust
99 lines
3.2 KiB
Rust
// SPDX-License-Identifier: Apache-2.0
|
|
// Copyright 2026 <author org>
|
|
//! OpenAI TTS backend — calls `api.openai.com/v1/audio/speech`.
|
|
//!
|
|
//! Supported models: `tts-1` (fast) and `tts-1-hd` (higher quality).
|
|
//! Default voice: `alloy`. Format negotiated via `response_format` field.
|
|
//!
|
|
//! Constructor surface:
|
|
//! * [`OpenAiBackend::from_env`] — reads `OPENAI_API_KEY`.
|
|
//! * [`OpenAiBackend::with_base_url`] — explicit URL + key + model (tests).
|
|
|
|
#![cfg(feature = "openai")]
|
|
|
|
use crate::error::TtsError;
|
|
use crate::request::{AudioFormat, TtsRequest};
|
|
use crate::response::TtsResponse;
|
|
use crate::trait_def::TtsBackend;
|
|
|
|
const DEFAULT_BASE_URL: &str = "https://api.openai.com";
|
|
const DEFAULT_MODEL: &str = "tts-1";
|
|
const DEFAULT_VOICE: &str = "alloy";
|
|
|
|
pub struct OpenAiBackend {
|
|
api_key: String,
|
|
model: String,
|
|
client: reqwest::Client,
|
|
base_url: String,
|
|
}
|
|
|
|
impl OpenAiBackend {
|
|
/// Build from explicit parameters (used in wiremock tests).
|
|
pub fn with_base_url(
|
|
base_url: impl Into<String>,
|
|
api_key: impl Into<String>,
|
|
model: impl Into<String>,
|
|
) -> Self {
|
|
Self {
|
|
api_key: api_key.into(),
|
|
model: model.into(),
|
|
client: reqwest::Client::new(),
|
|
base_url: base_url.into().trim_end_matches('/').to_string(),
|
|
}
|
|
}
|
|
|
|
/// Build from `OPENAI_API_KEY` env var. Reads optional
|
|
/// `KEI_TTS_OPENAI_MODEL` (default `tts-1`).
|
|
pub fn from_env() -> Result<Self, TtsError> {
|
|
let key = std::env::var("OPENAI_API_KEY")
|
|
.map_err(|_| TtsError::MissingEnv("OPENAI_API_KEY".into()))?;
|
|
let model = std::env::var("KEI_TTS_OPENAI_MODEL")
|
|
.unwrap_or_else(|_| DEFAULT_MODEL.to_string());
|
|
Ok(Self::with_base_url(DEFAULT_BASE_URL, key, model))
|
|
}
|
|
|
|
fn format_str(fmt: AudioFormat) -> &'static str {
|
|
match fmt {
|
|
AudioFormat::Mp3 => "mp3",
|
|
AudioFormat::Ogg => "opus",
|
|
AudioFormat::Wav => "wav",
|
|
AudioFormat::Raw => "pcm",
|
|
}
|
|
}
|
|
}
|
|
|
|
#[async_trait::async_trait]
|
|
impl TtsBackend for OpenAiBackend {
|
|
fn name(&self) -> &'static str { "openai" }
|
|
|
|
async fn synth(&self, req: &TtsRequest) -> Result<TtsResponse, TtsError> {
|
|
let url = format!("{}/v1/audio/speech", self.base_url);
|
|
let voice = req.voice_id.as_deref().unwrap_or(DEFAULT_VOICE);
|
|
let body = serde_json::json!({
|
|
"model": self.model,
|
|
"input": req.text,
|
|
"voice": voice,
|
|
"response_format": Self::format_str(req.format),
|
|
});
|
|
let resp = self.client
|
|
.post(&url)
|
|
.bearer_auth(&self.api_key)
|
|
.json(&body)
|
|
.send()
|
|
.await?;
|
|
if !resp.status().is_success() {
|
|
let status = resp.status().as_u16();
|
|
let text = resp.text().await.unwrap_or_default();
|
|
return Err(TtsError::Http(format!("http {status}: {text}")));
|
|
}
|
|
let mime = req.format.mime_type().to_string();
|
|
let bytes = resp.bytes().await
|
|
.map_err(|e| TtsError::Http(e.to_string()))?
|
|
.to_vec();
|
|
Ok(TtsResponse::new(bytes, mime))
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
#[path = "openai_test.rs"]
|
|
mod tests;
|