react-native-sherpa-onnx 0.3.2 → 0.3.3

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

@@ -1,16 +1,49 @@
 /**
  * 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 <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 +58,117 @@ 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). */
+static bool CapabilitySupportsTtsKind(
+    TtsModelKind kind,
+    bool hasVits,
+    bool hasMatcha,
+    bool hasPocket,
+    bool hasZipvoice,
+    bool hasVoicesFile,
+    bool hasDataDir
+) {
+    switch (kind) {
+        case TtsModelKind::kVits:
+            return hasVits && hasDataDir;
+        case TtsModelKind::kMatcha:
+            return hasMatcha && hasDataDir;
+        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;
+    std::vector<TtsModelKind> out;
+    auto add = [&out](TtsModelKind k) {
+        if (std::find(out.begin(), out.end(), k) == out.end())
+            out.push_back(k);
+    };
 
-    LOGI("DetectTtsModel: modelDir=%s, modelType=%s", modelDir.c_str(), modelType.c_str());
+    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 (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;
-    }
+    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::string lexiconFile = FindFileByName(files, "lexicon.txt");
+    std::string dataDirPath;
+    {
+        const std::string prefix = modelDir + "/espeak-ng-data/";
+        for (const auto& entry : files) {
+            if (entry.path.size() > prefix.size() && entry.path.compare(0, prefix.size(), prefix) == 0) {
+                dataDirPath = modelDir + "/espeak-ng-data";
+                break;
+            }
+        }
+    }
+    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.
+    bool hasVoicesFile = !voicesFile.empty();
     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);
+                     !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 +179,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 +194,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;
         }
     }
 
