react-native-sherpa-onnx 0.3.8 → 0.4.0

package/ios/enhancement/sherpa-onnx-enhancement-wrapper.h

@@ -0,0 +1,85 @@
+#ifndef SHERPA_ONNX_ENHANCEMENT_WRAPPER_H
+#define SHERPA_ONNX_ENHANCEMENT_WRAPPER_H
+
+#include "sherpa-onnx-common.h"
+#include "sherpa-onnx-model-detect.h"
+#include <cstdint>
+#include <memory>
+#include <optional>
+#include <string>
+#include <vector>
+
+namespace sherpaonnx {
+
+struct EnhancementInitializeResult {
+    bool success = false;
+    std::vector<DetectedModel> detectedModels;
+    std::string error;
+    std::string modelType;
+    int32_t sampleRate = 0;
+    int32_t frameShiftInSamples = 0;
+};
+
+struct EnhancedAudioResult {
+    std::vector<float> samples;
+    int32_t sampleRate = 0;
+};
+
+class EnhancementWrapper {
+public:
+    EnhancementWrapper();
+    ~EnhancementWrapper();
+
+    EnhancementInitializeResult initialize(
+        const std::string& modelDir,
+        const std::string& modelType = "auto",
+        int32_t numThreads = 1,
+        const std::optional<std::string>& provider = std::nullopt,
+        bool debug = false
+    );
+
+    EnhancedAudioResult runSamples(const std::vector<float>& samples, int32_t sampleRate);
+
+    int32_t getSampleRate() const;
+
+    bool isInitialized() const;
+
+    void release();
+
+private:
+    class Impl;
+    std::unique_ptr<Impl> pImpl;
+};
+
+class OnlineEnhancementWrapper {
+public:
+    OnlineEnhancementWrapper();
+    ~OnlineEnhancementWrapper();
+
+    EnhancementInitializeResult initialize(
+        const std::string& modelDir,
+        const std::string& modelType = "auto",
+        int32_t numThreads = 1,
+        const std::optional<std::string>& provider = std::nullopt,
+        bool debug = false
+    );
+
+    EnhancedAudioResult runSamples(const std::vector<float>& samples, int32_t sampleRate);
+    EnhancedAudioResult flush();
+    void reset();
+
+    int32_t getSampleRate() const;
+    int32_t getFrameShiftInSamples() const;
+
+    bool isInitialized() const;
+
+    void release();
+
+private:
+    class Impl;
+    std::unique_ptr<Impl> pImpl;
+};
+
+} // namespace sherpaonnx
+
+#endif // SHERPA_ONNX_ENHANCEMENT_WRAPPER_H

package/ios/enhancement/sherpa-onnx-enhancement-wrapper.mm

