react-native-sherpa-onnx 0.3.2 → 0.3.4

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

@@ -1,16 +1,50 @@
 /**
  * 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).
+ * Purpose: Detects TTS model type and fills TtsModelPaths from a model directory. Used by
+ * nativeDetectTtsModel (module-jni). Supports Vits, Matcha, Kokoro, Kitten, Pocket, Zipvoice.
+ *
+ * --- Detection pipeline (overview) ---
+ *
+ * 1. Gather files in modelDir (recursive), then map file names to logical paths (ttsModel,
+ *    acousticModel, vocoder, encoder, decoder, lmFlow, lmMain, textConditioner, tokens, lexicon,
+ *    dataDir, voices, vocabJson, tokenScoresJson). Path hints from directory name (isLikelyVits,
+ *    isLikelyKitten, isLikelyKokoro).
+ *
+ * 2. Capabilities (hasVits, hasMatcha, hasPocket, hasZipvoice, hasVoicesFile, hasDataDir): which
+ *    model types are *possible* given the paths. Multiple can be true (e.g. voices.bin can satisfy
+ *    both Kokoro and Kitten).
+ *
+ * 3. detectedModels (for UI "Select model type"): built from capabilities only. Every kind with
+ *    the corresponding has* == true is added (with existing rules: zipvoice only if !hasMatcha,
+ *    vits when hasVits and no voices or ambiguous folder name).
+ *
+ * 4. selectedKind: from ResolveTtsKind(). If modelType is explicit, use it if capabilities allow.
+ *    If modelType == "auto": Priority 1 = folder name (GetKindsFromDirNameTts: tokens like "vits",
+ *    "matcha", "kokoro" in dir name --> candidate kinds). Priority 2 = among those candidates, pick
+ *    the first that CapabilitySupportsTtsKind(). Fallback = file-only order (matcha --> pocket -->
+ *    zipvoice --> kokoro/kitten --> vits).
+ *
+ * 5. paths: all gathered paths are written into result.paths; the selected kind determines which
+ *    engine is used at runtime.
+ *
+ * Result to caller: ok, error, detectedModels (list), selectedKind (single), paths.
  */
 #include "sherpa-onnx-model-detect.h"
 #include "sherpa-onnx-model-detect-helper.h"
+#include "sherpa-onnx-validate-tts.h"
+#include <algorithm>
+#include <string>
+#include <vector>
+#ifdef __ANDROID__
 #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__)
+#else
+#define LOGI(...) ((void)0)
+#define LOGE(...) ((void)0)
+#endif
 
 namespace sherpaonnx {
 namespace {
@@ -25,94 +59,120 @@ TtsModelKind ParseTtsModelType(const std::string& modelType) {
     return TtsModelKind::kUnknown;
 }
 
-} // namespace
+/** Returns true if the given kind is supported by the current paths and hints (required files present).
+ *  data_dir (espeak-ng-data) is required only for Kitten and Kokoro (sherpa-onnx config Validate());
+ *  VITS, Matcha, Zipvoice use it optionally; Pocket does not use it. */
+static bool CapabilitySupportsTtsKind(
+    TtsModelKind kind,
+    bool hasVits,
+    bool hasMatcha,
+    bool hasPocket,
+    bool hasZipvoice,
+    bool hasVoicesFile,
+    bool hasDataDir
+) {
+    switch (kind) {
+        case TtsModelKind::kVits:
+            return hasVits;
+        case TtsModelKind::kMatcha:
+            return hasMatcha;
+        case TtsModelKind::kKokoro:
+        case TtsModelKind::kKitten:
+            return hasVoicesFile && hasDataDir;
+        case TtsModelKind::kPocket:
+            return hasPocket;
+        case TtsModelKind::kZipvoice:
+            return hasZipvoice;
+        default:
+            return false;
+    }
+}
 
-TtsDetectResult DetectTtsModel(const std::string& modelDir, const std::string& modelType) {
+/**
+ * Priority 1: Collect candidate TTS kinds from the model directory name (last path component).
+ * Tokens like "vits", "matcha", "kokoro" are matched case-insensitively. Returns candidates in a
+ * fixed priority order for file-based disambiguation when multiple names match.
+ */
+static std::vector<TtsModelKind> GetKindsFromDirNameTts(const std::string& modelDir) {
     using namespace model_detect;
+    size_t pos = modelDir.find_last_of("/\\");
+    std::string base = (pos == std::string::npos) ? modelDir : modelDir.substr(pos + 1);
+    std::string lower = ToLower(base);
 
-    TtsDetectResult result;
-
-    LOGI("DetectTtsModel: modelDir=%s, modelType=%s", modelDir.c_str(), modelType.c_str());
+    std::vector<TtsModelKind> out;
+    auto add = [&out](TtsModelKind k) {
+        if (std::find(out.begin(), out.end(), k) == out.end())
+            out.push_back(k);
+    };
 
-    if (modelDir.empty()) {
-        result.error = "TTS: Model directory is empty";
-        LOGE("%s", result.error.c_str());
-        return result;
-    }
+    if (lower.find("matcha") != std::string::npos) add(TtsModelKind::kMatcha);
+    if (lower.find("pocket") != std::string::npos) add(TtsModelKind::kPocket);
+    if (lower.find("zipvoice") != std::string::npos) add(TtsModelKind::kZipvoice);
+    if (lower.find("kokoro") != std::string::npos) add(TtsModelKind::kKokoro);
+    if (lower.find("kitten") != std::string::npos) add(TtsModelKind::kKitten);
+    if (lower.find("vits") != std::string::npos) add(TtsModelKind::kVits);
 
-    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;
-    }
+    return out;
+}
 
-    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);
-    }
+/** Shared detection logic: runs on a pre-built file list. No filesystem access, no logging. */
+static TtsDetectResult DetectTtsModelFromFiles(
+    const std::vector<model_detect::FileEntry>& files,
+    const std::string& modelDir,
+    const std::string& modelType
+) {
+    using namespace model_detect;
 
-    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);
+    TtsDetectResult result;
 
