std::filesystem::create_directories(voice_dir);

for (const auto & voice : embedded_demo_voices()) {

std::ofstream wav(

voice_dir / (std::string(voice.name) + ".wav"),

std::ios::binary | std::ios::trunc);

if (!wav) {

throw std::runtime_error("failed to create embedded demo voice: " + std::string(voice.name));

}

wav.write(voice.wav_bytes.data(), static_cast<std::streamsize>(voice.wav_bytes.size()));

if (!wav) {

throw std::runtime_error("failed to write embedded demo voice: " + std::string(voice.name));

}

}

const auto prompt_text = embedded_demo_voice_prompt_text();

std::ofstream prompts(voice_dir / "prompt_text", std::ios::binary | std::ios::trunc);

if (!prompts) {

throw std::runtime_error("failed to create embedded demo voice prompt_text");

}

prompts.write(prompt_text.data(), static_cast<std::streamsize>(prompt_text.size()));

if (!prompts) {

throw std::runtime_error("failed to write embedded demo voice prompt_text");

}

const auto * value = body.find("busy_timeout_ms");

if (value == nullptr) {

return std::nullopt;

}

const auto requested = engine::io::json::optional_i32(body, "busy_timeout_ms", 0);

if (requested < 0) {

throw std::runtime_error("busy_timeout_ms must be >= 0 (0 means no client-side bound)");

}

return requested;

return message.find("model contract spec not found for family '") != std::string_view::npos ||

message.find("does not embed an audio.cpp model spec") != std::string_view::npos ||

message.find("embeds a legacy model spec") != std::string_view::npos;

std::string_view family,

std::string_view option,

const std::optional<std::filesystem::path> & model_spec_override,

const std::filesystem::path & model_path) {

std::optional<engine::model_spec::ModelContract> contract;

{

engine::model_spec::ScopedSpecOverride scoped(model_spec_override, model_path);

try {

contract = engine::model_spec::model_contract(family);

} catch (const std::runtime_error & ex) {

if (!is_missing_model_contract_error(ex.what())) {

throw;

}

}

}

if (!contract.has_value()) {

return true;

}

return contract->request_option_keys.find(std::string(option)) != contract->request_option_keys.end();

const std::filesystem::path & voice_dir, const std::string & voice_name) {

std::ifstream f(voice_dir / "prompt_text");

std::string line;

while (std::getline(f, line)) {

const auto sep = line.find('|');

if (sep == std::string::npos) continue;

std::string name = line.substr(0, sep);

// trim trailing whitespace from name

while (!name.empty() && std::isspace(static_cast<unsigned char>(name.back()))) {

name.pop_back();

}

if (name == voice_name) {

return line.substr(sep + 1);

}

}

return std::nullopt;

const std::filesystem::path & voice_dir,

const std::string & voice_name) {

const std::filesystem::path name_path(voice_name);

if (voice_name.empty() ||

name_path.has_root_name() ||

name_path.has_root_directory() ||

name_path.has_parent_path() ||

name_path.filename().string() != voice_name ||

voice_name == "." ||

voice_name == "..") {

return std::nullopt;

}

const auto wav = voice_dir / (voice_name + ".wav");

std::error_code ec;

if (!std::filesystem::is_regular_file(wav, ec)) {

return std::nullopt;

}

return wav;

value = std::filesystem::path(value).filename().string();

for (char & ch : value) {

const auto uch = static_cast<unsigned char>(ch);

if (!(std::isalnum(uch) || ch == '.' || ch == '-' || ch == '_')) {

ch = '_';

}

}

if (value.empty() || value == "." || value == "..") {

value = "audio.wav";

}

return value;

const Value & body,

const std::filesystem::path & request_base,

bool lazy) {

ServerModelConfig model;

model.id = engine::io::json::require_string(body, "id");

model.path = resolve_path(request_base, engine::io::json::require_string(body, "path"));

model.family = engine::io::json::require_string(body, "family");

model.task = engine::io::json::optional_string(body, "task", model.task);

model.mode = engine::io::json::optional_string(body, "mode", model.mode);

model.lazy = lazy;

if (const auto * value = body.find("model_spec_override")) {

model.model_spec_override = resolve_path(request_base, value->as_string());

}

if (const auto * value = body.find("config")) {

model.config_id = value->as_string();

}

if (const auto * value = body.find("weight")) {

model.weight_id = value->as_string();

}

model.load_options = options_from_object(body.find("load_options"));

model.session_options = options_from_object(body.find("session_options"));

return model;

size_t pos = 0;

while (pos < query.size()) {

const size_t amp = query.find('&', pos);

const std::string pair = query.substr(pos, amp == std::string::npos ? std::string::npos : amp - pos);

const auto eq = pair.find('=');

const std::string name = pair.substr(0, eq);

if (name == key) {

return eq == std::string::npos ? "" : pair.substr(eq + 1);

}

if (amp == std::string::npos) {

break;

}

pos = amp + 1;

}

return {};

if (ch >= '0' && ch <= '9') {

return ch - '0';

}

if (ch >= 'a' && ch <= 'f') {

return ch - 'a' + 10;

}

if (ch >= 'A' && ch <= 'F') {

return ch - 'A' + 10;

}

return -1;

std::string out;

out.reserve(value.size());

for (size_t i = 0; i < value.size(); ++i) {

if (value[i] == '+') {

out.push_back(' ');

} else if (value[i] == '%' && i + 2 < value.size()) {

const int hi = hex_value(value[i + 1]);

const int lo = hex_value(value[i + 2]);

if (hi >= 0 && lo >= 0) {

out.push_back(static_cast<char>((hi << 4) | lo));

i += 2;

} else {

out.push_back(value[i]);

}

} else {

out.push_back(value[i]);

}

}

return out;

HttpResponse response;

response.status = 200;

response.content_type = "application/javascript; charset=utf-8";

response.body = R"JS(

)JS";