@@ -0,0 +1,218 @@
+#include "sherpa-onnx-enhancement-wrapper.h"
+
+#include "sherpa-onnx-model-detect.h"
+
+#include <optional>
+
+#include "sherpa-onnx/c-api/cxx-api.h"
+
+namespace sherpaonnx {
+namespace {
+
+std::string EnhancementKindToString(EnhancementModelKind kind) {
+    switch (kind) {
+        case EnhancementModelKind::kGtcrn:
+            return "gtcrn";
+        case EnhancementModelKind::kDpdfNet:
+            return "dpdfnet";
+        default:
+            return "unknown";
+    }
+}
+
+sherpa_onnx::cxx::OfflineSpeechDenoiserModelConfig BuildModelConfig(
+    const EnhancementDetectResult& detect,
+    int32_t numThreads,
+    const std::optional<std::string>& provider,
+    bool debug
+) {
+    sherpa_onnx::cxx::OfflineSpeechDenoiserModelConfig cfg;
+    cfg.num_threads = numThreads;
+    cfg.debug = debug;
+    if (provider.has_value() && !provider->empty()) {
+        cfg.provider = *provider;
+    }
+    switch (detect.selectedKind) {
+        case EnhancementModelKind::kGtcrn:
+            cfg.gtcrn.model = detect.paths.model;
+            break;
+        case EnhancementModelKind::kDpdfNet:
+            cfg.dpdfnet.model = detect.paths.model;
+            break;
+        default:
+            break;
+    }
+    return cfg;
+}
+
+EnhancedAudioResult ToEnhancedAudioResult(
+    const sherpa_onnx::cxx::DenoisedAudio& audio
+) {
+    EnhancedAudioResult out;
+    out.samples = audio.samples;
+    out.sampleRate = audio.sample_rate;
+    return out;
+}
+
+} // namespace
+
+class EnhancementWrapper::Impl {
+public:
+    bool initialized = false;
+    std::optional<sherpa_onnx::cxx::OfflineSpeechDenoiser> denoiser;
+};
+
+EnhancementWrapper::EnhancementWrapper() : pImpl(std::make_unique<Impl>()) {}
+
+EnhancementWrapper::~EnhancementWrapper() { release(); }
+
+EnhancementInitializeResult EnhancementWrapper::initialize(
+    const std::string& modelDir,
+    const std::string& modelType,
+    int32_t numThreads,
+    const std::optional<std::string>& provider,
+    bool debug
+) {
+    EnhancementInitializeResult result;
+    if (pImpl->initialized) {
+        release();
+    }
+    if (modelDir.empty()) {
+        result.error = "Enhancement model directory is empty";
+        return result;
+    }
+
+    auto detect = DetectEnhancementModel(modelDir, modelType);
+    result.detectedModels = detect.detectedModels;
+    result.modelType = EnhancementKindToString(detect.selectedKind);
+    if (!detect.ok) {
+        result.error = detect.error;
+        return result;
+    }
+
+    sherpa_onnx::cxx::OfflineSpeechDenoiserConfig config;
+    config.model = BuildModelConfig(detect, numThreads, provider, debug);
+    pImpl->denoiser = sherpa_onnx::cxx::OfflineSpeechDenoiser::Create(config);
+    pImpl->initialized = true;
+
+    result.success = true;
+    result.sampleRate = pImpl->denoiser->GetSampleRate();
+    return result;
+}
+
+EnhancedAudioResult EnhancementWrapper::runSamples(
+    const std::vector<float>& samples,
+    int32_t sampleRate
+) {
+    if (!pImpl->initialized || !pImpl->denoiser.has_value()) {
+        return {};
+    }
+    return ToEnhancedAudioResult(
+        pImpl->denoiser->Run(samples.data(), static_cast<int32_t>(samples.size()), sampleRate)
+    );
+}
+
+int32_t EnhancementWrapper::getSampleRate() const {
+    if (!pImpl->initialized || !pImpl->denoiser.has_value()) return 0;
+    return pImpl->denoiser->GetSampleRate();
+}
+
+bool EnhancementWrapper::isInitialized() const { return pImpl->initialized; }
+
+void EnhancementWrapper::release() {
+    if (pImpl->denoiser.has_value()) {
+        pImpl->denoiser.reset();
+    }
+    pImpl->initialized = false;
+}
+
+class OnlineEnhancementWrapper::Impl {
+public:
+    bool initialized = false;
+    std::optional<sherpa_onnx::cxx::OnlineSpeechDenoiser> denoiser;
+};
+
+OnlineEnhancementWrapper::OnlineEnhancementWrapper()
+    : pImpl(std::make_unique<Impl>()) {}
+
+OnlineEnhancementWrapper::~OnlineEnhancementWrapper() { release(); }
+
+EnhancementInitializeResult OnlineEnhancementWrapper::initialize(
+    const std::string& modelDir,
+    const std::string& modelType,
+    int32_t numThreads,
+    const std::optional<std::string>& provider,
+    bool debug
+) {
+    EnhancementInitializeResult result;
+    if (pImpl->initialized) {
+        release();
+    }
+    if (modelDir.empty()) {
+        result.error = "Enhancement model directory is empty";
+        return result;
+    }
+
+    auto detect = DetectEnhancementModel(modelDir, modelType);
+    result.detectedModels = detect.detectedModels;
+    result.modelType = EnhancementKindToString(detect.selectedKind);
+    if (!detect.ok) {
+        result.error = detect.error;
+        return result;
+    }
+
+    sherpa_onnx::cxx::OnlineSpeechDenoiserConfig config;
+    config.model = BuildModelConfig(detect, numThreads, provider, debug);
+    pImpl->denoiser = sherpa_onnx::cxx::OnlineSpeechDenoiser::Create(config);
+    pImpl->initialized = true;
+
+    result.success = true;
+    result.sampleRate = pImpl->denoiser->GetSampleRate();
+    result.frameShiftInSamples = pImpl->denoiser->GetFrameShiftInSamples();
+    return result;
+}
+
+EnhancedAudioResult OnlineEnhancementWrapper::runSamples(
+    const std::vector<float>& samples,
+    int32_t sampleRate
+) {
+    if (!pImpl->initialized || !pImpl->denoiser.has_value()) {
+        return {};
+    }
+    return ToEnhancedAudioResult(
+        pImpl->denoiser->Run(samples.data(), static_cast<int32_t>(samples.size()), sampleRate)
+    );
+}
+
+EnhancedAudioResult OnlineEnhancementWrapper::flush() {
+    if (!pImpl->initialized || !pImpl->denoiser.has_value()) {
+        return {};
+    }
+    return ToEnhancedAudioResult(pImpl->denoiser->Flush());
+}
+
+void OnlineEnhancementWrapper::reset() {
+    if (!pImpl->initialized || !pImpl->denoiser.has_value()) return;
+    pImpl->denoiser->Reset();
+}
+
+int32_t OnlineEnhancementWrapper::getSampleRate() const {
+    if (!pImpl->initialized || !pImpl->denoiser.has_value()) return 0;
+    return pImpl->denoiser->GetSampleRate();
+}
+
+int32_t OnlineEnhancementWrapper::getFrameShiftInSamples() const {
+    if (!pImpl->initialized || !pImpl->denoiser.has_value()) return 0;
+    return pImpl->denoiser->GetFrameShiftInSamples();
+}
+
+bool OnlineEnhancementWrapper::isInitialized() const { return pImpl->initialized; }
+
+void OnlineEnhancementWrapper::release() {
+    if (pImpl->denoiser.has_value()) {
+        pImpl->denoiser.reset();
+    }
+    pImpl->initialized = false;
+}
+
+} // namespace sherpaonnx