@@ -173,7 +220,6 @@ TtsDetectResult DetectTtsModel(const std::string& modelDir, const std::string& m
         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;
@@ -182,7 +228,7 @@ TtsDetectResult DetectTtsModel(const std::string& modelDir, const std::string& m
         result.error = "TTS: Matcha model requested but required files not found in " + modelDir;
         return result;
     }
-    if ((selected == TtsModelKind::kKokoro || selected == TtsModelKind::kKitten) && (!hasVits || !hasVoicesFile)) {
+    if ((selected == TtsModelKind::kKokoro || selected == TtsModelKind::kKitten) && (!hasVoicesFile || !hasDataDir)) {
         result.error = "TTS: Kokoro/Kitten model requested but required files not found in " + modelDir;
         return result;
     }
@@ -196,8 +242,7 @@ TtsDetectResult DetectTtsModel(const std::string& modelDir, const std::string& m
     }
     if ((selected == TtsModelKind::kVits || selected == TtsModelKind::kMatcha ||
          selected == TtsModelKind::kKokoro || selected == TtsModelKind::kKitten ||
-         selected == TtsModelKind::kZipvoice) &&
-        !hasDataDir) {
+         selected == TtsModelKind::kZipvoice) && !hasDataDir) {
         result.error = "TTS: espeak-ng-data not found in " + modelDir +
                        ". Copy espeak-ng-data into the model directory.";
         return result;
@@ -206,7 +251,7 @@ TtsDetectResult DetectTtsModel(const std::string& modelDir, const std::string& m
     result.selectedKind = selected;
     result.paths.ttsModel = ttsModel;
     result.paths.tokens = tokensFile;
-    result.paths.lexicon = !lexiconFile.empty() && FileExists(lexiconFile) ? lexiconFile : "";
+    result.paths.lexicon = !lexiconFile.empty() ? lexiconFile : "";
     result.paths.dataDir = dataDirPath;
     result.paths.voices = voicesFile;
     result.paths.acousticModel = acousticModel;
@@ -219,20 +264,70 @@ 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());
-
-    if (selected != TtsModelKind::kPocket && (tokensFile.empty() || !FileExists(tokensFile))) {
+    if (selected != TtsModelKind::kPocket && tokensFile.empty()) {
         result.error = "TTS: tokens.txt not found in " + modelDir;
-        LOGE("%s", result.error.c_str());
         return result;
     }
 
     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;
+    }
+
+    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;
@@ -113,11 +182,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/java/com/sherpaonnx/SherpaOnnxModule.kt

@@ -55,6 +55,7 @@ class SherpaOnnxModule(reactContext: ReactApplicationContext) :
     { instanceId, requestId, cancelled -> emitTtsStreamEnd(instanceId, requestId, cancelled) }
   )
   private val archiveHelper = SherpaOnnxArchiveHelper()
+  private var pcmCapture: SherpaOnnxPcmCapture? = null
 
   override fun getName(): String {
     return NAME
@@ -62,6 +63,8 @@ class SherpaOnnxModule(reactContext: ReactApplicationContext) :
 
   override fun onCatalystInstanceDestroy() {
     super.onCatalystInstanceDestroy()
+    pcmCapture?.stop()
+    pcmCapture = null
     onlineSttHelper.shutdown()
     ttsHelper.shutdown()
   }
@@ -319,12 +322,14 @@ class SherpaOnnxModule(reactContext: ReactApplicationContext) :
         return
       }
       val success = result["success"] as? Boolean ?: false
+      val isHardwareSpecificUnsupported = result["isHardwareSpecificUnsupported"] as? Boolean ?: false
       val detectedModels = result["detectedModels"] as? ArrayList<*>
         ?: arrayListOf<HashMap<String, String>>()
       val modelTypeStr = result["modelType"] as? String
 
       val resultMap = Arguments.createMap()
       resultMap.putBoolean("success", success)
+      resultMap.putBoolean("isHardwareSpecificUnsupported", isHardwareSpecificUnsupported)
       val modelsArray = Arguments.createArray()
       for (model in detectedModels) {
         val modelMap = model as? HashMap<*, *>
@@ -484,6 +489,71 @@ class SherpaOnnxModule(reactContext: ReactApplicationContext) :
     onlineSttHelper.processSttAudioChunk(streamId, samples, sampleRate.toInt(), promise)
   }
 
+  override fun startPcmLiveStream(options: ReadableMap, promise: Promise) {
+    try {
+      pcmCapture?.stop()
+      pcmCapture = null
+      val sampleRate = options.getDouble("sampleRate").toInt().takeIf { it > 0 } ?: 16000
+      val channelCount = if (options.hasKey("channelCount")) options.getDouble("channelCount").toInt().coerceIn(1, 2) else 1
+      val bufferSizeFrames = if (options.hasKey("bufferSizeFrames")) options.getDouble("bufferSizeFrames").toInt() else 0
+      var startError: String? = null
+      var started = false
+      val capture = SherpaOnnxPcmCapture(
+        targetSampleRate = sampleRate,
+        channelCount = channelCount,
+        bufferSizeFrames = bufferSizeFrames,
+        onChunk = { base64Pcm, sr -> emitPcmLiveStreamData(base64Pcm, sr) },
+        onError = { msg ->
+          if (!started) {
+            startError = msg
+          } else {
+            emitPcmLiveStreamError(msg)
+          }
+        },
+        logTag = NAME
+      )
+      pcmCapture = capture
+      capture.start()
+      started = true
+      val err = startError
+      if (err != null) {
+        promise.reject("PCM_LIVE_STREAM_ERROR", err)
+      } else {
+        promise.resolve(null)
+      }
+    } catch (e: Exception) {
+      android.util.Log.e(NAME, "startPcmLiveStream failed", e)
+      promise.reject("PCM_LIVE_STREAM_ERROR", e.message ?: "Failed to start PCM capture", e)
+    }
+  }
+
+  override fun stopPcmLiveStream(promise: Promise) {
+    try {
+      pcmCapture?.stop()
+      pcmCapture = null
+      promise.resolve(null)
+    } catch (e: Exception) {
+      promise.reject("PCM_LIVE_STREAM_ERROR", e.message ?: "Failed to stop PCM capture", e)
+    }
+  }
+
+  private fun emitPcmLiveStreamData(base64Pcm: String, sampleRate: Int) {
+    val eventEmitter = reactApplicationContext
+      .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+    val payload = Arguments.createMap()
+    payload.putString("base64Pcm", base64Pcm)
+    payload.putInt("sampleRate", sampleRate)
+    eventEmitter.emit("pcmLiveStreamData", payload)
+  }
+
+  private fun emitPcmLiveStreamError(message: String) {
+    val eventEmitter = reactApplicationContext
+      .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+    val payload = Arguments.createMap()
+    payload.putString("message", message)
+    eventEmitter.emit("pcmLiveStreamError", payload)
+  }
+
   // ==================== STT Methods ====================
 
   /**