Add server voice presets

Author: 0xShug0

CMakeLists.txt

@@ -643,6 +643,23 @@ if (ENGINE_BUILD_TESTS)
         NAME server_multipart_test
         COMMAND server_multipart_test
     )
+
+    add_executable(server_config_test
+        tests/unittests/test_server_config.cpp
+        app/server/config.cpp
+        app/cli/args.cpp
+        app/cli/request.cpp
+    )
+    target_include_directories(server_config_test PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/app/server)
+    target_link_libraries(server_config_test PRIVATE engine_runtime ggml)
+    if (ENGINE_ENABLE_OPENMP)
+        target_link_libraries(server_config_test PRIVATE OpenMP::OpenMP_CXX)
+    endif()
+
+    add_test(
+        NAME server_config_test
+        COMMAND server_config_test
+    )
 endif()
 
 if (ENGINE_BUILD_EXAMPLES)

app/server/README.md

@@ -34,6 +34,14 @@ cat > server.json <<'JSON'
       },
       "session_options": {
         "language": "english"
+      },
+      "default_voice_preset": {
+        "voice_id": "alba"
+      },
+      "voice_presets": {
+        "cosette": {
+          "voice_id": "cosette"
+        }
       }
     },
     {
@@ -57,6 +65,41 @@ Set top-level `"lazy_load": true` to register all configured model ids at startu
 > [!WARNING]
 > Lazy loading does not unload models after a request. Once a model is first used, the server keeps that model and session in memory for reuse until the server exits.
 
+For TTS models that need repeated voice-clone context, set a model-level `default_voice_preset` so OpenAI-compatible clients can omit `voice_ref` and `reference_text` on each request:
+
+```json
+{
+  "id": "omnivoice",
+  "family": "omnivoice",
+  "path": "/absolute/path/to/models/OmniVoice",
+  "task": "tts",
+  "mode": "offline",
+  "default_voice_preset": {
+    "voice_ref": "/absolute/path/to/reference.wav",
+    "reference_text": "Reference transcript for the reference audio."
+  }
+}
+```
+
+For multiple server-side presets, use `voice_presets` and optionally point `default_voice_preset` at one of those preset names:
+
+```json
+{
+  "voice_presets": {
+    "assistant": {
+      "voice_ref": "/absolute/path/to/assistant.wav",
+      "reference_text": "Reference transcript for assistant."
+    },
+    "narrator": {
+      "voice_id": "alba"
+    }
+  },
+  "default_voice_preset": "assistant"
+}
+```
+
+When a request sends `"voice": "assistant"`, the server uses that configured preset. When `"voice"` does not match a configured preset, it is passed through as the model-native cached voice id, preserving the previous behavior.
+
 ## Start
 
 ```bash
@@ -90,12 +133,13 @@ curl http://127.0.0.1:8080/v1/audio/speech \
   -d '{
     "model": "pocket-tts",
     "input": "audio.cpp is serving this request through the framework runtime.",
-    "voice_ref": "/path/to/reference.wav",
     "max_tokens": 96,
     "seed": 1234
   }'
 ```
 
+If no request voice is provided and the configured model has `default_voice_preset`, the server injects that preset automatically. Request-level `voice`, `voice_ref`, and `reference_text` override the configured default.
+
 Set `"response_format": "json"` to receive base64 WAV in a JSON response.
 
 ### `POST /v1/audio/transcriptions`
@@ -124,7 +168,7 @@ curl http://127.0.0.1:8080/v1/audio/transcriptions \
 
 ### `GET /v1/audio/voices?model=<id>`
 
-Lists the cached voice ids available for a TTS model, so a client can populate a voice picker instead of guessing generic names. For families that keep voice presets under `model_root/embeddings/*.safetensors` (`pocket_tts` today), this returns those ids; for other families, or an unknown/missing `model` parameter, it returns an empty list.
+Lists the cached voice ids and configured server voice preset names available for a TTS model, so a client can populate a voice picker instead of guessing generic names. For families that keep voice presets under `model_root/embeddings/*.safetensors` (`pocket_tts` today), this returns those ids too; for other families with no configured presets, or an unknown/missing `model` parameter, it returns an empty list.
 
 ```bash
 curl 'http://127.0.0.1:8080/v1/audio/voices?model=pocket-tts'

app/server/config.cpp

@@ -19,6 +19,29 @@ std::unordered_map<std::string, std::string> options_from_object(const engine::i
     return minitts::cli::json_options_map(value);
 }
 
+ServerModelConfig::VoicePreset parse_voice_preset(
+    const std::filesystem::path & base,
+    const engine::io::json::Value & value,
+    const std::string & context) {
+    if (!value.is_object()) {
+        throw std::runtime_error(context + " must be an object");
+    }
+    ServerModelConfig::VoicePreset preset;
+    if (const auto * voice_id = value.find("voice_id")) {
+        preset.voice_id = voice_id->as_string();
+    }
+    if (const auto * voice_ref = value.find("voice_ref")) {
+        preset.voice_ref = resolve_path(base, voice_ref->as_string());
+    }
+    if (const auto * reference_text = value.find("reference_text")) {
+        preset.reference_text = reference_text->as_string();
+    }
+    if (!preset.voice_id.has_value() && !preset.voice_ref.has_value() && !preset.reference_text.has_value()) {
+        throw std::runtime_error(context + " must set voice_id, voice_ref, or reference_text");
+    }
+    return preset;
+}
+
 }  // namespace
 
 engine::core::BackendType parse_server_backend(const std::string & value) {
@@ -66,6 +89,40 @@ ServerConfig load_server_config(const std::filesystem::path & path) {
         }
         model.load_options = options_from_object(item.find("load_options"));
         model.session_options = options_from_object(item.find("session_options"));
+        if (const auto * voice_presets = item.find("voice_presets")) {
+            if (!voice_presets->is_object()) {
+                throw std::runtime_error("voice_presets for model " + model.id + " must be an object");
+            }
+            for (const auto & [name, preset_value] : voice_presets->as_object()) {
+                if (name.empty()) {
+                    throw std::runtime_error("voice_presets for model " + model.id + " cannot use an empty preset name");
+                }
+                auto [it, inserted] = model.voice_presets.emplace(
+                    name,
+                    parse_voice_preset(base, preset_value, "voice preset " + name + " for model " + model.id));
+                if (!inserted) {
+                    throw std::runtime_error("duplicate voice preset for model " + model.id + ": " + name);
+                }
+                (void) it;
+            }
+        }
+        if (const auto * default_voice_preset = item.find("default_voice_preset")) {
+            if (default_voice_preset->is_string()) {
+                model.default_voice_preset_id = default_voice_preset->as_string();
+                if (model.default_voice_preset_id->empty()) {
+                    throw std::runtime_error("default_voice_preset for model " + model.id + " cannot be empty");
+                }
+                if (model.voice_presets.find(*model.default_voice_preset_id) == model.voice_presets.end()) {
+                    throw std::runtime_error(
+                        "default_voice_preset for model " + model.id +
+                        " does not match a configured voice_presets entry: " +
+                        *model.default_voice_preset_id);
+                }
+            } else {
+                model.default_voice_preset =
+                    parse_voice_preset(base, *default_voice_preset, "default_voice_preset for model " + model.id);
+            }
+        }
         config.models.push_back(std::move(model));
     }
     return config;

app/server/config.h

@@ -11,6 +11,12 @@
 namespace minitts::server {
 
 struct ServerModelConfig {
+    struct VoicePreset {
+        std::optional<std::string> voice_id;
+        std::optional<std::filesystem::path> voice_ref;
+        std::optional<std::string> reference_text;
+    };
+
     std::string id;
     std::filesystem::path path;
     std::string family;
@@ -21,6 +27,9 @@ struct ServerModelConfig {
     std::optional<std::string> weight_id;
     std::unordered_map<std::string, std::string> load_options;
     std::unordered_map<std::string, std::string> session_options;
+    std::unordered_map<std::string, VoicePreset> voice_presets;
+    std::optional<VoicePreset> default_voice_preset;
+    std::optional<std::string> default_voice_preset_id;
 };
 
 struct ServerConfig {

app/server/example.json

@@ -17,6 +17,14 @@
       },
       "session_options": {
         "language": "english"
+      },
+      "default_voice_preset": {
+        "voice_id": "alba"
+      },
+      "voice_presets": {
+        "cosette": {
+          "voice_id": "cosette"
+        }
       }
     },
     {