react-native-sherpa-onnx 0.2.0 → 0.3.0

package/android/src/main/cpp/jni/model_detect/sherpa-onnx-model-detect-stt.cpp

@@ -0,0 +1,399 @@
+/**
+ * sherpa-onnx-model-detect-stt.cpp
+ *
+ * Purpose: Detects STT model type and fills SttModelPaths from a model directory. Supports
+ * transducer, paraformer, whisper, and other STT variants. Used by nativeDetectSttModel (module-jni).
+ */
+#include "sherpa-onnx-model-detect.h"
+#include "sherpa-onnx-model-detect-helper.h"
+#include <android/log.h>
+#include <cstdlib>
+#include <string>
+#include <algorithm>
+
+#define LOG_TAG "SttModelDetect"
+#define LOGI(...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__)
+#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__)
+
+namespace sherpaonnx {
+namespace {
+
+SttModelKind ParseSttModelType(const std::string& modelType) {
+    if (modelType == "transducer") return SttModelKind::kTransducer;
+    if (modelType == "nemo_transducer") return SttModelKind::kNemoTransducer;
+    if (modelType == "paraformer") return SttModelKind::kParaformer;
+    if (modelType == "nemo_ctc") return SttModelKind::kNemoCtc;
+    if (modelType == "wenet_ctc") return SttModelKind::kWenetCtc;
+    if (modelType == "sense_voice") return SttModelKind::kSenseVoice;
+    if (modelType == "zipformer_ctc" || modelType == "ctc") return SttModelKind::kZipformerCtc;
+    if (modelType == "whisper") return SttModelKind::kWhisper;
+    if (modelType == "funasr_nano") return SttModelKind::kFunAsrNano;
+    if (modelType == "fire_red_asr") return SttModelKind::kFireRedAsr;
+    if (modelType == "moonshine") return SttModelKind::kMoonshine;
+    if (modelType == "dolphin") return SttModelKind::kDolphin;
+    if (modelType == "canary") return SttModelKind::kCanary;
+    if (modelType == "omnilingual") return SttModelKind::kOmnilingual;
+    if (modelType == "medasr") return SttModelKind::kMedAsr;
+    if (modelType == "telespeech_ctc") return SttModelKind::kTeleSpeechCtc;
+    return SttModelKind::kUnknown;
+}
+
+} // namespace
+
+SttDetectResult DetectSttModel(
+    const std::string& modelDir,
+    const std::optional<bool>& preferInt8,
+    const std::optional<std::string>& modelType,
+    bool debug /* = false */
+) {
+    using namespace model_detect;
+
+    SttDetectResult result;
+
+    LOGI("DetectSttModel: modelDir=%s, modelType=%s, preferInt8=%s",
+         modelDir.c_str(),
+         modelType.has_value() ? modelType->c_str() : "auto",
+         preferInt8.has_value() ? (preferInt8.value() ? "true" : "false") : "unset");
+
+    if (modelDir.empty()) {
+        result.error = "Model directory is empty";
+        LOGE("%s", result.error.c_str());
+        return result;
+    }
+
+    if (!FileExists(modelDir) || !IsDirectory(modelDir)) {
+        result.error = "Model directory does not exist or is not a directory: " + modelDir;
+        LOGE("%s", result.error.c_str());
+        return result;
+    }
+
+    // Depth 4 supports layouts like root/data/lang_bpe_500/tokens.txt (icefall, k2)
+    const int kMaxSearchDepth = 4;
+    const auto files = ListFilesRecursive(modelDir, kMaxSearchDepth);
+    bool verbose = debug;
+    LOGI("DetectSttModel: Found %zu files in %s (verbose=%d)", files.size(), modelDir.c_str(), (int)verbose);
+    if (verbose) {
+        for (const auto& f : files) {
+            LOGI("  file: %s (size=%llu)", f.path.c_str(), (unsigned long long)f.size);
+        }
+    } else {
+        LOGI("(detailed file listing suppressed; enable by passing debug=true to initialize())");
+    }
+
+    std::string encoderPath = FindOnnxByAnyToken(files, {"encoder"}, preferInt8);
+    std::string decoderPath = FindOnnxByAnyToken(files, {"decoder"}, preferInt8);
+    std::string joinerPath = FindOnnxByAnyToken(files, {"joiner"}, preferInt8);
+
+    LOGI("DetectSttModel: encoder=%s, decoder=%s, joiner=%s",
+         encoderPath.c_str(), decoderPath.c_str(), joinerPath.c_str());
+
+    std::string funasrEncoderAdaptor = FindOnnxByAnyToken(files, {"encoder_adaptor", "encoder-adaptor"}, preferInt8);
+    std::string funasrLLM = FindOnnxByAnyToken(files, {"llm"}, preferInt8);
+    std::string funasrEmbedding = FindOnnxByAnyToken(files, {"embedding"}, preferInt8);
+
+    std::string funasrTokenizerDir = ResolveTokenizerDir(modelDir);
+
+    // Moonshine: preprocess, encode, uncached_decode, cached_decode
+    std::string moonshinePreprocessor = FindOnnxByAnyToken(files, {"preprocess", "preprocessor"}, preferInt8);
+    std::string moonshineEncoder = FindOnnxByAnyToken(files, {"encode"}, preferInt8);
+    std::string moonshineUncachedDecoder = FindOnnxByAnyToken(files, {"uncached_decode", "uncached"}, preferInt8);
+    std::string moonshineCachedDecoder = FindOnnxByAnyToken(files, {"cached_decode", "cached"}, preferInt8);
+
+    std::vector<std::string> modelExcludes = {
+        "encoder",
+        "decoder",
+        "joiner",
+        "vocoder",
+        "acoustic",
+        "embedding",
+        "llm",
+        "encoder_adaptor",
+        "encoder-adaptor"
+    };
+
+    std::string paraformerModelPath = FindOnnxByAnyToken(files, {"model"}, preferInt8);
+    if (paraformerModelPath.empty()) {
+        paraformerModelPath = FindLargestOnnxExcludingTokens(files, modelExcludes);
+    }
+
+    std::string ctcModelPath = FindOnnxByAnyToken(files, {"model"}, preferInt8);
+    if (ctcModelPath.empty()) {
+        ctcModelPath = FindLargestOnnxExcludingTokens(files, modelExcludes);
+    }
+
+    // Search for tokens file: first try exact "tokens.txt", then suffix match
+    // (e.g. "tiny-tokens.txt" for Whisper models). Use same depth as file list
+    // so layouts like root/data/lang_bpe_500/tokens.txt (icefall) are found.
+    std::string tokensPath = FindFileEndingWith(modelDir, "tokens.txt", kMaxSearchDepth);
+    LOGI("DetectSttModel: tokens=%s", tokensPath.c_str());
+
+    // Optional: BPE vocabulary for hotwords (sentencepiece bpe.vocab). Used when modeling_unit is bpe or cjkchar+bpe.
+    std::string bpeVocabPath = FindFileByName(modelDir, "bpe.vocab", kMaxSearchDepth);
+    if (!bpeVocabPath.empty()) {
+        LOGI("DetectSttModel: bpeVocab=%s", bpeVocabPath.c_str());
+    }
+
+    bool hasTransducer = !encoderPath.empty() && !decoderPath.empty() && !joinerPath.empty();
+
+    bool hasWhisperEncoder = !encoderPath.empty();
+    bool hasWhisperDecoder = !decoderPath.empty();
+    bool hasWhisper = hasWhisperEncoder && hasWhisperDecoder && joinerPath.empty();
+
+    bool hasFunAsrEncoderAdaptor = !funasrEncoderAdaptor.empty();
+    bool hasFunAsrLLM = !funasrLLM.empty();
+    bool hasFunAsrEmbedding = !funasrEmbedding.empty();
+    bool hasFunAsrTokenizer = !funasrTokenizerDir.empty() && FileExists(funasrTokenizerDir + "/vocab.json");
+    bool hasFunAsrNano = hasFunAsrEncoderAdaptor && hasFunAsrLLM && hasFunAsrEmbedding && hasFunAsrTokenizer;
+
+    // Case-insensitive path hints so "Nemo parakeet Tdt CTC 110m EN" etc. are recognized
+    std::string modelDirLower = model_detect::ToLower(modelDir);
+    bool isLikelyNemo = modelDirLower.find("nemo") != std::string::npos ||
+                        modelDirLower.find("parakeet") != std::string::npos;
+    bool isLikelyTdt = modelDirLower.find("tdt") != std::string::npos;
+    bool isLikelyWenetCtc = modelDirLower.find("wenet") != std::string::npos;
+    bool isLikelySenseVoice = modelDirLower.find("sense") != std::string::npos ||
+                              modelDirLower.find("sensevoice") != std::string::npos;
+    bool isLikelyFunAsrNano = modelDirLower.find("funasr") != std::string::npos ||
+                              modelDirLower.find("funasr-nano") != std::string::npos;
+    bool isLikelyMoonshine = modelDirLower.find("moonshine") != std::string::npos;
+    bool isLikelyDolphin = modelDirLower.find("dolphin") != std::string::npos;
+    bool isLikelyFireRedAsr = modelDirLower.find("fire_red") != std::string::npos ||
+                              modelDirLower.find("fire-red") != std::string::npos;
+    bool isLikelyCanary = modelDirLower.find("canary") != std::string::npos;
+    bool isLikelyOmnilingual = modelDirLower.find("omnilingual") != std::string::npos;
+    bool isLikelyMedAsr = modelDirLower.find("medasr") != std::string::npos;
+    bool isLikelyTeleSpeech = modelDirLower.find("telespeech") != std::string::npos;
+
+    bool hasMoonshine = !moonshinePreprocessor.empty() && !moonshineUncachedDecoder.empty() &&
+                        !moonshineCachedDecoder.empty() && !moonshineEncoder.empty();
+    bool hasDolphin = isLikelyDolphin && !ctcModelPath.empty();
+    bool hasFireRedAsr = hasTransducer && isLikelyFireRedAsr;
+    // Canary (NeMo Canary) uses encoder + decoder without joiner; same file pattern as Whisper but path contains "canary"
+    bool hasCanary = hasWhisperEncoder && hasWhisperDecoder && joinerPath.empty() && isLikelyCanary;
+    bool hasOmnilingual = !ctcModelPath.empty() && isLikelyOmnilingual;
+    bool hasMedAsr = !ctcModelPath.empty() && isLikelyMedAsr;
+    bool hasTeleSpeechCtc = (!ctcModelPath.empty() || !paraformerModelPath.empty()) && isLikelyTeleSpeech;
+
+    if (hasTransducer) {
+        if (isLikelyNemo || isLikelyTdt) {
+            result.detectedModels.push_back({"nemo_transducer", modelDir});
+        } else {
+            result.detectedModels.push_back({"transducer", modelDir});
+        }
+    }
+
+    if (!ctcModelPath.empty() && (isLikelyNemo || isLikelyWenetCtc || isLikelySenseVoice)) {
+        if (isLikelyNemo) {
+            result.detectedModels.push_back({"nemo_ctc", modelDir});
+        } else if (isLikelyWenetCtc) {
+            result.detectedModels.push_back({"wenet_ctc", modelDir});
+        } else if (isLikelySenseVoice) {
+            result.detectedModels.push_back({"sense_voice", modelDir});
+        } else {
+            result.detectedModels.push_back({"ctc", modelDir});
+        }
+    } else if (!paraformerModelPath.empty()) {
+        result.detectedModels.push_back({"paraformer", modelDir});
+    }
+
+    if (hasWhisper) {
+        result.detectedModels.push_back({"whisper", modelDir});
+    }
+
+    if (hasFunAsrNano) {
+        result.detectedModels.push_back({"funasr_nano", modelDir});
+    }
+    if (hasMoonshine) {
+        result.detectedModels.push_back({"moonshine", modelDir});
+    }
+    if (hasDolphin) {
+        result.detectedModels.push_back({"dolphin", modelDir});
+    }
+    if (hasFireRedAsr) {
+        result.detectedModels.push_back({"fire_red_asr", modelDir});
+    }
+    if (hasCanary) {
+        result.detectedModels.push_back({"canary", modelDir});
+    }
+    if (hasOmnilingual) {
+        result.detectedModels.push_back({"omnilingual", modelDir});
+    }
+    if (hasMedAsr) {
+        result.detectedModels.push_back({"medasr", modelDir});
+    }
+    if (hasTeleSpeechCtc) {
+        result.detectedModels.push_back({"telespeech_ctc", modelDir});
+    }
+
+    SttModelKind selected = SttModelKind::kUnknown;
+
+    if (modelType.has_value() && modelType.value() != "auto") {
+        selected = ParseSttModelType(modelType.value());
+        if (selected == SttModelKind::kUnknown) {
+            result.error = "Unknown model type: " + modelType.value();
+            return result;
+        }
+
+        if (selected == SttModelKind::kTransducer && !hasTransducer) {
+            result.error = "Transducer model requested but files not found in " + modelDir;
+            return result;
+        }
+        if (selected == SttModelKind::kNemoTransducer && !hasTransducer) {
+            result.error = "NeMo Transducer model requested but encoder/decoder/joiner not found in " + modelDir;
+            return result;
+        }
+        if (selected == SttModelKind::kParaformer && paraformerModelPath.empty()) {
+            result.error = "Paraformer model requested but model file not found in " + modelDir;
+            return result;
+        }
+        if ((selected == SttModelKind::kNemoCtc || selected == SttModelKind::kWenetCtc ||
+             selected == SttModelKind::kSenseVoice || selected == SttModelKind::kZipformerCtc) &&
+            ctcModelPath.empty()) {
+            result.error = "CTC model requested but model file not found in " + modelDir;
+            return result;
+        }
+        if (selected == SttModelKind::kWhisper && !hasWhisper) {
+            result.error = "Whisper model requested but encoder/decoder not found in " + modelDir;
+            return result;
+        }
+        if (selected == SttModelKind::kFunAsrNano && !hasFunAsrNano) {
+            result.error = "FunASR Nano model requested but required files not found in " + modelDir;
+            return result;
+        }
+        if (selected == SttModelKind::kMoonshine && !hasMoonshine) {
+            result.error = "Moonshine model requested but preprocess/encode/uncached_decode/cached_decode not found in " + modelDir;
+            return result;
+        }
+        if (selected == SttModelKind::kDolphin && !hasDolphin) {
+            result.error = "Dolphin model requested but model not found in " + modelDir;
+            return result;
+        }
+        if (selected == SttModelKind::kFireRedAsr && !hasFireRedAsr) {
+            result.error = "FireRed ASR model requested but encoder/decoder not found in " + modelDir;
+            return result;
+        }
+        if (selected == SttModelKind::kCanary && !hasCanary) {
+            result.error = "Canary model requested but encoder/decoder not found in " + modelDir;
+            return result;
+        }
+        if (selected == SttModelKind::kOmnilingual && !hasOmnilingual) {
+            result.error = "Omnilingual model requested but model not found in " + modelDir;
+            return result;
+        }
+        if (selected == SttModelKind::kMedAsr && !hasMedAsr) {
+            result.error = "MedASR model requested but model not found in " + modelDir;
+            return result;
+        }
+        if (selected == SttModelKind::kTeleSpeechCtc && !hasTeleSpeechCtc) {
+            result.error = "TeleSpeech CTC model requested but model not found in " + modelDir;
+            return result;
+        }
+    } else {
+        if (hasTransducer) {
+            selected = (isLikelyNemo || isLikelyTdt) ? SttModelKind::kNemoTransducer : SttModelKind::kTransducer;
+        } else if (!ctcModelPath.empty() && (isLikelyNemo || isLikelyWenetCtc || isLikelySenseVoice)) {
+            if (isLikelyNemo) {
+                selected = SttModelKind::kNemoCtc;
+            } else if (isLikelyWenetCtc) {
+                selected = SttModelKind::kWenetCtc;
+            } else {
+                selected = SttModelKind::kSenseVoice;
+            }
+        } else if (hasFunAsrNano && isLikelyFunAsrNano) {
+            selected = SttModelKind::kFunAsrNano;
+        } else if (!paraformerModelPath.empty()) {
+            selected = SttModelKind::kParaformer;
+        } else if (hasCanary) {
+            selected = SttModelKind::kCanary;
+        } else if (hasFireRedAsr) {
+            selected = SttModelKind::kFireRedAsr;
+        } else if (hasWhisper) {
+            selected = SttModelKind::kWhisper;
+        } else if (hasFunAsrNano) {
+            selected = SttModelKind::kFunAsrNano;
+        } else if (hasMoonshine && isLikelyMoonshine) {
+            selected = SttModelKind::kMoonshine;
+        } else if (hasDolphin) {
+            selected = SttModelKind::kDolphin;
+        } else if (hasOmnilingual) {
+            selected = SttModelKind::kOmnilingual;
+        } else if (hasMedAsr) {
+            selected = SttModelKind::kMedAsr;
+        } else if (hasTeleSpeechCtc) {
+            selected = SttModelKind::kTeleSpeechCtc;
+        } else if (!ctcModelPath.empty()) {
+            selected = SttModelKind::kZipformerCtc;
+        }
+    }
+
+    if (selected == SttModelKind::kUnknown) {
+        result.error = "No compatible model type detected in " + modelDir;
+        LOGE("%s", result.error.c_str());
+        return result;
+    }
+
+    LOGI("DetectSttModel: selected kind=%d", static_cast<int>(selected));
+    result.selectedKind = selected;
+    // sherpa-onnx's OfflineModelConfig::Validate() requires tokens for ALL models
+    // except FunASR-nano (which uses its own tokenizer directory).
+    // Whisper models also need tokens.txt despite seeming self-contained.
+    result.tokensRequired = (selected != SttModelKind::kFunAsrNano);
+
+    if (selected == SttModelKind::kTransducer || selected == SttModelKind::kNemoTransducer) {
+        result.paths.encoder = encoderPath;
+        result.paths.decoder = decoderPath;
+        result.paths.joiner = joinerPath;
+    } else if (selected == SttModelKind::kParaformer) {
+        result.paths.paraformerModel = paraformerModelPath;
+    } else if (selected == SttModelKind::kNemoCtc || selected == SttModelKind::kWenetCtc ||
+               selected == SttModelKind::kSenseVoice || selected == SttModelKind::kZipformerCtc) {
+        result.paths.ctcModel = ctcModelPath;
+    } else if (selected == SttModelKind::kWhisper) {
+        result.paths.whisperEncoder = encoderPath;
+        result.paths.whisperDecoder = decoderPath;
+    } else if (selected == SttModelKind::kFunAsrNano) {
+        result.paths.funasrEncoderAdaptor = funasrEncoderAdaptor;
+        result.paths.funasrLLM = funasrLLM;
+        result.paths.funasrEmbedding = funasrEmbedding;
+        // FunASR Nano C++ expects tokenizer directory (e.g. .../Qwen3-0.6B), not path to vocab.json
+        result.paths.funasrTokenizer = funasrTokenizerDir;
+    } else if (selected == SttModelKind::kMoonshine) {
+        result.paths.moonshinePreprocessor = moonshinePreprocessor;
+        result.paths.moonshineEncoder = moonshineEncoder;
+        result.paths.moonshineUncachedDecoder = moonshineUncachedDecoder;
+        result.paths.moonshineCachedDecoder = moonshineCachedDecoder;
+    } else if (selected == SttModelKind::kDolphin) {
+        result.paths.dolphinModel = ctcModelPath.empty() ? paraformerModelPath : ctcModelPath;
+    } else if (selected == SttModelKind::kFireRedAsr) {
+        result.paths.fireRedEncoder = encoderPath;
+        result.paths.fireRedDecoder = decoderPath;
+    } else if (selected == SttModelKind::kCanary) {
+        result.paths.canaryEncoder = encoderPath;
+        result.paths.canaryDecoder = decoderPath;
+    } else if (selected == SttModelKind::kOmnilingual) {
+        result.paths.omnilingualModel = ctcModelPath;
+    } else if (selected == SttModelKind::kMedAsr) {
+        result.paths.medasrModel = ctcModelPath;
+    } else if (selected == SttModelKind::kTeleSpeechCtc) {
+        result.paths.telespeechCtcModel = ctcModelPath.empty() ? paraformerModelPath : ctcModelPath;
+    }
+
+    if (!tokensPath.empty() && FileExists(tokensPath)) {
+        result.paths.tokens = tokensPath;
+    } else if (result.tokensRequired) {
+        result.error = "Tokens file not found in " + modelDir;
+        LOGE("%s", result.error.c_str());
+        return result;
+    }
+
+    if (!bpeVocabPath.empty() && FileExists(bpeVocabPath)) {
+        result.paths.bpeVocab = bpeVocabPath;
+    }
+
+    LOGI("DetectSttModel: detection OK for %s — tokens=%s",
+         modelDir.c_str(), result.paths.tokens.c_str());
+    result.ok = true;
+    return result;
+}
+
+} // namespace sherpaonnx