-    LOGI("DetectTtsModel: tokens=%s, lexicon=%s, dataDir=%s, voices=%s",
-         tokensFile.c_str(), lexiconFile.c_str(), dataDirPath.c_str(), voicesFile.c_str());
+    std::string tokensFile = FindFileByName(files, "tokens.txt");
+    std::vector<LexiconCandidate> lexiconCandidates = FindLexiconCandidates(files, modelDir);
+    std::string dataDirPath = FindDirectoryUnderRoot(files, modelDir, "espeak-ng-data");
+    std::string voicesFile = FindFileByName(files, "voices.bin");
 
     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::string vocabJsonFile = FindFileByName(files, "vocab.json");
+    std::string tokenScoresJsonFile = FindFileByName(files, "token_scores.json");
 
     std::vector<std::string> modelExcludes = {
-        "acoustic",
-        "vocoder",
-        "encoder",
-        "decoder",
-        "joiner"
+        "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.
+    std::string modelDirLower = ToLower(modelDir);
+    bool isLikelyMatcha = modelDirLower.find("matcha") != std::string::npos;
+    bool hasMatcha = (!acousticModel.empty() && !vocoder.empty())
+        || (isLikelyMatcha && !ttsModel.empty() && !tokensFile.empty());
+    if (hasMatcha && acousticModel.empty())
+        acousticModel = ttsModel;  // single-file Matcha: model.onnx is the acoustic model
+    bool hasVoicesFile = !voicesFile.empty();
+    bool isLikelyZipvoice = modelDirLower.find("zipvoice") != std::string::npos;
     bool hasZipvoice = !encoder.empty() && !decoder.empty() && !vocoder.empty();
+    if (isLikelyZipvoice && !encoder.empty() && !decoder.empty() && vocoder.empty()) {
+        result.ok = false;
+        result.error = "TTS: Zipvoice distill variant (no vocoder) is not supported. Use a full Zipvoice model with vocoder or add vocos_24khz.onnx separately.";
+        return result;
+    }
     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);
+                     !textConditioner.empty() && !vocabJsonFile.empty() && !tokenScoresJsonFile.empty();
+    bool hasDataDir = !dataDirPath.empty();
 
-    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 (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});
@@ -123,23 +183,11 @@ TtsDetectResult DetectTtsModel(const std::string& modelDir, const std::string& m
             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});
-        }
+        bool addVits = !hasVoicesFile || isLikelyVits || voicesAmbiguous;
+        if (addVits) result.detectedModels.push_back({"vits", modelDir});
     }
 
     TtsModelKind selected = TtsModelKind::kUnknown;
@@ -150,22 +198,25 @@ TtsDetectResult DetectTtsModel(const std::string& modelDir, const std::string& m
             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;
+        std::vector<TtsModelKind> nameCandidates = GetKindsFromDirNameTts(modelDir);
+        if (!nameCandidates.empty()) {
+            for (TtsModelKind k : nameCandidates) {
+                if (CapabilitySupportsTtsKind(k, hasVits, hasMatcha, hasPocket, hasZipvoice,
+                                              hasVoicesFile, hasDataDir)) {
+                    selected = k;
+                    break;
+                }
             }
-        } else if (hasVits) {
-            selected = TtsModelKind::kVits;
+        }
+        if (selected == TtsModelKind::kUnknown) {
+            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;
         }
     }
 