package/ios/model_detect/sherpa-onnx-model-detect-enhancement.mm

@@ -0,0 +1,92 @@
+#include "sherpa-onnx-model-detect.h"
+#include "sherpa-onnx-model-detect-helper.h"
+#include "sherpa-onnx-validate-enhancement.h"
+
+#include <optional>
+#include <string>
+#include <vector>
+
+namespace sherpaonnx {
+namespace {
+
+using namespace model_detect;
+
+EnhancementModelKind ParseEnhancementModelType(const std::string& modelType) {
+    if (modelType == "gtcrn") return EnhancementModelKind::kGtcrn;
+    if (modelType == "dpdfnet") return EnhancementModelKind::kDpdfNet;
+    return EnhancementModelKind::kUnknown;
+}
+
+} // namespace
+
+EnhancementDetectResult DetectEnhancementModel(
+    const std::string& modelDir,
+    const std::string& modelType
+) {
+    EnhancementDetectResult result;
+
+    if (modelDir.empty()) {
+        result.error = "Enhancement: model directory is empty";
+        return result;
+    }
+    if (!FileExists(modelDir) || !IsDirectory(modelDir)) {
+        result.error =
+            "Enhancement: model directory does not exist or is not a directory: " +
+            modelDir;
+        return result;
+    }
+
+    const std::vector<FileEntry> files = ListFilesRecursive(modelDir, 4);
+    const std::string gtcrnModel =
+        FindOnnxByAnyToken(files, {"gtcrn"}, std::nullopt);
+    const std::string dpdfnetModel =
+        FindOnnxByAnyToken(files, {"dpdfnet"}, std::nullopt);
+
+    if (!gtcrnModel.empty()) {
+        result.detectedModels.push_back({"gtcrn", modelDir});
+    }
+    if (!dpdfnetModel.empty()) {
+        result.detectedModels.push_back({"dpdfnet", modelDir});
+    }
+
+    EnhancementModelKind selected = EnhancementModelKind::kUnknown;
+    if (modelType == "auto" || modelType.empty()) {
+        if (!gtcrnModel.empty()) {
+            selected = EnhancementModelKind::kGtcrn;
+        } else if (!dpdfnetModel.empty()) {
+            selected = EnhancementModelKind::kDpdfNet;
+        }
+    } else {
+        selected = ParseEnhancementModelType(modelType);
+        if (selected == EnhancementModelKind::kUnknown) {
+            result.error = "Enhancement: unknown model type: " + modelType;
+            return result;
+        }
+    }
+
+    switch (selected) {
+        case EnhancementModelKind::kGtcrn:
+            result.paths.model = gtcrnModel;
+            break;
+        case EnhancementModelKind::kDpdfNet:
+            result.paths.model = dpdfnetModel;
+            break;
+        default:
+            result.error = "Enhancement: no compatible model type detected in " +
+                           modelDir;
+            return result;
+    }
+
+    auto validation =
+        ValidateEnhancementPaths(selected, result.paths, modelDir);
+    if (!validation.ok) {
+        result.error = validation.error;
+        return result;
+    }
+
+    result.selectedKind = selected;
+    result.ok = true;
+    return result;
+}
+
+} // namespace sherpaonnx