package/android/src/main/cpp/jni/model_detect/sherpa-onnx-model-detect-tts.cpp

@@ -0,0 +1,238 @@
+/**
+ * sherpa-onnx-model-detect-tts.cpp
+ *
+ * Purpose: Detects TTS model type and fills TtsModelPaths from a model directory. Supports Vits,
+ * Piper, Kokoro, Zipvoice, Pocket, etc. Used by nativeDetectTtsModel (module-jni).
+ */
+#include "sherpa-onnx-model-detect.h"
+#include "sherpa-onnx-model-detect-helper.h"
+#include <android/log.h>
+
+#define LOG_TAG "TtsModelDetect"
+#define LOGI(...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__)
+#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__)
+
+namespace sherpaonnx {
+namespace {
+
+TtsModelKind ParseTtsModelType(const std::string& modelType) {
+    if (modelType == "vits") return TtsModelKind::kVits;
+    if (modelType == "matcha") return TtsModelKind::kMatcha;
+    if (modelType == "kokoro") return TtsModelKind::kKokoro;
+    if (modelType == "kitten") return TtsModelKind::kKitten;
+    if (modelType == "pocket") return TtsModelKind::kPocket;
+    if (modelType == "zipvoice") return TtsModelKind::kZipvoice;
+    return TtsModelKind::kUnknown;
+}
+
+} // namespace
+
+TtsDetectResult DetectTtsModel(const std::string& modelDir, const std::string& modelType) {
+    using namespace model_detect;
+
+    TtsDetectResult result;
+
+    LOGI("DetectTtsModel: modelDir=%s, modelType=%s", modelDir.c_str(), modelType.c_str());
+
+    if (modelDir.empty()) {
+        result.error = "TTS: Model directory is empty";
+        LOGE("%s", result.error.c_str());
+        return result;
+    }
+
+    if (!FileExists(modelDir) || !IsDirectory(modelDir)) {
+        result.error = "TTS: Model directory does not exist or is not a directory: " + modelDir;
+        LOGE("%s", result.error.c_str());
+        return result;
+    }
+
+    const auto files = ListFilesRecursive(modelDir, 4);
+    LOGI("DetectTtsModel: Found %zu files in %s", files.size(), modelDir.c_str());
+    for (const auto& f : files) {
+        LOGI("  file: %s (size=%llu)", f.path.c_str(), (unsigned long long)f.size);
+    }
+
+    std::string tokensFile = FindFileByName(modelDir, "tokens.txt", 2);
+    std::string lexiconFile = FindFileByName(modelDir, "lexicon.txt", 2);
+    std::string dataDirPath = FindDirectoryByName(modelDir, "espeak-ng-data", 2);
+    std::string voicesFile = FindFileByName(modelDir, "voices.bin", 2);
+
+    LOGI("DetectTtsModel: tokens=%s, lexicon=%s, dataDir=%s, voices=%s",
+         tokensFile.c_str(), lexiconFile.c_str(), dataDirPath.c_str(), voicesFile.c_str());
+
+    std::string acousticModel = FindOnnxByAnyToken(files, {"acoustic_model", "acoustic-model"}, std::nullopt);
+    // Note: matches either a "vocoder" or "vocos" ONNX file; both are stored in this field.
+    std::string vocoder = FindOnnxByAnyToken(files, {"vocoder", "vocos"}, std::nullopt);
+    std::string encoder = FindOnnxByAnyToken(files, {"encoder"}, std::nullopt);
+    std::string decoder = FindOnnxByAnyToken(files, {"decoder"}, std::nullopt);
+    std::string lmFlow = FindOnnxByAnyToken(files, {"lm_flow", "lm-flow"}, std::nullopt);
+    std::string lmMain = FindOnnxByAnyToken(files, {"lm_main", "lm-main"}, std::nullopt);
+    std::string textConditioner = FindOnnxByAnyToken(files, {"text_conditioner", "text-conditioner"}, std::nullopt);
+    std::string vocabJsonFile = FindFileByName(modelDir, "vocab.json", 2);
+    std::string tokenScoresJsonFile = FindFileByName(modelDir, "token_scores.json", 2);
+
+    LOGI("DetectTtsModel: acousticModel=%s, vocoder=%s, encoder=%s, decoder=%s",
+         acousticModel.c_str(), vocoder.c_str(), encoder.c_str(), decoder.c_str());
+    LOGI("DetectTtsModel: lmFlow=%s, lmMain=%s, textConditioner=%s, vocabJson=%s, tokenScoresJson=%s",
+         lmFlow.c_str(), lmMain.c_str(), textConditioner.c_str(), vocabJsonFile.c_str(), tokenScoresJsonFile.c_str());
+
+    std::vector<std::string> modelExcludes = {
+        "acoustic",
+        "vocoder",
+        "encoder",
+        "decoder",
+        "joiner"
+    };
+
+    std::string ttsModel = FindOnnxByAnyToken(files, {"model"}, std::nullopt);
+    if (ttsModel.empty()) {
+        ttsModel = FindLargestOnnxExcludingTokens(files, modelExcludes);
+    }
+    LOGI("DetectTtsModel: ttsModel=%s", ttsModel.c_str());
+
+    bool hasVits = !ttsModel.empty();
+    bool hasMatcha = !acousticModel.empty() && !vocoder.empty();
+    bool hasVoicesFile = !voicesFile.empty() && FileExists(voicesFile);
+    // Zipvoice requires encoder + decoder + vocoder (full model). Distill variants (no vocoder) are not supported by the native layer.
+    bool hasZipvoice = !encoder.empty() && !decoder.empty() && !vocoder.empty();
+    bool hasPocket = !lmFlow.empty() && !lmMain.empty() && !encoder.empty() && !decoder.empty() &&
+                     !textConditioner.empty() && !vocabJsonFile.empty() && FileExists(vocabJsonFile) &&
+                     !tokenScoresJsonFile.empty() && FileExists(tokenScoresJsonFile);
+    bool hasDataDir = !dataDirPath.empty() && IsDirectory(dataDirPath);
+
+    std::string modelDirLower = ToLower(modelDir);
+    bool isLikelyKitten = modelDirLower.find("kitten") != std::string::npos;
+    bool isLikelyKokoro = modelDirLower.find("kokoro") != std::string::npos;
+
+    if (hasMatcha) {
+        result.detectedModels.push_back({"matcha", modelDir});
+    }
+    if (hasPocket) {
+        result.detectedModels.push_back({"pocket", modelDir});
+    }
+    if (hasZipvoice && !hasMatcha) {
+        result.detectedModels.push_back({"zipvoice", modelDir});
+    }
+    if (hasVoicesFile) {
+        if (isLikelyKitten && !isLikelyKokoro) {
+            result.detectedModels.push_back({"kitten", modelDir});
+        } else if (isLikelyKokoro && !isLikelyKitten) {
+            result.detectedModels.push_back({"kokoro", modelDir});
+        } else {
+            result.detectedModels.push_back({"kokoro", modelDir});
+            result.detectedModels.push_back({"kitten", modelDir});
+        }
+    }
+
+    if (hasVits) {
+        bool isLikelyVits = modelDirLower.find("vits") != std::string::npos;
+        bool voicesAmbiguous = !isLikelyKitten && !isLikelyKokoro;
+
+        bool addVits = false;
+        if (!hasVoicesFile) {
+            addVits = true;
+        } else {
+            if (isLikelyVits || voicesAmbiguous) {
+                addVits = true;
+            }
+        }
+
+        if (addVits) {
+            result.detectedModels.push_back({"vits", modelDir});
+        }
+    }
+
+    TtsModelKind selected = TtsModelKind::kUnknown;
+    if (modelType != "auto") {
+        selected = ParseTtsModelType(modelType);
+        if (selected == TtsModelKind::kUnknown) {
+            result.error = "TTS: Unknown model type: " + modelType;
+            return result;
+        }
+    } else {
+        if (hasMatcha) {
+            selected = TtsModelKind::kMatcha;
+        } else if (hasPocket) {
+            selected = TtsModelKind::kPocket;
+        } else if (hasZipvoice) {
+            selected = TtsModelKind::kZipvoice;
+        } else if (hasVoicesFile) {
+            if (isLikelyKitten && !isLikelyKokoro) {
+                selected = TtsModelKind::kKitten;
+            } else if (isLikelyKokoro && !isLikelyKitten) {
+                selected = TtsModelKind::kKokoro;
+            } else {
+                selected = TtsModelKind::kKokoro;
+            }
+        } else if (hasVits) {
+            selected = TtsModelKind::kVits;
+        }
+    }
+
+    if (selected == TtsModelKind::kUnknown) {
+        result.error = "TTS: No compatible model type detected in " + modelDir;
+        return result;
+    }
+
+    if (selected == TtsModelKind::kVits && !hasVits) {
+        result.error = "TTS: VITS model requested but model file not found in " + modelDir;
+        return result;
+    }
+    if (selected == TtsModelKind::kMatcha && !hasMatcha) {
+        result.error = "TTS: Matcha model requested but required files not found in " + modelDir;
+        return result;
+    }
+    if ((selected == TtsModelKind::kKokoro || selected == TtsModelKind::kKitten) && (!hasVits || !hasVoicesFile)) {
+        result.error = "TTS: Kokoro/Kitten model requested but required files not found in " + modelDir;
+        return result;
+    }
+    if (selected == TtsModelKind::kPocket && !hasPocket) {
+        result.error = "TTS: Pocket model requested but required files not found in " + modelDir;
+        return result;
+    }
+    if (selected == TtsModelKind::kZipvoice && !hasZipvoice) {
+        result.error = "TTS: Zipvoice model requested but required files not found in " + modelDir;
+        return result;
+    }
+    if ((selected == TtsModelKind::kVits || selected == TtsModelKind::kMatcha ||
+         selected == TtsModelKind::kKokoro || selected == TtsModelKind::kKitten ||
+         selected == TtsModelKind::kZipvoice) &&
+        !hasDataDir) {
+        result.error = "TTS: espeak-ng-data not found in " + modelDir +
+                       ". Copy espeak-ng-data into the model directory.";
+        return result;
+    }
+
+    result.selectedKind = selected;
+    result.paths.ttsModel = ttsModel;
+    result.paths.tokens = tokensFile;
+    result.paths.lexicon = !lexiconFile.empty() && FileExists(lexiconFile) ? lexiconFile : "";
+    result.paths.dataDir = dataDirPath;
+    result.paths.voices = voicesFile;
+    result.paths.acousticModel = acousticModel;
+    result.paths.vocoder = vocoder;
+    result.paths.encoder = encoder;
+    result.paths.decoder = decoder;
+    result.paths.lmFlow = lmFlow;
+    result.paths.lmMain = lmMain;
+    result.paths.textConditioner = textConditioner;
+    result.paths.vocabJson = vocabJsonFile;
+    result.paths.tokenScoresJson = tokenScoresJsonFile;
+
+    LOGI("DetectTtsModel: selected kind=%d, ttsModel=%s",
+         static_cast<int>(selected), ttsModel.c_str());
+    LOGI("DetectTtsModel: final paths — tokens=%s, dataDir=%s",
+         result.paths.tokens.c_str(), result.paths.dataDir.c_str());
+
+    if (selected != TtsModelKind::kPocket && (tokensFile.empty() || !FileExists(tokensFile))) {
+        result.error = "TTS: tokens.txt not found in " + modelDir;
+        LOGE("%s", result.error.c_str());
+        return result;
+    }
+
+    result.ok = true;
+    LOGI("DetectTtsModel: detection OK for %s", modelDir.c_str());
+    return result;
+}
+
+} // namespace sherpaonnx