@@ -174,39 +225,22 @@ TtsDetectResult DetectTtsModel(const std::string& modelDir, const std::string& m
         return result;
     }
 
-    if (selected == TtsModelKind::kVits && !hasVits) {
-        result.error = "TTS: VITS model requested but model file not found in " + modelDir;
-        return result;
+    std::string lexiconPath;
+    for (const auto& c : lexiconCandidates) {
+        result.lexiconLanguageCandidates.push_back(c.languageId);
     }
-    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 (!lexiconCandidates.empty()) {
+        lexiconPath = lexiconCandidates[0].path;
     }
-    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;
+
+    if (selected == TtsModelKind::kMatcha && !acousticModel.empty() && vocoder.empty()) {
+        vocoder = acousticModel;
     }
 
     result.selectedKind = selected;
     result.paths.ttsModel = ttsModel;
     result.paths.tokens = tokensFile;
-    result.paths.lexicon = !lexiconFile.empty() && FileExists(lexiconFile) ? lexiconFile : "";
+    result.paths.lexicon = lexiconPath;
     result.paths.dataDir = dataDirPath;
     result.paths.voices = voicesFile;
     result.paths.acousticModel = acousticModel;
@@ -219,20 +253,72 @@ TtsDetectResult DetectTtsModel(const std::string& modelDir, const std::string& m
     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());
+    auto validation = ValidateTtsPaths(selected, result.paths, modelDir);
+    if (!validation.ok) {
+        result.ok = false;
+        result.error = validation.error;
+        return result;
+    }
 
-    if (selected != TtsModelKind::kPocket && (tokensFile.empty() || !FileExists(tokensFile))) {
-        result.error = "TTS: tokens.txt not found in " + modelDir;
+    result.ok = true;
+    return result;
+}
+
+} // 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;
     }
 
-    result.ok = true;
+    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);
+    }
+
+    result = DetectTtsModelFromFiles(files, modelDir, modelType);
+    if (!result.ok) {
+        if (!result.error.empty()) LOGE("%s", result.error.c_str());
+        return result;
+    }
+    LOGI("DetectTtsModel: tokens=%s, lexicon=%s, dataDir=%s, voices=%s",
+         result.paths.tokens.c_str(), result.paths.lexicon.c_str(),
+         result.paths.dataDir.c_str(), result.paths.voices.c_str());
+    LOGI("DetectTtsModel: selected kind=%d, ttsModel=%s",
+         static_cast<int>(result.selectedKind), result.paths.ttsModel.c_str());
+    LOGI("DetectTtsModel: final paths — tokens=%s, dataDir=%s",
+         result.paths.tokens.c_str(), result.paths.dataDir.c_str());
     LOGI("DetectTtsModel: detection OK for %s", modelDir.c_str());
     return result;
 }
 
+// Test-only: used by host-side model_detect_test; not used in production (Android/iOS use DetectTtsModel).
+TtsDetectResult DetectTtsModelFromFileList(
+    const std::vector<model_detect::FileEntry>& files,
+    const std::string& modelDir,
+    const std::string& modelType
+) {
+    TtsDetectResult result;
+    if (modelDir.empty()) {
+        result.error = "TTS: Model directory is empty";
+        return result;
+    }
+    return DetectTtsModelFromFiles(files, modelDir, modelType);
+}
+
 } // namespace sherpaonnx

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

@@ -2,6 +2,7 @@
 #define SHERPA_ONNX_MODEL_DETECT_H
 
 #include "sherpa-onnx-common.h"
+#include "sherpa-onnx-model-detect-helper.h"
 #include <optional>
 #include <string>
 #include <vector>