package/ios/model_detect/sherpa-onnx-model-detect-helper.h

@@ -80,6 +80,11 @@ std::vector<LexiconCandidate> FindLexiconCandidates(
     const std::string& rootDir
 );
 
+bool Qwen3TokenizerDirHasVocabAndMerges(
+    const std::vector<FileEntry>& files,
+    const std::string& dir
+);
+
 } // namespace model_detect
 } // namespace sherpaonnx
 

package/ios/model_detect/sherpa-onnx-model-detect-helper.mm

@@ -257,5 +257,28 @@ std::vector<LexiconCandidate> FindLexiconCandidates(
     return candidates;
 }
 
+bool Qwen3TokenizerDirHasVocabAndMerges(
+    const std::vector<FileEntry>& files,
+    const std::string& dirRaw
+) {
+    std::string dir = dirRaw;
+    while (!dir.empty() && (dir.back() == '/' || dir.back() == '\\'))
+        dir.pop_back();
+    if (dir.empty()) return false;
+    bool hasVocab = false;
+    bool hasMerges = false;
+    const std::string prefix = dir + "/";
+    for (const auto& e : files) {
+        if (e.path.size() <= prefix.size()) continue;
+        if (e.path.compare(0, prefix.size(), prefix) != 0) continue;
+        std::string rest = e.path.substr(prefix.size());
+        if (rest.find('/') != std::string::npos || rest.find('\\') != std::string::npos) continue;
+        if (e.nameLower == "vocab.json") hasVocab = true;
+        if (e.nameLower == "merges.txt") hasMerges = true;
+    }
+    if (hasVocab && hasMerges) return true;
+    return FileExists(dir + "/vocab.json") && FileExists(dir + "/merges.txt");
+}
+
 } // namespace model_detect
 } // namespace sherpaonnx

package/ios/model_detect/sherpa-onnx-model-detect-stt.mm