response.headers["Cache-Control"] = "no-store, no-cache, must-revalidate, max-age=0";

response.headers["Clear-Site-Data"] = "\"cache\"";

response.headers["Expires"] = "0";

response.headers["Pragma"] = "no-cache";

response.headers["Service-Worker-Allowed"] = "/";

response.headers["X-Content-Type-Options"] = "nosniff";

return response;

std::ostringstream out;

out << "{";

bool first = true;

for (const auto & [key, value] : options) {

if (!first) {

out << ",";

}

first = false;

out << json_quote(key) << ":" << json_quote(value);

}

out << "}";

return out.str();

std::unordered_map<std::string, std::string> & options,

const Value & object,

const std::string & field,

const std::string & option_key) {

const auto * value = object.find(field);

if (value != nullptr && !value->is_null()) {

options[option_key] = minitts::cli::json_option_string(*value);

}

if (audio.sample_rate <= 0) {

throw std::runtime_error("audio output sample rate must be positive");

}

if (audio.channels <= 0) {

throw std::runtime_error("audio output channel count must be positive");

}

if (audio.samples.size() % static_cast<size_t>(audio.channels) != 0) {

throw std::runtime_error("audio output sample count must be divisible by channel count");

}

const uint16_t channels = static_cast<uint16_t>(audio.channels);

const uint16_t bits_per_sample = 16;

const uint32_t data_bytes = static_cast<uint32_t>(audio.samples.size() * sizeof(int16_t));

const uint32_t riff_size = 36 + data_bytes;

const uint32_t byte_rate = static_cast<uint32_t>(audio.sample_rate) * channels * bits_per_sample / 8;

const uint16_t block_align = channels * bits_per_sample / 8;

std::vector<uint8_t> out;

out.reserve(44 + data_bytes);

auto append_bytes = [&](const void * data, size_t size) {

const auto * bytes = static_cast<const uint8_t *>(data);

out.insert(out.end(), bytes, bytes + size);

};

auto append_u16 = [&](uint16_t value) { append_bytes(&value, sizeof(value)); };

auto append_u32 = [&](uint32_t value) { append_bytes(&value, sizeof(value)); };

out.insert(out.end(), {'R', 'I', 'F', 'F'});

append_u32(riff_size);

out.insert(out.end(), {'W', 'A', 'V', 'E', 'f', 'm', 't', ' '});

append_u32(16);

append_u16(1);

append_u16(channels);

append_u32(static_cast<uint32_t>(audio.sample_rate));

append_u32(byte_rate);

append_u16(block_align);

append_u16(bits_per_sample);

out.insert(out.end(), {'d', 'a', 't', 'a'});

append_u32(data_bytes);

for (float sample : audio.samples) {

sample = std::max(-1.0F, std::min(1.0F, sample));

const auto pcm = static_cast<int16_t>(std::lrint(sample * 32767.0F));

append_bytes(&pcm, sizeof(pcm));

}

return out;

if (audio.sample_rate <= 0) {

throw std::runtime_error("audio output sample rate must be positive");

}

if (audio.channels <= 0) {

throw std::runtime_error("audio output channel count must be positive");

}

if (audio.samples.size() % static_cast<size_t>(audio.channels) != 0) {

throw std::runtime_error("audio output sample count must be divisible by channel count");

}

std::vector<uint8_t> out;

out.reserve(audio.samples.size() * sizeof(int16_t));

auto append_bytes = [&](const void * data, size_t size) {

const auto * bytes = static_cast<const uint8_t *>(data);

out.insert(out.end(), bytes, bytes + size);

};

for (float sample : audio.samples) {

sample = std::max(-1.0F, std::min(1.0F, sample));

const auto pcm = static_cast<int16_t>(std::lrint(sample * 32767.0F));

append_bytes(&pcm, sizeof(pcm));

}

return out;

const auto * value = object.find(key);

if (value == nullptr || value->is_null()) {

return default_value;

}

if (value->is_bool()) {

return value->as_bool();

}

if (value->is_string()) {

const auto str = value->as_string();

if (str == "true" || str == "1") {

return true;

}

if (str == "false" || str == "0") {

return false;

}

}

throw std::runtime_error(key + " must be a boolean");

HttpResponse response;

response.status = 200;

response.content_type = "text/event-stream; charset=utf-8";

response.headers.emplace("X-Accel-Buffering", "no");

response.stream_body = std::move(stream);

return response;

HttpResponse response;

response.status = 200;

response.content_type = "application/octet-stream";

response.stream_body = std::move(stream);

return response;

std::string ext = std::filesystem::path(filename).extension().string();

for (char & ch : ext) {

ch = static_cast<char>(std::tolower(static_cast<unsigned char>(ch)));

}

return ext.empty() || ext == ".wav";

for (char & ch : value) {

ch = static_cast<char>(std::tolower(static_cast<unsigned char>(ch)));

}

return value;

while (!value.empty() && std::isspace(static_cast<unsigned char>(value.front())) != 0) {

value.remove_prefix(1);

}

while (!value.empty() && std::isspace(static_cast<unsigned char>(value.back())) != 0) {

value.remove_suffix(1);

}

return value;

const auto it = request.headers.find("content-type");

if (it == request.headers.end()) {

return false;

}

const std::string content_type = lower_ascii(it->second);

const auto media_type = trim_ascii(std::string_view(content_type).substr(0, content_type.find(';')));

return media_type == "application/json" ||

(media_type.size() > 5 && media_type.substr(media_type.size() - 5) == "+json");

if (!config.log_request_body || !engine::debug::log_enabled()) {

return;

}

if (request.method != "POST") {

return;

}

if (!request.body.empty() && is_json_content_type(request)) {

engine::debug::log_message("[REQUEST_BODY] " + request.method + " " + request.path);

engine::debug::log_message(request.body);

return;

}

if (request.body.empty() && request.body_stream == nullptr) {

return;

}

std::ostringstream out;

out << "[REQUEST_BODY_SKIPPED] " << request.method << " " << request.path

<< " content_type=" << json_quote(request_content_type(request));

if (request.body_stream != nullptr) {

out << " body=stream";

} else {

out << " body_bytes=" << request.body.size();

}

if (!request.query.empty()) {

out << " query=" << json_quote(request.query);

}

engine::debug::log_message(out.str());

const ServerConfig & config,

const std::vector<MultipartPart> & parts) {

if (!config.log_request_body || !engine::debug::log_enabled()) {

return;

}

for (const auto & part : parts) {

if (part.filename.empty()) {

continue;

}

std::ostringstream out;

out << "[REQUEST_BODY_SKIPPED] multipart_file"

<< " field=" << json_quote(part.name)

<< " filename=" << json_quote(part.filename)

<< " bytes=" << part.data.size();

engine::debug::log_message(out.str());

}

if (audio.sample_rate <= 0 || audio.channels <= 0) {

return 0.0;

}

return 1000.0 * static_cast<double>(audio.samples.size()) /

static_cast<double>(audio.sample_rate * audio.channels);

std::ostringstream out;

out << "{\"wall_ms\":" << wall_ms << "}";

return out.str();

const double duration_ms = audio_duration_ms(audio);

std::ostringstream out;

out << "{\"wall_ms\":" << wall_ms

<< ",\"audio_duration_ms\":" << duration_ms

<< ",\"rtf\":" << audio_rtf(wall_ms, duration_ms) << "}";

return out.str();

std::ostringstream out;

out << "{\"ttft_ms\":" << ttft_ms << "}";

return out.str();

const double input_end_to_first_audio_ms = request_start_to_first_audio_ms - input_end_ms;

const bool first_audio_before_input_end = input_end_to_first_audio_ms < 0.0;

const double overlap_ms = first_audio_before_input_end ? -input_end_to_first_audio_ms : 0.0;

std::ostringstream out;

out << "{\"ttft_ms\":";

if (first_audio_before_input_end) {

out << "null";

} else {

out << input_end_to_first_audio_ms;

}

out << ",\"first_audio_before_input_end\":" << (first_audio_before_input_end ? "true" : "false")

<< ",\"request_start_to_first_audio_ms\":" << request_start_to_first_audio_ms

<< ",\"input_end_ms\":" << input_end_ms

<< ",\"overlap_ms\":" << overlap_ms << "}";

return out.str();

return (event.partial_text.has_value() && !event.partial_text->text.empty()) ||

event.audio_output.has_value() ||

!event.named_audio_outputs.empty();

return result.text_output.has_value() ||

result.audio_output.has_value() ||

!result.named_audio_outputs.empty() ||

result.artifact_output.has_value() ||

!result.output_artifacts.empty();

if (!ttft_ms.has_value()) {

throw std::runtime_error("streaming response produced no TTFT event");

}

return *ttft_ms;

if (!input_end_ms.has_value()) {

throw std::runtime_error("live streaming response did not observe input end");

}

return *input_end_ms;

double wall_ms,

const engine::runtime::AudioBuffer & audio) {

const double duration_ms = audio_duration_ms(audio);

return {

{"X-AudioCPP-Wall-Ms", std::to_string(wall_ms)},

{"X-AudioCPP-Audio-Duration-Ms", std::to_string(duration_ms)},

{"X-AudioCPP-RTF", std::to_string(audio_rtf(wall_ms, duration_ms))},

};

std::ostringstream & out,

const engine::runtime::TaskResult & result,

FieldFn field) {

if (!result.speech_segments.empty()) {

field("segments");

out << "[";

for (size_t i = 0; i < result.speech_segments.size(); ++i) {

if (i != 0) {

out << ",";

}

const auto & segment = result.speech_segments[i];

out << "{\"start_sample\":" << segment.span.start_sample

<< ",\"end_sample\":" << segment.span.end_sample

<< ",\"confidence\":" << segment.confidence;

if (!segment.text.empty()) {

out << ",\"text\":" << json_quote(segment.text);

}

out << "}";

}

out << "]";

}

if (!result.speaker_turns.empty()) {

field("speaker_turns");

out << "[";

for (size_t i = 0; i < result.speaker_turns.size(); ++i) {

if (i != 0) {

out << ",";

}

const auto & turn = result.speaker_turns[i];

out << "{\"start_sample\":" << turn.span.start_sample

<< ",\"end_sample\":" << turn.span.end_sample

<< ",\"speaker_id\":" << json_quote(turn.speaker_id)

<< ",\"confidence\":" << turn.confidence;

if (!turn.text.empty()) {

out << ",\"text\":" << json_quote(turn.text);

}

out << "}";

}

out << "]";

}

if (!result.word_timestamps.empty()) {

field("words");

out << "[";

for (size_t i = 0; i < result.word_timestamps.size(); ++i) {

if (i != 0) {

out << ",";

}

const auto & word = result.word_timestamps[i];

out << "{\"word\":" << json_quote(word.word)

<< ",\"start_sample\":" << word.span.start_sample

<< ",\"end_sample\":" << word.span.end_sample

<< ",\"confidence\":" << word.confidence << "}";

}

out << "]";

}

const engine::runtime::TaskResult & result,

const std::string & timing) {

std::ostringstream out;

out << "{";

bool first = true;

auto field = [&](const std::string & name) {

if (!first) {

out << ",";

}

first = false;

out << json_quote(name) << ":";

};

if (result.text_output.has_value()) {

field("text");

out << json_quote(result.text_output->text);

if (!result.text_output->language.empty()) {

field("language");

out << json_quote(result.text_output->language);

}

}

if (result.audio_output.has_value()) {

const auto wav = encode_pcm16_wav(*result.audio_output);

field("audio");

out << json_quote(base64_encode(wav));

field("sample_rate");

out << result.audio_output->sample_rate;

field("channels");

out << result.audio_output->channels;

}

if (!result.named_audio_outputs.empty()) {

field("named_audio_outputs");

out << "[";

for (size_t i = 0; i < result.named_audio_outputs.size(); ++i) {

if (i != 0) {

out << ",";

}

const auto wav = encode_pcm16_wav(result.named_audio_outputs[i].audio);

out << "{\"id\":" << json_quote(result.named_audio_outputs[i].id)

<< ",\"audio\":" << json_quote(base64_encode(wav))

<< ",\"sample_rate\":" << result.named_audio_outputs[i].audio.sample_rate

<< ",\"channels\":" << result.named_audio_outputs[i].audio.channels

<< "}";

}

out << "]";

}

if (result.artifact_output.has_value() || !result.output_artifacts.empty()) {

field("artifacts");

out << "[";

bool first_artifact = true;

auto write_artifact = [&](const engine::runtime::VoiceArtifact & artifact) {

if (!first_artifact) out << ",";

first_artifact = false;

out << "{\"id\":" << json_quote(artifact.id)

<< ",\"kind\":" << json_quote(artifact_kind_name(artifact.kind))

<< ",\"payload\":" << json_quote(base64_encode(artifact.payload))

<< ",\"meta\":{";

bool first_meta = true;

for (const auto & [key, value] : artifact.meta) {

if (!first_meta) out << ",";

first_meta = false;

out << json_quote(key) << ":" << json_quote(value);

}

out << "}}";

};

if (result.artifact_output.has_value()) write_artifact(*result.artifact_output);

for (const auto & artifact : result.output_artifacts) write_artifact(artifact);

out << "]";

}

write_transcript_detail_fields(out, result, field);

field("timing");

out << timing;

out << "}";

return out.str();

if (result.audio_output.has_value()) {

return task_result_json_with_timing(result, timing_json(wall_ms, *result.audio_output));

}

if (result.named_audio_outputs.size() == 1) {

return task_result_json_with_timing(result, timing_json(wall_ms, result.named_audio_outputs.front().audio));

}

return task_result_json_with_timing(result, timing_json(wall_ms));

const engine::runtime::TaskResult & result,

const engine::runtime::AudioBuffer & audio,

double wall_ms) {

if (audio.sample_rate <= 0) {

throw std::runtime_error("alignment timing requires a positive input sample rate");

}

std::ostringstream out;

out << "{";

bool first = true;

auto field = [&](const std::string & name) {

if (!first) {

out << ",";

}

first = false;

out << json_quote(name) << ":";

};

if (result.text_output.has_value()) {

field("text");

out << json_quote(result.text_output->text);

if (!result.text_output->language.empty()) {

field("language");

out << json_quote(result.text_output->language);

}

}

field("words");

out << "[";

for (size_t i = 0; i < result.word_timestamps.size(); ++i) {

if (i != 0) {

out << ",";

}

const auto & word = result.word_timestamps[i];

out << "{\"word\":" << json_quote(word.word)

<< ",\"start\":" << (static_cast<double>(word.span.start_sample) / audio.sample_rate)

<< ",\"end\":" << (static_cast<double>(word.span.end_sample) / audio.sample_rate)

<< ",\"start_sample\":" << word.span.start_sample

<< ",\"end_sample\":" << word.span.end_sample

<< ",\"confidence\":" << word.confidence << "}";

}

out << "]";

field("timing");

out << timing_json(wall_ms, audio);

out << "}";

return out.str();

const engine::runtime::TaskResult & result,

const std::optional<double> & ttft_ms) {

return task_result_json_with_timing(result, ttft_timing_json(require_ttft_ms(ttft_ms)));

std::ostringstream out;

out << "{";

bool first = true;

auto field = [&](const char * name) {

if (!first) {

out << ",";

}

first = false;

out << "\"" << name << "\":";

};

if (event.partial_text.has_value()) {

field("partial_text");

out << "{\"text\":" << json_quote(event.partial_text->text)

<< ",\"language\":" << json_quote(event.partial_text->language)

<< "}";

}

if (event.audio_output.has_value()) {

const auto wav = encode_pcm16_wav(*event.audio_output);

field("audio");

out << json_quote(base64_encode(wav));

}

if (!event.named_audio_outputs.empty()) {

field("named_audio_outputs");

out << "[";

for (size_t i = 0; i < event.named_audio_outputs.size(); ++i) {

if (i != 0) {

out << ",";

}

const auto wav = encode_pcm16_wav(event.named_audio_outputs[i].audio);

out << "{\"id\":" << json_quote(event.named_audio_outputs[i].id)

<< ",\"audio\":" << json_quote(base64_encode(wav))

<< ",\"format\":\"wav\"}";

}

out << "]";

}

if (!event.word_timestamps.empty()) {

field("word_timestamps");

out << "[";

for (size_t i = 0; i < event.word_timestamps.size(); ++i) {

if (i != 0) {

out << ",";

}

out << "{\"start_sample\":" << event.word_timestamps[i].span.start_sample

<< ",\"end_sample\":" << event.word_timestamps[i].span.end_sample

<< ",\"word\":" << json_quote(event.word_timestamps[i].word)

<< ",\"confidence\":" << event.word_timestamps[i].confidence

<< "}";

}

out << "]";

}

field("is_final");

out << (event.is_final ? "true" : "false");

out << "}";

return out.str();

const Value & body,

const std::filesystem::path & base_dir,

bool accepts_language_option,

const std::string * uploaded_audio_bytes = nullptr) {

const auto * audio = body.find("audio");

if (audio == nullptr) {

audio = body.find("audio_path");

}

if (audio == nullptr) {

audio = body.find("file");

}

if (uploaded_audio_bytes == nullptr && (audio == nullptr || !audio->is_string())) {

throw std::runtime_error("transcription request requires audio, audio_path, or file path");

}

engine::runtime::TaskRequest request;

if (uploaded_audio_bytes == nullptr) {

request.audio_input = minitts::cli::read_audio_buffer(resolve_path(base_dir, audio->as_string()));

} else {

request.audio_input = minitts::cli::read_audio_buffer(std::string_view(*uploaded_audio_bytes));

}

request.options = options_from_object(body.find("options"));

std::string language;

if (const auto * value = body.find("language")) {

language = value->as_string();

// Only forward a language the caller actually chose, and only to a model

// whose contract accepts it. Clients send the field unconditionally, so

// without both guards a model that validates request options strictly

// rejects the whole request over an option the user never set. The

// language still reaches the model through text_input either way.

if (!language.empty() && accepts_language_option) {

request.options["language"] = language;

}

}

std::string context;

if (const auto * value = body.find("text")) {

context = value->as_string();

}

if (!language.empty() || !context.empty()) {

request.text_input = engine::runtime::Transcript{std::move(context), std::move(language)};

}

return request;

std::filesystem::path start,

Predicate predicate) {

std::error_code ec;

start = std::filesystem::absolute(std::move(start), ec).lexically_normal();

if (ec) {

return std::nullopt;

}

for (;;) {

if (predicate(start)) {

return start;

}

const auto parent = start.parent_path();

if (parent.empty() || parent == start) {

return std::nullopt;

}

start = parent;

}

const std::filesystem::path & request_base,

const std::filesystem::path & resource_anchor,

Predicate predicate) {

if (auto found = find_ancestor(request_base, predicate)) {