@@ -21,6 +22,7 @@ enum class SttModelKind {
     kFunAsrNano,
     kFireRedAsr,
     kMoonshine,
+    kMoonshineV2,
     kDolphin,
     kCanary,
     kOmnilingual,
@@ -59,6 +61,8 @@ struct SttModelPaths {
     std::string moonshineEncoder;
     std::string moonshineUncachedDecoder;
     std::string moonshineCachedDecoder;
+    /** Moonshine v2: encoder + mergedDecoder (reuse moonshineEncoder for encoder path). */
+    std::string moonshineMergedDecoder;
     // Dolphin, Omnilingual, MedAsr, TeleSpeech (single model each)
     std::string dolphinModel;
     std::string omnilingualModel;
@@ -71,6 +75,69 @@ struct SttModelPaths {
     std::string canaryDecoder;
 };
 
+/** All candidate paths gathered before model kind selection (used by STT detection steps). */
+struct SttCandidatePaths {
+    std::string encoder;
+    std::string decoder;
+    std::string joiner;
+    std::string paraformerModel;
+    std::string ctcModel;
+    std::string tokens;
+    std::string bpeVocab;
+    std::string funasrEncoderAdaptor;
+    std::string funasrLLM;
+    std::string funasrEmbedding;
+    std::string funasrTokenizerDir;
+    std::string moonshinePreprocessor;
+    std::string moonshineEncoder;
+    std::string moonshineUncachedDecoder;
+    std::string moonshineCachedDecoder;
+    std::string moonshineMergedDecoder;
+    std::string encoderForV2;
+};
+
+/** Path hints derived from model directory name (isLikely* flags). */
+struct SttPathHints {
+    bool isLikelyNemo = false;
+    bool isLikelyTdt = false;
+    bool isLikelyWenetCtc = false;
+    bool isLikelySenseVoice = false;
+    bool isLikelyFunAsrNano = false;
+    bool isLikelyZipformer = false;
+    bool isLikelyMoonshine = false;
+    bool isLikelyDolphin = false;
+    bool isLikelyFireRedAsr = false;
+    bool isLikelyCanary = false;
+    bool isLikelyOmnilingual = false;
+    bool isLikelyMedAsr = false;
+    bool isLikelyTeleSpeech = false;
+    bool isLikelyToneCtc = false;
+    bool isLikelyParaformer = false;
+    /** VAD (silero, ten-vad, etc.): not yet supported; when true, detection returns unsupported. */
+    bool isLikelyVad = false;
+    /** TDNN (keyword/yesno): not yet supported; when true, detection returns unsupported. */
+    bool isLikelyTdnn = false;
+};
+
+/** Which model types are possible given paths and hints (has* flags). */
+struct SttCapabilities {
+    bool hasTransducer = false;
+    bool hasWhisper = false;
+    bool hasMoonshine = false;
+    bool hasMoonshineV2 = false;
+    bool hasParaformer = false;
+    bool hasFunAsrNano = false;
+    bool hasDolphin = false;
+    bool hasFireRedAsr = false;
+    /** True when dir name suggests Fire Red but only a single CTC/paraformer model (no encoder/decoder). Use zipformer_ctc. */
+    bool hasFireRedCtc = false;
+    bool hasCanary = false;
+    bool hasOmnilingual = false;
+    bool hasMedAsr = false;
+    bool hasTeleSpeechCtc = false;
+    bool hasToneCtc = false;
+};
+
 struct TtsModelPaths {
     std::string ttsModel;
     std::string tokens;
@@ -92,6 +159,8 @@ struct TtsModelPaths {
 struct SttDetectResult {
     bool ok = false;
     std::string error;
+    /** True when detection failed because the model is for unsupported hardware (RK35xx, Ascend, CANN, etc.). */
+    bool isHardwareSpecificUnsupported = false;
     std::vector<DetectedModel> detectedModels;
     SttModelKind selectedKind = SttModelKind::kUnknown;
     bool tokensRequired = true;
@@ -104,6 +173,8 @@ struct TtsDetectResult {
     std::vector<DetectedModel> detectedModels;
     TtsModelKind selectedKind = TtsModelKind::kUnknown;
     TtsModelPaths paths;
+    /** Language ids from detected lexicon files (e.g. "default", "us-en", "zh") for multi-lang Kokoro/Kitten. Empty when not applicable. */
+    std::vector<std::string> lexiconLanguageCandidates;
 };
 
 SttDetectResult DetectSttModel(
@@ -113,11 +184,32 @@ SttDetectResult DetectSttModel(
     bool debug = false
 );
 
+/** Test-only: Like DetectSttModel but takes a pre-built file list; no filesystem access.
+ *  Only used by the host-side C++ test suite (test/cpp/model_detect_test.cpp). Not used in
+ *  production (Android/iOS use DetectSttModel). Does not validate modelDir existence or
+ *  call FileExists on tokens/bpeVocab. */
+SttDetectResult DetectSttModelFromFileList(
+    const std::vector<model_detect::FileEntry>& files,
+    const std::string& modelDir,
+    const std::optional<bool>& preferInt8 = std::nullopt,
+    const std::optional<std::string>& modelType = std::nullopt
+);
+
 TtsDetectResult DetectTtsModel(
     const std::string& modelDir,
     const std::string& modelType
 );
 
+/** Test-only: Like DetectTtsModel but takes a pre-built file list; no filesystem access.
+ *  Only used by the host-side C++ test suite (test/cpp/model_detect_test.cpp). Not used in
+ *  production (Android/iOS use DetectTtsModel). Does not validate modelDir existence or
+ *  call FileExists / IsDirectory. */
+TtsDetectResult DetectTtsModelFromFileList(
+    const std::vector<model_detect::FileEntry>& files,
+    const std::string& modelDir,
+    const std::string& modelType = "auto"
+);
+
 } // namespace sherpaonnx
 
 #endif // SHERPA_ONNX_MODEL_DETECT_H

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

@@ -25,6 +25,7 @@ const char* SttModelKindToString(SttModelKind k) {
     case SttModelKind::kFunAsrNano: return "funasr_nano";
     case SttModelKind::kFireRedAsr: return "fire_red_asr";
     case SttModelKind::kMoonshine: return "moonshine";
+    case SttModelKind::kMoonshineV2: return "moonshine_v2";
     case SttModelKind::kDolphin: return "dolphin";
     case SttModelKind::kCanary: return "canary";
     case SttModelKind::kOmnilingual: return "omnilingual";
@@ -52,6 +53,7 @@ jobject SttDetectResultToJava(JNIEnv* env, const SttDetectResult& result) {
 
   PutBoolean(env, map, mapPut, "success", result.ok);
   PutString(env, map, mapPut, "error", result.error);
+  PutBoolean(env, map, mapPut, "isHardwareSpecificUnsupported", result.isHardwareSpecificUnsupported);
   PutString(env, map, mapPut, "modelType", SttModelKindToString(result.selectedKind));
 
   jobject detectedList = BuildDetectedModelsList(env, result.detectedModels);
@@ -81,6 +83,7 @@ jobject SttDetectResultToJava(JNIEnv* env, const SttDetectResult& result) {
       PutString(env, pathsMap, mapPut, "moonshineEncoder", result.paths.moonshineEncoder);
       PutString(env, pathsMap, mapPut, "moonshineUncachedDecoder", result.paths.moonshineUncachedDecoder);
       PutString(env, pathsMap, mapPut, "moonshineCachedDecoder", result.paths.moonshineCachedDecoder);
+      PutString(env, pathsMap, mapPut, "moonshineMergedDecoder", result.paths.moonshineMergedDecoder);
       PutString(env, pathsMap, mapPut, "dolphinModel", result.paths.dolphinModel);
       PutString(env, pathsMap, mapPut, "omnilingualModel", result.paths.omnilingualModel);
       PutString(env, pathsMap, mapPut, "medasrModel", result.paths.medasrModel);

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

@@ -45,10 +45,20 @@ jobject TtsDetectResultToJava(JNIEnv* env, const TtsDetectResult& result) {
 
   jobject detectedList = BuildDetectedModelsList(env, result.detectedModels);
   if (detectedList) {
-    env->CallObjectMethod(map, mapPut, env->NewStringUTF("detectedModels"), detectedList);
+    jstring keyDetected = env->NewStringUTF("detectedModels");
+    env->CallObjectMethod(map, mapPut, keyDetected, detectedList);
+    env->DeleteLocalRef(keyDetected);
     env->DeleteLocalRef(detectedList);
   }
 
+  jobject langCandidatesList = BuildStringList(env, result.lexiconLanguageCandidates);
+  if (langCandidatesList) {
+    jstring keyLangCandidates = env->NewStringUTF("lexiconLanguageCandidates");
+    env->CallObjectMethod(map, mapPut, keyLangCandidates, langCandidatesList);
+    env->DeleteLocalRef(keyLangCandidates);
+    env->DeleteLocalRef(langCandidatesList);
+  }
+
   jclass hashMapClass = env->FindClass("java/util/HashMap");
   if (hashMapClass) {
     jobject pathsMap = env->NewObject(hashMapClass, mapInit);
@@ -68,7 +78,9 @@ jobject TtsDetectResultToJava(JNIEnv* env, const TtsDetectResult& result) {
       PutString(env, pathsMap, mapPut, "textConditioner", result.paths.textConditioner);
       PutString(env, pathsMap, mapPut, "vocabJson", result.paths.vocabJson);
       PutString(env, pathsMap, mapPut, "tokenScoresJson", result.paths.tokenScoresJson);
-      env->CallObjectMethod(map, mapPut, env->NewStringUTF("paths"), pathsMap);
+      jstring keyPaths = env->NewStringUTF("paths");
+      env->CallObjectMethod(map, mapPut, keyPaths, pathsMap);
+      env->DeleteLocalRef(keyPaths);
       env->DeleteLocalRef(pathsMap);
     }
   }