@@ -58,6 +58,7 @@ static const char* KindToName(SttModelKind k) {
         case SttModelKind::kZipformerCtc: return "zipformer_ctc";
         case SttModelKind::kWhisper: return "whisper";
         case SttModelKind::kFunAsrNano: return "funasr_nano";
+        case SttModelKind::kQwen3Asr: return "qwen3_asr";
         case SttModelKind::kFireRedAsr: return "fire_red_asr";
         case SttModelKind::kMoonshine: return "moonshine";
         case SttModelKind::kMoonshineV2: return "moonshine_v2";
@@ -85,6 +86,7 @@ SttModelKind ParseSttModelType(const std::string& modelType) {
     if (modelType == "zipformer_ctc" || modelType == "ctc") return SttModelKind::kZipformerCtc;
     if (modelType == "whisper") return SttModelKind::kWhisper;
     if (modelType == "funasr_nano") return SttModelKind::kFunAsrNano;
+    if (modelType == "qwen3_asr") return SttModelKind::kQwen3Asr;
     if (modelType == "fire_red_asr") return SttModelKind::kFireRedAsr;
     if (modelType == "moonshine") return SttModelKind::kMoonshine;
     if (modelType == "moonshine_v2") return SttModelKind::kMoonshineV2;
@@ -123,6 +125,8 @@ static bool CapabilitySupportsKind(
             return cap.hasWhisper;
         case SttModelKind::kFunAsrNano:
             return cap.hasFunAsrNano;
+        case SttModelKind::kQwen3Asr:
+            return cap.hasQwen3Asr;
         case SttModelKind::kFireRedAsr:
             return cap.hasFireRedAsr;
         case SttModelKind::kMoonshine:
@@ -185,6 +189,8 @@ static std::vector<SttModelKind> GetKindsFromDirName(const std::string& modelDir
         add(SttModelKind::kTransducer);
         add(SttModelKind::kZipformerCtc);
     }
+    if (lower.find("qwen3-asr") != std::string::npos || lower.find("qwen3_asr") != std::string::npos)
+        add(SttModelKind::kQwen3Asr);
     if (lower.find("funasr") != std::string::npos)
         add(SttModelKind::kFunAsrNano);
     if (lower.find("canary") != std::string::npos)
@@ -245,6 +251,19 @@ static SttCandidatePaths GatherSttCandidatePaths(
                 p.funasrTokenizerDir = vocabInSubdir.substr(0, lastSlash);
         }
     }
+    p.qwen3ConvFrontend = FindOnnxByAnyToken(files, {"conv_frontend"}, preferInt8);
+    {
+        for (const auto& entry : files) {
+            if (entry.nameLower != "tokenizer_config.json") continue;
+            size_t slash = entry.path.find_last_of("/\\");
+            if (slash == std::string::npos) continue;
+            std::string dir = entry.path.substr(0, slash);
+            if (Qwen3TokenizerDirHasVocabAndMerges(files, dir)) {
+                p.qwen3TokenizerDir = dir;
+                break;
+            }
+        }
+    }
     p.moonshinePreprocessor = FindOnnxByAnyToken(files, {"preprocess", "preprocessor"}, preferInt8);
     p.moonshineEncoder = FindOnnxByAnyToken(files, {"encode", "encoder_model"}, preferInt8);
     p.moonshineUncachedDecoder = FindOnnxByAnyToken(files, {"uncached_decode", "uncached"}, preferInt8);
@@ -254,7 +273,8 @@ static SttCandidatePaths GatherSttCandidatePaths(
     static const std::vector<std::string> modelExcludes = {
         "encoder", "decoder", "joiner", "vocoder", "acoustic", "embedding", "llm",
         "encoder_adaptor", "encoder-adaptor", "encoder_model", "decoder_model",
-        "merged_decoder", "decoder_model_merged", "preprocess", "encode", "uncached", "cached"
+        "merged_decoder", "decoder_model_merged", "preprocess", "encode", "uncached", "cached",
+        "conv_frontend"
     };
     p.paraformerModel = FindOnnxByAnyToken(files, {"model"}, preferInt8);
     if (!p.paraformerModel.empty()) {
@@ -297,6 +317,7 @@ static SttPathHints GetSttPathHints(const std::string& modelDir) {
     h.isLikelyWenetCtc = lower.find("wenet") != std::string::npos;
     h.isLikelySenseVoice = lower.find("sense") != std::string::npos || lower.find("sensevoice") != std::string::npos;
     h.isLikelyFunAsrNano = lower.find("funasr") != std::string::npos || lower.find("funasr-nano") != std::string::npos;
+    h.isLikelyQwen3Asr = lower.find("qwen3-asr") != std::string::npos || lower.find("qwen3_asr") != std::string::npos;
     h.isLikelyZipformer = lower.find("zipformer") != std::string::npos;
     h.isLikelyMoonshine = lower.find("moonshine") != std::string::npos;
     h.isLikelyDolphin = lower.find("dolphin") != std::string::npos;
@@ -338,7 +359,9 @@ static SttCapabilities ComputeSttCapabilities(const SttCandidatePaths& paths, co
     c.hasTransducer = !paths.encoder.empty() && !paths.decoder.empty() && !paths.joiner.empty();
     bool hasWhisperEnc = !paths.encoder.empty();
     bool hasWhisperDec = !paths.decoder.empty();
-    c.hasWhisper = hasWhisperEnc && hasWhisperDec && paths.joiner.empty();
+    bool hasQwen3Tok = !paths.qwen3TokenizerDir.empty();
+    c.hasQwen3Asr = !paths.qwen3ConvFrontend.empty() && hasWhisperEnc && hasWhisperDec && hasQwen3Tok;
+    c.hasWhisper = hasWhisperEnc && hasWhisperDec && paths.joiner.empty() && !c.hasQwen3Asr;
     bool hasFunAsrTok = !paths.funasrTokenizerDir.empty();
     c.hasFunAsrNano = !paths.funasrEncoderAdaptor.empty() && !paths.funasrLLM.empty() &&
                       !paths.funasrEmbedding.empty() && hasFunAsrTok;
@@ -378,6 +401,7 @@ static void CollectDetectedModels(
         out.push_back({"paraformer", modelDir});
     }
     if (cap.hasWhisper) out.push_back({"whisper", modelDir});
+    if (cap.hasQwen3Asr) out.push_back({"qwen3_asr", modelDir});
     if (cap.hasFunAsrNano) out.push_back({"funasr_nano", modelDir});
     if (cap.hasMoonshine) out.push_back({"moonshine", modelDir});
     if (cap.hasMoonshineV2) out.push_back({"moonshine_v2", modelDir});
@@ -439,6 +463,10 @@ static SttModelKind ResolveSttKind(
             outError = "FunASR Nano model requested but required files not found in " + modelDir;
             return SttModelKind::kUnknown;
         }
+        if (selected == SttModelKind::kQwen3Asr && !cap.hasQwen3Asr) {
+            outError = "Qwen3-ASR model requested but conv_frontend/encoder/decoder/tokenizer not found in " + modelDir;
+            return SttModelKind::kUnknown;
+        }
         if (selected == SttModelKind::kMoonshine && !cap.hasMoonshine) {
             outError = "Moonshine v1 model requested but preprocess/encode/uncached_decode/cached_decode not found in " + modelDir;
             return SttModelKind::kUnknown;
@@ -505,7 +533,9 @@ static SttModelKind ResolveSttKind(
     if (!paths.paraformerModel.empty()) return SttModelKind::kParaformer;
     if (cap.hasCanary) return SttModelKind::kCanary;
     if (cap.hasFireRedAsr) return SttModelKind::kFireRedAsr;
+    if (cap.hasQwen3Asr && hints.isLikelyQwen3Asr) return SttModelKind::kQwen3Asr;
     if (cap.hasWhisper) return SttModelKind::kWhisper;
+    if (cap.hasQwen3Asr) return SttModelKind::kQwen3Asr;
     if (cap.hasFunAsrNano) return SttModelKind::kFunAsrNano;
     if (cap.hasMoonshineV2) return SttModelKind::kMoonshineV2;
     if (cap.hasDolphin) return SttModelKind::kDolphin;
@@ -551,6 +581,12 @@ static void ApplyPathsForSttKind(SttModelKind kind, const SttCandidatePaths& can
             resultPaths.funasrEmbedding = candidate.funasrEmbedding;
             resultPaths.funasrTokenizer = candidate.funasrTokenizerDir;
             break;
+        case SttModelKind::kQwen3Asr:
+            resultPaths.qwen3ConvFrontend = candidate.qwen3ConvFrontend;
+            resultPaths.qwen3Encoder = candidate.encoder;
+            resultPaths.qwen3Decoder = candidate.decoder;
+            resultPaths.qwen3Tokenizer = candidate.qwen3TokenizerDir;
+            break;
         case SttModelKind::kMoonshine:
             resultPaths.moonshinePreprocessor = candidate.moonshinePreprocessor;
             resultPaths.moonshineEncoder = candidate.moonshineEncoder;
@@ -624,13 +660,15 @@ SttDetectResult DetectSttModel(
             EmptyOrPath(candidate.encoder), EmptyOrPath(candidate.decoder));
         LOGI("DetectSttModel: funasr encoderAdaptor=%s llm=%s embedding=%s tokenizerDir=%s",
             EmptyOrPath(candidate.funasrEncoderAdaptor), EmptyOrPath(candidate.funasrLLM), EmptyOrPath(candidate.funasrEmbedding), EmptyOrPath(candidate.funasrTokenizerDir));
-        LOGI("DetectSttModel: hasTransducer=%d hasWhisper=%d hasMoonshine=%d hasMoonshineV2=%d hasParaformer=%d hasFunAsrNano=%d hasDolphin=%d hasFireRedAsr=%d hasFireRedCtc=%d hasCanary=%d hasOmnilingual=%d hasMedAsr=%d hasTeleSpeechCtc=%d hasToneCtc=%d",
+        LOGI("DetectSttModel: qwen3_asr conv=%s tokenizerDir=%s",
+            EmptyOrPath(candidate.qwen3ConvFrontend), EmptyOrPath(candidate.qwen3TokenizerDir));
+        LOGI("DetectSttModel: hasTransducer=%d hasWhisper=%d hasMoonshine=%d hasMoonshineV2=%d hasParaformer=%d hasFunAsrNano=%d hasQwen3Asr=%d hasDolphin=%d hasFireRedAsr=%d hasFireRedCtc=%d hasCanary=%d hasOmnilingual=%d hasMedAsr=%d hasTeleSpeechCtc=%d hasToneCtc=%d",
             (int)cap.hasTransducer, (int)cap.hasWhisper, (int)cap.hasMoonshine, (int)cap.hasMoonshineV2,
-            (int)cap.hasParaformer, (int)cap.hasFunAsrNano, (int)cap.hasDolphin, (int)cap.hasFireRedAsr, (int)cap.hasFireRedCtc,
+            (int)cap.hasParaformer, (int)cap.hasFunAsrNano, (int)cap.hasQwen3Asr, (int)cap.hasDolphin, (int)cap.hasFireRedAsr, (int)cap.hasFireRedCtc,
             (int)cap.hasCanary, (int)cap.hasOmnilingual, (int)cap.hasMedAsr, (int)cap.hasTeleSpeechCtc, (int)cap.hasToneCtc);
-        LOGI("DetectSttModel: hints isLikelyNemo=%d isLikelyTdt=%d isLikelyWenetCtc=%d isLikelySenseVoice=%d isLikelyFunAsrNano=%d isLikelyZipformer=%d isLikelyMoonshine=%d isLikelyDolphin=%d isLikelyFireRedAsr=%d isLikelyCanary=%d isLikelyOmnilingual=%d isLikelyMedAsr=%d isLikelyTeleSpeech=%d isLikelyToneCtc=%d isLikelyParaformer=%d isLikelyVad=%d isLikelyTdnn=%d",
+        LOGI("DetectSttModel: hints isLikelyNemo=%d isLikelyTdt=%d isLikelyWenetCtc=%d isLikelySenseVoice=%d isLikelyFunAsrNano=%d isLikelyQwen3Asr=%d isLikelyZipformer=%d isLikelyMoonshine=%d isLikelyDolphin=%d isLikelyFireRedAsr=%d isLikelyCanary=%d isLikelyOmnilingual=%d isLikelyMedAsr=%d isLikelyTeleSpeech=%d isLikelyToneCtc=%d isLikelyParaformer=%d isLikelyVad=%d isLikelyTdnn=%d",
              (int)hints.isLikelyNemo, (int)hints.isLikelyTdt, (int)hints.isLikelyWenetCtc, (int)hints.isLikelySenseVoice,
-             (int)hints.isLikelyFunAsrNano, (int)hints.isLikelyZipformer, (int)hints.isLikelyMoonshine, (int)hints.isLikelyDolphin,
+             (int)hints.isLikelyFunAsrNano, (int)hints.isLikelyQwen3Asr, (int)hints.isLikelyZipformer, (int)hints.isLikelyMoonshine, (int)hints.isLikelyDolphin,
              (int)hints.isLikelyFireRedAsr, (int)hints.isLikelyCanary, (int)hints.isLikelyOmnilingual, (int)hints.isLikelyMedAsr,
              (int)hints.isLikelyTeleSpeech, (int)hints.isLikelyToneCtc, (int)hints.isLikelyParaformer, (int)hints.isLikelyVad, (int)hints.isLikelyTdnn);
     }
@@ -653,7 +691,8 @@ SttDetectResult DetectSttModel(
     }
 
     LOGI("DetectSttModel: selected kind=%d (%s)", static_cast<int>(result.selectedKind), KindToName(result.selectedKind));
-    result.tokensRequired = (result.selectedKind != SttModelKind::kFunAsrNano);
+    result.tokensRequired = (result.selectedKind != SttModelKind::kFunAsrNano &&
+                             result.selectedKind != SttModelKind::kQwen3Asr);
     ApplyPathsForSttKind(result.selectedKind, candidate, result.paths);
 
     if (!candidate.tokens.empty() && FileExists(candidate.tokens)) {
@@ -711,6 +750,11 @@ SttDetectResult DetectSttModel(
                  EmptyOrPath(result.paths.funasrEncoderAdaptor), EmptyOrPath(result.paths.funasrLLM),
                  EmptyOrPath(result.paths.funasrEmbedding), EmptyOrPath(result.paths.funasrTokenizer));
             break;
+        case SttModelKind::kQwen3Asr:
+            LOGI("DetectSttModel: paths set qwen3_asr conv=%s encoder=%s decoder=%s tokenizer=%s",
+                 EmptyOrPath(result.paths.qwen3ConvFrontend), EmptyOrPath(result.paths.qwen3Encoder),
+                 EmptyOrPath(result.paths.qwen3Decoder), EmptyOrPath(result.paths.qwen3Tokenizer));
+            break;
         default:
             break;
     }