feat(clients): google cloud voice: generic client, TTS, STT, Gemini audio, live voice page

src/google: GoogleClient over molo::clients (key in x-goog-api-key, never in
URLs), Service base, TextToSpeech, SpeechToText, Generative (replies, audio
in, audio out), Recognizer/Synthesizer seams with cloud, gemini and vertex
backends, VoicePipeline with bounded history. Example: /voice live
conversation page, /voice/{say,hear,turn,reset}, /google/status. Keys load
from env, .env.json.local, .env.json. Paid routes are excluded from locust.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
This commit is contained in:
2026-10-24 04:05:41 +02:00
co-authored by Claude Sonnet 5.5
parent dd773d3015
commit 837de58136
54 changed files with 3086 additions and 21 deletions
+519
View File
@@ -0,0 +1,519 @@
// Google Cloud part: request shape, credential placement, error mapping,
// caps, and the voice pipeline, all against a scripted transport.
#include <memory>
#include "framework.h"
#include "google/caps.h"
#include "google/client.h"
#include "google/credentials.h"
#include "google/endpoints.h"
#include "google/gemini_voice.h"
#include "google/generative.h"
#include "google/voice_backend.h"
#include "google/wav.h"
#include "google/speech_to_text.h"
#include "google/text_to_speech.h"
#include "google/voice.h"
#include "clients/transports/mock_transport.h"
#include "security/crypto/Base64.h"
using namespace molo::google;
using molo::clients::ClientResponse;
using molo::clients::HeaderMap;
using molo::clients::Method;
using molo::clients::transports::MockTransport;
using molo::clients::body::Json;
using molo::security::crypto::Base64;
namespace {
const char* kKey = "AIzaSECRETKEY123";
ClientResponse json_ok(const std::string& body, int status = 200) {
HeaderMap h;
h.set("Content-Type", "application/json");
return ClientResponse(status, h, body);
}
struct Rig {
MockTransport* mock;
std::shared_ptr<GoogleClient> client;
explicit Rig(bool with_key = true) {
auto transport = std::make_unique<MockTransport>();
mock = transport.get();
client = std::make_shared<GoogleClient>(
std::move(transport), with_key ? Credentials::api_key(kKey) : nullptr);
}
void tts_ok(const std::string& mp3 = "MP3DATA") {
mock->expect_response(Method::kPost, "/v1/text:synthesize",
json_ok("{\"audioContent\":\"" + Base64::encode(mp3) + "\"}"));
}
void stt_ok(const std::string& text) {
mock->expect_response(
Method::kPost, "/v1/speech:recognize",
json_ok("{\"results\":[{\"alternatives\":[{\"transcript\":\"" + text +
"\",\"confidence\":0.9}]}]}"));
}
void gemini_ok(const std::string& text) {
mock->expect_response(
Method::kPost, "/v1beta/models/m1:generateContent",
json_ok("{\"candidates\":[{\"content\":{\"parts\":[{\"text\":\"" + text +
"\"}]}}]}"));
}
};
std::shared_ptr<VoicePipeline> pipeline(Rig& rig,
std::shared_ptr<VoiceSessions> s = nullptr) {
auto gen = std::make_shared<Generative>(rig.client);
return std::make_shared<VoicePipeline>(
std::make_shared<SpeechToText>(rig.client),
std::make_shared<GenerativeResponder>(gen),
std::make_shared<TextToSpeech>(rig.client),
s ? s : std::make_shared<VoiceSessions>());
}
} // namespace
TEST(google, key_in_header_never_in_url) {
Rig rig;
rig.tts_ok();
TextToSpeech tts(rig.client);
SynthesisRequest req;
req.text = "hallo";
tts.synthesize(req);
auto seen = rig.mock->seen();
ASSERT_EQ(seen.size(), 1u);
ASSERT_EQ(seen[0].headers.get_or("x-goog-api-key", ""), std::string(kKey));
ASSERT_TRUE(seen[0].target.find(kKey) == std::string::npos);
}
TEST(google, not_configured_fails_before_network) {
Rig rig(false);
TextToSpeech tts(rig.client);
SynthesisRequest req;
req.text = "hallo";
try {
tts.synthesize(req);
FAIL("expected NotConfiguredError");
} catch (const NotConfiguredError& e) {
ASSERT_EQ(e.http_status(), 503);
ASSERT_EQ(e.status(), "NOT_CONFIGURED");
}
ASSERT_EQ(rig.mock->send_count(), 0u);
ASSERT_FALSE(tts.configured());
}
TEST(google, tts_request_shape_and_decode) {
Rig rig;
rig.tts_ok("AUDIO!");
TextToSpeech tts(rig.client);
SynthesisRequest req;
req.text = "hoi";
req.language = "nl-NL";
req.voice = "nl-NL-Wavenet-A";
Audio a = tts.synthesize(req);
ASSERT_EQ(a.bytes, "AUDIO!");
ASSERT_EQ(a.mime, "audio/mpeg");
Json body = Json::parse(rig.mock->seen()[0].body);
ASSERT_EQ(body.find("input")->find("text")->as_string(), "hoi");
ASSERT_EQ(body.find("voice")->find("languageCode")->as_string(), "nl-NL");
ASSERT_EQ(body.find("voice")->find("name")->as_string(), "nl-NL-Wavenet-A");
ASSERT_EQ(body.find("audioConfig")->find("audioEncoding")->as_string(), "MP3");
}
TEST(google, tts_rejects_bad_input_without_network) {
Rig rig;
TextToSpeech tts(rig.client);
SynthesisRequest req;
ASSERT_THROW(tts.synthesize(req), GoogleError); // empty
req.text = std::string(Caps::kMaxTtsChars + 1, 'a');
ASSERT_THROW(tts.synthesize(req), GoogleError); // over cap
req.text = "ok";
req.speaking_rate = 9.0;
ASSERT_THROW(tts.synthesize(req), GoogleError); // rate
ASSERT_EQ(rig.mock->send_count(), 0u);
}
TEST(google, tts_voices_list) {
Rig rig;
rig.mock->expect_response(
Method::kGet, "/v1/voices",
json_ok("{\"voices\":[{\"name\":\"nl-NL-Wavenet-A\",\"ssmlGender\":"
"\"FEMALE\",\"languageCodes\":[\"nl-NL\"]}]}"));
auto v = TextToSpeech(rig.client).voices("nl-NL");
ASSERT_EQ(v.size(), 1u);
ASSERT_EQ(v[0].name, "nl-NL-Wavenet-A");
ASSERT_EQ(v[0].languages[0], "nl-NL");
}
TEST(google, error_mapping_hides_key) {
Rig rig;
rig.mock->expect_response(
Method::kPost, "/v1/text:synthesize",
json_ok("{\"error\":{\"code\":403,\"message\":\"API not enabled\","
"\"status\":\"PERMISSION_DENIED\"}}",
403));
SynthesisRequest req;
req.text = "x";
try {
TextToSpeech(rig.client).synthesize(req);
FAIL("expected GoogleError");
} catch (const GoogleError& e) {
ASSERT_EQ(e.http_status(), 403);
ASSERT_EQ(e.status(), "PERMISSION_DENIED");
ASSERT_EQ(e.service(), "texttospeech");
ASSERT_TRUE(std::string(e.what()).find("API not enabled") != std::string::npos);
ASSERT_TRUE(std::string(e.what()).find(kKey) == std::string::npos);
}
}
TEST(google, non_json_error_body) {
Rig rig;
rig.mock->expect_status(Method::kPost, "/v1/text:synthesize", 400, "<html>");
SynthesisRequest req;
req.text = "x";
try {
TextToSpeech(rig.client).synthesize(req);
FAIL("expected GoogleError");
} catch (const GoogleError& e) {
ASSERT_EQ(e.http_status(), 400);
ASSERT_EQ(e.status(), "UNKNOWN");
}
}
TEST(google, transport_failure_becomes_unavailable) {
Rig rig;
rig.mock->expect_error(
Method::kPost, "/v1/text:synthesize",
std::make_exception_ptr(molo::clients::TransportError("boom")));
SynthesisRequest req;
req.text = "x";
try {
TextToSpeech(rig.client).synthesize(req);
FAIL("expected GoogleError");
} catch (const GoogleError& e) {
ASSERT_EQ(e.status(), "UNAVAILABLE");
}
}
TEST(google, stt_request_shape_and_join) {
Rig rig;
rig.mock->expect_response(
Method::kPost, "/v1/speech:recognize",
json_ok("{\"results\":[{\"alternatives\":[{\"transcript\":\"hallo\","
"\"confidence\":0.8}]},{\"alternatives\":[{\"transcript\":"
"\"wereld\"}]}]}"));
RecognitionRequest req;
req.audio = "RAWAUDIO";
Transcript t = SpeechToText(rig.client).recognize(req);
ASSERT_EQ(t.text, "hallo wereld");
ASSERT_TRUE(t.confidence > 0.79 && t.confidence < 0.81);
Json body = Json::parse(rig.mock->seen()[0].body);
ASSERT_EQ(body.find("config")->find("encoding")->as_string(), "WEBM_OPUS");
ASSERT_EQ(body.find("config")->find("languageCode")->as_string(), "nl-NL");
ASSERT_EQ(body.find("audio")->find("content")->as_string(),
Base64::encode("RAWAUDIO"));
}
TEST(google, stt_silence_is_empty_transcript) {
Rig rig;
rig.mock->expect_response(Method::kPost, "/v1/speech:recognize", json_ok("{}"));
RecognitionRequest req;
req.audio = "x";
ASSERT_EQ(SpeechToText(rig.client).recognize(req).text, "");
}
TEST(google, stt_rejects_bad_audio_without_network) {
Rig rig;
SpeechToText stt(rig.client);
RecognitionRequest req;
ASSERT_THROW(stt.recognize(req), GoogleError);
req.audio = std::string(Caps::kMaxSttBytes + 1, 'a');
ASSERT_THROW(stt.recognize(req), GoogleError);
ASSERT_EQ(rig.mock->send_count(), 0u);
}
TEST(google, stt_encoding_from_mime) {
SpeechEncoding e;
ASSERT_TRUE(speech_encoding_from_mime("audio/webm;codecs=opus", e));
ASSERT_EQ(std::string(speech_encoding_name(e)), "WEBM_OPUS");
ASSERT_TRUE(speech_encoding_from_mime("audio/ogg", e));
ASSERT_EQ(std::string(speech_encoding_name(e)), "OGG_OPUS");
ASSERT_FALSE(speech_encoding_from_mime("video/mp4", e));
}
TEST(google, generative_request_shape) {
Rig rig;
rig.gemini_ok("dag");
GenerationRequest req;
req.model = "m1";
req.system = "be brief";
req.messages = {{"user", "hoi"}};
ASSERT_EQ(Generative(rig.client).generate(req), "dag");
Json body = Json::parse(rig.mock->seen()[0].body);
ASSERT_EQ(body.find("contents")->as_array()[0].find("role")->as_string(), "user");
ASSERT_EQ(body.find("systemInstruction")->find("parts")->as_array()[0]
.find("text")->as_string(), "be brief");
ASSERT_EQ(body.find("generationConfig")->find("maxOutputTokens")->as_int(), 300);
ASSERT_TRUE(body.find("generationConfig")->find("thinkingConfig") == nullptr);
}
TEST(google, generative_validation_and_empty) {
Rig rig;
Generative gen(rig.client);
GenerationRequest req;
req.model = "m1";
ASSERT_THROW(gen.generate(req), GoogleError); // no messages
req.messages = {{"robot", "x"}};
ASSERT_THROW(gen.generate(req), GoogleError); // bad role
req.messages = {{"user", "x"}};
req.max_output_tokens = Caps::kMaxOutputTokens + 1;
ASSERT_THROW(gen.generate(req), GoogleError); // token cap
ASSERT_EQ(rig.mock->send_count(), 0u);
req.max_output_tokens = 10;
rig.mock->expect_response(Method::kPost, "/v1beta/models/m1:generateContent",
json_ok("{\"candidates\":[]}"));
try {
gen.generate(req);
FAIL("expected EMPTY_RESPONSE");
} catch (const GoogleError& e) {
ASSERT_EQ(e.status(), "EMPTY_RESPONSE");
}
}
TEST(google, voice_turn_full_pipeline) {
setenv("GOOGLE_GENAI_MODEL", "m1", 1);
Rig rig;
rig.stt_ok("wat is het weer");
rig.gemini_ok("Zonnig.");
rig.tts_ok("SPOKEN");
auto p = pipeline(rig);
RecognitionRequest heard;
heard.audio = "AUDIO";
VoiceTurn t = p->turn("conv1", heard);
ASSERT_EQ(t.transcript, "wat is het weer");
ASSERT_EQ(t.reply, "Zonnig.");
ASSERT_EQ(t.audio.bytes, "SPOKEN");
ASSERT_EQ(Json::parse(rig.mock->seen()[1].body)
.find("generationConfig")->find("thinkingConfig")
->find("thinkingBudget")->as_int(), 0);
ASSERT_EQ(p->sessions().history_size("conv1"), 2u);
rig.mock->verify();
unsetenv("GOOGLE_GENAI_MODEL");
}
TEST(google, voice_silence_skips_reply_and_synthesis) {
Rig rig;
rig.mock->expect_response(Method::kPost, "/v1/speech:recognize", json_ok("{}"));
auto p = pipeline(rig);
RecognitionRequest heard;
heard.audio = "AUDIO";
VoiceTurn t = p->turn("conv1", heard);
ASSERT_EQ(t.transcript, "");
ASSERT_EQ(t.audio.bytes, "");
ASSERT_EQ(rig.mock->send_count(), 1u);
ASSERT_EQ(p->sessions().size(), 0u);
}
TEST(google, voice_failed_turn_rolls_back_history) {
setenv("GOOGLE_GENAI_MODEL", "m1", 1);
Rig rig;
rig.mock->expect_response(
Method::kPost, "/v1beta/models/m1:generateContent",
json_ok("{\"error\":{\"code\":429,\"message\":\"quota\",\"status\":"
"\"RESOURCE_EXHAUSTED\"}}", 400));
auto p = pipeline(rig);
ASSERT_THROW(p->turn_text("c", "hoi", "nl-NL"), GoogleError);
ASSERT_EQ(p->sessions().history_size("c"), 0u);
unsetenv("GOOGLE_GENAI_MODEL");
}
TEST(google, voice_bad_conversation_id) {
Rig rig;
auto p = pipeline(rig);
ASSERT_THROW(p->turn_text("bad id!", "hoi", "nl-NL"), GoogleError);
ASSERT_THROW(p->turn_text("", "hoi", "nl-NL"), GoogleError);
ASSERT_EQ(rig.mock->send_count(), 0u);
}
TEST(google, sessions_bounded_history_and_count) {
VoiceSessions s;
for (std::size_t i = 0; i < Caps::kMaxHistoryTurns * 2 + 10; ++i)
s.append("a", {i % 2 == 0 ? "user" : "model", "m"});
ASSERT_TRUE(s.history_size("a") <= Caps::kMaxHistoryTurns * 2);
auto h = s.append("a", {"user", "x"});
ASSERT_EQ(h.front().role, "user");
for (std::size_t i = 0; i < Caps::kMaxConversations + 5; ++i)
s.append("c" + std::to_string(i), {"user", "m"});
ASSERT_EQ(s.size(), Caps::kMaxConversations);
ASSERT_EQ(s.history_size("a"), 0u); // oldest evicted
s.reset("c10");
ASSERT_EQ(s.history_size("c10"), 0u);
}
TEST(google, catalog_lists_known_services) {
auto c = endpoints::catalog();
ASSERT_EQ(c.size(), 4u);
ASSERT_EQ(c[0].name, "texttospeech");
for (const auto& e : c) ASSERT_TRUE(e.base_url.rfind("https://", 0) == 0);
}
// ---- Gemini audio backends (Vertex paths) ----------------------------------
namespace {
const char* kVertexPrefix = "/v1/publishers/google/models/";
void vertex_text(Rig& rig, const std::string& model, const std::string& text) {
rig.mock->expect_response(
Method::kPost, std::string(kVertexPrefix) + model + ":generateContent",
json_ok("{\"candidates\":[{\"content\":{\"parts\":[{\"text\":\"" + text +
"\"}]}}]}"));
}
void vertex_pcm(Rig& rig, const std::string& model, const std::string& pcm) {
rig.mock->expect_response(
Method::kPost, std::string(kVertexPrefix) + model + ":generateContent",
json_ok("{\"candidates\":[{\"content\":{\"parts\":[{\"inlineData\":"
"{\"mimeType\":\"audio/L16;codec=pcm;rate=24000\",\"data\":\"" +
Base64::encode(pcm) + "\"}}]}}]}"));
}
} // namespace
TEST(google, wav_wrap_and_rate) {
std::string wav = pcm16_to_wav(std::string(10, 'x'), 24000);
ASSERT_EQ(wav.size(), 54u);
ASSERT_EQ(wav.substr(0, 4), "RIFF");
ASSERT_EQ(wav.substr(8, 4), "WAVE");
ASSERT_EQ(static_cast<unsigned char>(wav[24]), 0xC0); // 24000 = 0x5DC0
ASSERT_EQ(static_cast<unsigned char>(wav[25]), 0x5D);
ASSERT_EQ(wav.substr(44), std::string(10, 'x'));
ASSERT_EQ(sample_rate_from_mime("audio/L16;codec=pcm;rate=16000"), 16000);
ASSERT_EQ(sample_rate_from_mime("audio/L16"), 24000);
ASSERT_EQ(sample_rate_from_mime("audio/L16;rate=999999999"), 24000);
}
TEST(google, gemini_transcribe_shape) {
Rig rig;
vertex_text(rig, "stt-m", " hallo wereld \n");
Generative gen(rig.client, endpoints::vertex_generative());
std::string text = gen.transcribe("stt-m", "RAW", "audio/webm", "nl-NL");
ASSERT_EQ(text, "hallo wereld");
Json body = Json::parse(rig.mock->seen()[0].body);
const Json& parts = *body.find("contents")->as_array()[0].find("parts");
ASSERT_EQ(parts.as_array()[0].find("inlineData")->find("mimeType")->as_string(),
"audio/webm");
ASSERT_EQ(parts.as_array()[0].find("inlineData")->find("data")->as_string(),
Base64::encode("RAW"));
ASSERT_TRUE(parts.as_array()[1].find("text")->as_string().find("nl-NL") !=
std::string::npos);
ASSERT_THROW(gen.transcribe("stt-m", "", "audio/webm", "nl-NL"), GoogleError);
ASSERT_EQ(rig.mock->send_count(), 1u);
}
TEST(google, gemini_speak_shape_and_wav) {
Rig rig;
vertex_pcm(rig, "tts-m", "PCMDATA!");
Generative gen(rig.client, endpoints::vertex_generative());
Audio a = gen.speak("tts-m", "hoi", "");
ASSERT_EQ(a.mime, "audio/wav");
ASSERT_EQ(a.bytes.substr(0, 4), "RIFF");
ASSERT_EQ(a.bytes.substr(44), "PCMDATA!");
Json body = Json::parse(rig.mock->seen()[0].body);
const Json& gc = *body.find("generationConfig");
ASSERT_EQ(gc.find("responseModalities")->as_array()[0].as_string(), "AUDIO");
ASSERT_EQ(gc.find("speechConfig")->find("voiceConfig")->find("prebuiltVoiceConfig")
->find("voiceName")->as_string(), "Kore");
vertex_text(rig, "tts-m", "no audio here");
ASSERT_THROW(gen.speak("tts-m", "hoi", ""), GoogleError); // EMPTY_RESPONSE
ASSERT_THROW(gen.speak("tts-m", "", ""), GoogleError);
}
TEST(google, backend_selection) {
unsetenv("GOOGLE_API_BACKEND");
setenv("GOOGLE_API_KEY", "AQ.vertexstyle", 1);
ASSERT_EQ(std::string(voice_backend_name(voice_backend_from_env())), "vertex");
setenv("GOOGLE_API_KEY", "AIzaclassic", 1);
ASSERT_EQ(std::string(voice_backend_name(voice_backend_from_env())), "cloud");
setenv("GOOGLE_API_BACKEND", "gemini", 1);
ASSERT_EQ(std::string(voice_backend_name(voice_backend_from_env())), "gemini");
unsetenv("GOOGLE_API_BACKEND");
unsetenv("GOOGLE_API_KEY");
}
TEST(google, voice_turn_on_vertex_backend) {
setenv("GOOGLE_GENAI_MODEL", "chat-m", 1);
setenv("GOOGLE_STT_MODEL", "stt-m", 1);
setenv("GOOGLE_TTS_MODEL", "tts-m", 1);
Rig rig;
vertex_text(rig, "stt-m", "wat is het weer");
vertex_text(rig, "chat-m", "Zonnig.");
vertex_pcm(rig, "tts-m", "SPEECH");
VoiceParts parts = make_voice_parts(rig.client, VoiceBackend::kVertex);
VoicePipeline p(parts.recognizer, parts.responder, parts.synthesizer,
std::make_shared<VoiceSessions>());
RecognitionRequest heard;
heard.audio = "AUDIO";
VoiceTurn t = p.turn("c1", heard);
ASSERT_EQ(t.transcript, "wat is het weer");
ASSERT_EQ(t.reply, "Zonnig.");
ASSERT_EQ(t.audio.mime, "audio/wav");
ASSERT_EQ(t.audio.bytes.substr(44), "SPEECH");
rig.mock->verify();
ASSERT_TRUE(rig.mock->seen()[0].target.rfind("/v1/publishers/google/", 0) == 0);
unsetenv("GOOGLE_GENAI_MODEL");
unsetenv("GOOGLE_STT_MODEL");
unsetenv("GOOGLE_TTS_MODEL");
}
// ---- live tests: real network, opt-in -------------------------------------
// MOLO_LIVE_NET=1 enables the TLS check (no key needed). GOOGLE_API_KEY
// additionally enables a real synthesis. Without them the case prints SKIP
// and passes; the skip is visible in the output, never silent.
#include <cstdlib>
#include <iostream>
#include "clients/transports/http_transport.h"
TEST(google_live, tls_handshake_with_google) {
if (!std::getenv("MOLO_LIVE_NET")) {
std::cout << "SKIP google_live.tls_handshake_with_google (set MOLO_LIVE_NET=1)\n";
return;
}
// Regression: a wire-format ALPN list made Google answer a fatal alert.
try {
TextToSpeech(std::make_shared<GoogleClient>(
std::make_unique<molo::clients::transports::HttpTransport>(),
Credentials::api_key("not-a-real-key")))
.voices();
FAIL("a bogus key must be rejected");
} catch (const GoogleError& e) {
// Reaching Google and being refused proves TLS plus error mapping.
ASSERT_TRUE(e.http_status() == 400 || e.http_status() == 403);
ASSERT_TRUE(e.status() != "UNAVAILABLE");
}
}
TEST(google_live, real_speech_roundtrip) {
// Uses whatever backend the key implies (GOOGLE_API_BACKEND / key prefix).
// Speaks a sentence, then transcribes the audio it got back.
if (!std::getenv("MOLO_LIVE_NET") || Credentials::env().empty()) {
std::cout << "SKIP google_live.real_speech_roundtrip (set MOLO_LIVE_NET=1 and a Google key)\n";
return;
}
VoiceParts parts = make_voice_parts(GoogleClient::from_env(), voice_backend_from_env());
SynthesisRequest say;
say.text = "Hello, this is a test of the voice pipeline.";
say.language = "en-US";
Audio audio = parts.synthesizer->synthesize(say);
ASSERT_TRUE(audio.bytes.size() > 5000);
RecognitionRequest heard;
heard.audio = audio.bytes;
SpeechEncoding enc;
ASSERT_TRUE(speech_encoding_from_mime(audio.mime, enc));
heard.encoding = enc;
heard.language = "en-US";
Transcript t = parts.recognizer->recognize(heard);
std::cout << " heard: " << t.text << "\n";
ASSERT_TRUE(t.text.find("voice") != std::string::npos ||
t.text.find("Voice") != std::string::npos);
}