react-native-sherpa-onnx 0.3.8 → 0.3.9

package/README.md

@@ -126,8 +126,8 @@ Full step-by-step: [Download manager – Setup (iOS & Android)](docs/download-ma
 | Model quantization | ✅ **Supported** | [Model setup](./docs/model-setup.md) | Automatic detection and preference for quantized (int8) models. |
 | Flexible model loading | ✅ **Supported** | [Model setup](./docs/model-setup.md) | Asset models, file system models, or auto-detection. |
 | TypeScript | ✅ **Supported** | — | Full type definitions included. |
-| Speaker Diarization | ❌ Not yet supported | [Diarization](./docs/diarization.md) | Scheduled for release 0.4.0 |
-| Speech Enhancement | ❌ Not yet supported | [Enhancement](./docs/enhancement.md) | Scheduled for release 0.5.0 |
+| Speech Enhancement | ❌ Not yet supported | [Enhancement](./docs/enhancement.md) | Scheduled for release 0.4.0 |
+| Speaker Diarization | ❌ Not yet supported | [Diarization](./docs/diarization.md) | Scheduled for release 0.5.0 |
 | Source Separation | ❌ Not yet supported | [Separation](./docs/separation.md) | Scheduled for release 0.6.0 |
 | VAD (Voice Activity Detection) | ❌ Not yet supported | [VAD](./docs/vad.md) | Scheduled for release 0.7.0 |
 
@@ -148,6 +148,7 @@ Full step-by-step: [Download manager – Setup (iOS & Android)](docs/download-ma
 
 | Model Type               | `modelType` Value | Description                                                                              | Download Links                                                                                   |
 | ------------------------ | ----------------- | ---------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------ |
+| **Auto Detect**          | `'auto'`          | Automatically detects model layout/type from files in the model folder and picks the best supported STT type. | n/a |
 | **Zipformer/Transducer** | `'transducer'`    | Encoder–decoder–joiner (e.g. icefall). Good balance of speed and accuracy. Folder name should contain **zipformer** or **transducer** for auto-detection. | [Download](https://k2-fsa.github.io/sherpa/onnx/pretrained_models/offline-transducer/index.html) |
 | **LSTM Transducer**      | `'transducer'`    | Same layout as Zipformer (encoder–decoder–joiner). LSTM-based streaming ASR; detected as transducer. Folder name may contain **lstm**. | [Download](https://k2-fsa.github.io/sherpa/onnx/pretrained_models/online-transducer/lstm-transducer-models.html) |
 | **Paraformer**           | `'paraformer'`    | Single-model non-autoregressive ASR; fast and accurate. Detected by `model.onnx`; no folder token required. | [Download](https://k2-fsa.github.io/sherpa/onnx/pretrained_models/offline-paraformer/index.html) |
@@ -172,6 +173,7 @@ For **real-time (streaming) recognition** from a microphone or audio stream, use
 
 | Model Type       | `modelType` Value | Description                                                                                          | Download Links                                                                      |
 | ---------------- | ----------------- | ---------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------- |
+| **Auto Detect**   | `'auto'`              | Automatically detects the TTS model layout from files in the model folder and selects the matching supported type. | n/a |
 | **VITS**         | `'vits'`          | Fast, high-quality TTS (Piper, Coqui, MeloTTS, MMS). Folder name should contain **vits** if used with other voice models. | [Download](https://github.com/k2-fsa/sherpa-onnx/releases/tag/tts-models)          |
 | **Matcha**       | `'matcha'`        | High-quality acoustic model + vocoder. Detected by acoustic_model + vocoder; no folder token required. | [Download](https://k2-fsa.github.io/sherpa/onnx/tts/pretrained_models/matcha.html) |
 | **Kokoro**       | `'kokoro'`        | Multi-speaker, multi-language. Folder name should contain **kokoro** (not kitten) for auto-detection. | [Download](https://github.com/k2-fsa/sherpa-onnx/releases/tag/tts-models)          |

package/SherpaOnnx.podspec

@@ -140,7 +140,10 @@ Pod::Spec.new do |s|
   s.libraries = "c++", "z", "iconv", "bz2"
 
   # Per-release-model license metadata (synced from CI; same CSV as android/src/main/assets/model_licenses/).
-  s.resources = ["ios/Resources/model_licenses/*.csv"]
+  # Use resource_bundles so assets are packaged reliably across CocoaPods integration modes.
+  s.resource_bundles = {
+    "SherpaOnnxResources" => ["ios/Resources/model_licenses/*.csv"]
+  }
 
   install_modules_dependencies(s)
 end

package/android/prebuilt-download.gradle

@@ -222,14 +222,14 @@ project.tasks.register("downloadNativeLibsIfNeeded") {
             sherpaVersionFile.text = currentSherpaVersion
             sherpaResolved = true
             println "[sherpa-onnx] jniLibs (*.so per ABI) .............. MAVEN_AAR  ${aar.name}"
-            println "[sherpa-onnx]   install: jni/<abi>/*.so → ${jniLibsHuman}/<abi>/"
-            println "[sherpa-onnx] C headers (sherpa-onnx) ............. ${copiedHeaders ? 'MAVEN_AAR  c-api/** → ' + includeSherpaDir : 'unchanged (no c-api/ in AAR; existing tree kept)'}"
+            println "[sherpa-onnx]   install: jni/<abi>/*.so --> ${jniLibsHuman}/<abi>/"
+            println "[sherpa-onnx] C headers (sherpa-onnx) ............. ${copiedHeaders ? 'MAVEN_AAR  c-api/** --> ' + includeSherpaDir : 'unchanged (no c-api/ in AAR; existing tree kept)'}"
             println "[sherpa-onnx] version stamp ...................... written  ${sherpaVersionFile.name}=${currentSherpaVersion}"
           } else {
-            println "[sherpa-onnx] MAVEN_AAR: sherpaOnnxAar empty → trying GITHUB_RELEASE"
+            println "[sherpa-onnx] MAVEN_AAR: sherpaOnnxAar empty --> trying GITHUB_RELEASE"
           }
         } catch (Exception e) {
-          println "[sherpa-onnx] MAVEN_AAR failed: ${e.message} → trying GITHUB_RELEASE"
+          println "[sherpa-onnx] MAVEN_AAR failed: ${e.message} --> trying GITHUB_RELEASE"
         }
       }
     } else {
@@ -290,14 +290,14 @@ project.tasks.register("downloadNativeLibsIfNeeded") {
             ffmpegVersionFile.text = currentFfmpegVersion
             ffmpegResolved = true
             println "[FFmpeg] jniLibs .................................. MAVEN_AAR  ${aar.name}"
-            println "[FFmpeg]   install: jni/<abi>/*.so → ${jniLibsHuman}/<abi>/"
-            println "[FFmpeg] C headers ................................ ${copiedHdr ? 'MAVEN_AAR  include/** → ' + ffmpegIncludeDir : 'unchanged (no include/ in AAR)'}"
+            println "[FFmpeg]   install: jni/<abi>/*.so --> ${jniLibsHuman}/<abi>/"
+            println "[FFmpeg] C headers ................................ ${copiedHdr ? 'MAVEN_AAR  include/** --> ' + ffmpegIncludeDir : 'unchanged (no include/ in AAR)'}"
             println "[FFmpeg] version stamp ............................ written  ${ffmpegVersionFile.name}=${currentFfmpegVersion}"
           } else {
-            println "[FFmpeg] MAVEN_AAR: ffmpegAar empty → trying GITHUB_RELEASE"
+            println "[FFmpeg] MAVEN_AAR: ffmpegAar empty --> trying GITHUB_RELEASE"
           }
         } catch (Exception e) {
-          println "[FFmpeg] MAVEN_AAR failed: ${e.message} → trying GITHUB_RELEASE"
+          println "[FFmpeg] MAVEN_AAR failed: ${e.message} --> trying GITHUB_RELEASE"
         }
       }
     } else {
@@ -358,14 +358,14 @@ project.tasks.register("downloadNativeLibsIfNeeded") {
             libarchiveVersionFile.text = currentLibarchiveVersion
             libarchiveResolved = true
             println "[libarchive] jniLibs .............................. MAVEN_AAR  ${aar.name}"
-            println "[libarchive]   install: jni/<abi>/*.so → ${jniLibsHuman}/<abi>/"
-            println "[libarchive] C headers ............................ ${copiedHdr ? 'MAVEN_AAR  include/** → ' + libarchiveIncludeDir : 'unchanged (no include/ in AAR)'}"
+            println "[libarchive]   install: jni/<abi>/*.so --> ${jniLibsHuman}/<abi>/"
+            println "[libarchive] C headers ............................ ${copiedHdr ? 'MAVEN_AAR  include/** --> ' + libarchiveIncludeDir : 'unchanged (no include/ in AAR)'}"
             println "[libarchive] version stamp ........................ written  ${libarchiveVersionFile.name}=${currentLibarchiveVersion}"
           } else {
-            println "[libarchive] MAVEN_AAR: libarchiveAar empty → trying GITHUB_RELEASE"
+            println "[libarchive] MAVEN_AAR: libarchiveAar empty --> trying GITHUB_RELEASE"
           }
         } catch (Exception e) {
-          println "[libarchive] MAVEN_AAR failed: ${e.message} → trying GITHUB_RELEASE"
+          println "[libarchive] MAVEN_AAR failed: ${e.message} --> trying GITHUB_RELEASE"
         }
       }
     } else {
@@ -415,7 +415,7 @@ project.tasks.register("downloadNativeLibsIfNeeded") {
             }
             ortJniResolved = true
             println "[onnxruntime] libonnxruntime4j_jni.so .......... MAVEN_AAR  ${aar.name}"
-            println "[onnxruntime]   install: per ABI → ${jniLibsHuman}/<abi>/ (only JNI bridge; libonnxruntime.so from sherpa prebuilts)"
+            println "[onnxruntime]   install: per ABI --> ${jniLibsHuman}/<abi>/ (only JNI bridge; libonnxruntime.so from sherpa prebuilts)"
           } else {
             println "[onnxruntime] MAVEN_AAR: onnxruntimeAar empty — libonnxruntime4j_jni.so still missing"
           }
@@ -436,7 +436,7 @@ project.tasks.register("downloadNativeLibsIfNeeded") {
       def needLibarchive = !sherpaOnnxDisableLibarchive && !libarchiveResolved
       def needSherpa = !sherpaResolved
       if (needFfmpeg || needLibarchive || needSherpa) {
-        println "[prebuilt] GITHUB_RELEASE: skipped (no repo). Set -PprebuiltGitHubRepo=owner/repo or git remote origin → github.com"
+        println "[prebuilt] GITHUB_RELEASE: skipped (no repo). Set -PprebuiltGitHubRepo=owner/repo or git remote origin --> github.com"
         println "[prebuilt]   still need: sherpa=${needSherpa}, ffmpeg=${needFfmpeg}, libarchive=${needLibarchive}"
         def diag = [
           "prebuiltGitHubRepo=${project.findProperty('prebuiltGitHubRepo') ?: '(not set)'}",
@@ -492,7 +492,7 @@ project.tasks.register("downloadNativeLibsIfNeeded") {
       ffmpegVersionFile.text = currentFfmpegVersion
       println "[FFmpeg] jniLibs + C headers ...................... GITHUB_RELEASE  tag=${tag}"
       println "[FFmpeg]   url: ${url}"
-      println "[FFmpeg]   install: <abi>/*.so → ${jniLibsHuman}/"
+      println "[FFmpeg]   install: <abi>/*.so --> ${jniLibsHuman}/"
       println "[FFmpeg] version stamp .......................... written  ${ffmpegVersionFile.name}=${currentFfmpegVersion}"
     }
 
@@ -522,7 +522,7 @@ project.tasks.register("downloadNativeLibsIfNeeded") {
       libarchiveVersionFile.text = currentLibarchiveVersion
       println "[libarchive] jniLibs + C headers .................. GITHUB_RELEASE  tag=${tag}"
       println "[libarchive]   url: ${url}"
-      println "[libarchive]   install: <abi>/*.so → ${jniLibsHuman}/"
+      println "[libarchive]   install: <abi>/*.so --> ${jniLibsHuman}/"
       println "[libarchive] version stamp ........................ written  ${libarchiveVersionFile.name}=${currentLibarchiveVersion}"
     }
 
@@ -560,8 +560,8 @@ project.tasks.register("downloadNativeLibsIfNeeded") {
       sherpaVersionFile.text = currentSherpaVersion
       println "[sherpa-onnx] jniLibs + C headers ................. GITHUB_RELEASE  tag=${tag}"
       println "[sherpa-onnx]   url: ${url}"
-      println "[sherpa-onnx]   install: <abi>/*.so → ${jniLibsHuman}/"
-      println "[sherpa-onnx] classes.jar ......................... ${sherpaJavaJar.exists() ? 'GITHUB_RELEASE  → ' + sherpaOnnxClassesDir : 'not in zip (use extractSherpaOnnxClasses)'}"
+      println "[sherpa-onnx]   install: <abi>/*.so --> ${jniLibsHuman}/"
+      println "[sherpa-onnx] classes.jar ......................... ${sherpaJavaJar.exists() ? 'GITHUB_RELEASE  --> ' + sherpaOnnxClassesDir : 'not in zip (use extractSherpaOnnxClasses)'}"
       println "[sherpa-onnx] version stamp ...................... written  ${sherpaVersionFile.name}=${currentSherpaVersion}"
     }
     println ""
@@ -612,7 +612,7 @@ project.afterEvaluate {
   project.tasks.findByName('preBuild')?.dependsOn(project.tasks.findByName('checkJniLibs'))
 }
 
-// sherpa-onnx classes.jar: resolution order THIRD_PARTY → MAVEN_AAR → GITHUB_EXTRACT
+// sherpa-onnx classes.jar: resolution order THIRD_PARTY --> MAVEN_AAR --> GITHUB_EXTRACT
 def sherpaLocalJar = file("${project.projectDir.parent}/third_party/sherpa-onnx-prebuilt/android/java/classes.jar")
 def sherpaExtractedJar = file("${project.buildDir}/prebuilt-downloads/sherpa-onnx-extract/java/classes.jar")
 
@@ -627,7 +627,7 @@ project.tasks.register("extractSherpaOnnxClasses") {
       copy { from sherpaLocalJar; into sherpaOnnxClassesDir }
       println "[prebuilt] extractSherpaOnnxClasses"
       println "[sherpa-onnx] classes.jar (Kotlin API) .......... THIRD_PARTY"
-      println "[sherpa-onnx]   ${sherpaLocalJar.absolutePath} → ${sherpaOnnxClassesDir}"
+      println "[sherpa-onnx]   ${sherpaLocalJar.absolutePath} --> ${sherpaOnnxClassesDir}"
       return
     }
     def aarFiles = project.configurations.sherpaOnnxAar.files
@@ -640,14 +640,14 @@ project.tasks.register("extractSherpaOnnxClasses") {
       }
       println "[prebuilt] extractSherpaOnnxClasses"
       println "[sherpa-onnx] classes.jar (Kotlin API) .......... MAVEN_AAR  ${aar.name}"
-      println "[sherpa-onnx]   classes.jar → ${sherpaOnnxClassesDir}"
+      println "[sherpa-onnx]   classes.jar --> ${sherpaOnnxClassesDir}"
       return
     }
     if (sherpaExtractedJar.exists()) {
       copy { from sherpaExtractedJar; into sherpaOnnxClassesDir }
       println "[prebuilt] extractSherpaOnnxClasses"
       println "[sherpa-onnx] classes.jar (Kotlin API) .......... GITHUB_EXTRACT"
-      println "[sherpa-onnx]   ${sherpaExtractedJar.absolutePath} → ${sherpaOnnxClassesDir}"
+      println "[sherpa-onnx]   ${sherpaExtractedJar.absolutePath} --> ${sherpaOnnxClassesDir}"
       return
     }
     throw new RuntimeException(
@@ -678,7 +678,7 @@ project.tasks.register("extractOnnxruntimeClasses") {
       }
       println "[prebuilt] extractOnnxruntimeClasses"
       println "[onnxruntime] classes.jar (Java API) ........... MAVEN_AAR  ${aar.name}"
-      println "[onnxruntime]   renamed to onnxruntime-classes.jar → ${onnxruntimeClassesDir}"
+      println "[onnxruntime]   renamed to onnxruntime-classes.jar --> ${onnxruntimeClassesDir}"
       return
     }
     throw new RuntimeException(

package/android/src/main/assets/model_licenses/asr-models-license-status.csv

@@ -397,6 +397,7 @@ sherpa-onnx-rk3576-streaming-zipformer-en-2023-06-26.tar.bz2,apache-2.0,yes,high
 sherpa-onnx-rk3568-streaming-zipformer-en-2023-06-26.tar.bz2,apache-2.0,yes,high,manual,https://huggingface.co/csukuangfj/sherpa-onnx-streaming-zipformer-en-2023-06-26
 sherpa-onnx-rk3566-streaming-zipformer-en-2023-06-26.tar.bz2,apache-2.0,yes,high,manual,https://huggingface.co/csukuangfj/sherpa-onnx-streaming-zipformer-en-2023-06-26
 sherpa-onnx-rk3562-streaming-zipformer-en-2023-06-26.tar.bz2,apache-2.0,yes,high,manual,https://huggingface.co/csukuangfj/sherpa-onnx-streaming-zipformer-en-2023-06-26
+sherpa-onnx-qwen3-asr-0.6B-int8-2026-03-25.tar.bz2,apache-2.0,yes,high,manual,https://huggingface.co/Qwen/Qwen3-ASR-0.6B
 sherpa-onnx-rk3588-streaming-zipformer-small-bilingual-zh-en-2023-02-16.tar.bz2,apache-2.0,yes,high,manual,https://huggingface.co/csukuangfj/k2fsa-zipformer-bilingual-zh-en-t
 sherpa-onnx-rk3588-streaming-zipformer-bilingual-zh-en-2023-02-20.tar.bz2,apache-2.0,yes,high,manual,https://huggingface.co/csukuangfj/k2fsa-zipformer-bilingual-zh-en-t
 sherpa-onnx-rk3576-streaming-zipformer-small-bilingual-zh-en-2023-02-16.tar.bz2,apache-2.0,yes,high,manual,https://huggingface.co/csukuangfj/k2fsa-zipformer-bilingual-zh-en-t

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

@@ -389,5 +389,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/android/src/main/cpp/jni/model_detect/sherpa-onnx-model-detect-helper.h

@@ -88,6 +88,15 @@ std::vector<LexiconCandidate> FindLexiconCandidates(
     const std::string& rootDir
 );
 
+/**
+ * True if `dir` contains vocab.json and merges.txt: listed in `files` (fixture / synthetic trees)
+ * or present on disk. Used for Qwen3-ASR tokenizer directory detection.
+ */
+bool Qwen3TokenizerDirHasVocabAndMerges(
+    const std::vector<FileEntry>& files,
+    const std::string& dir
+);
+
 } // namespace model_detect
 } // namespace sherpaonnx
 

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

@@ -61,6 +61,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";
@@ -88,6 +89,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;
@@ -126,6 +128,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:
@@ -189,6 +193,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)
@@ -249,6 +255,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);
@@ -258,7 +277,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()) {
@@ -302,6 +322,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;
@@ -404,7 +425,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;
@@ -446,6 +469,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});
@@ -507,6 +531,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;
@@ -573,7 +601,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;
@@ -618,6 +648,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;
@@ -711,13 +747,13 @@ 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: 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);
     }
@@ -747,7 +783,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)) {
@@ -808,6 +845,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;
     }
@@ -854,7 +896,8 @@ SttDetectResult DetectSttModelFromFileList(
         return result;
     }
 
-    result.tokensRequired = (result.selectedKind != SttModelKind::kFunAsrNano);
+    result.tokensRequired = (result.selectedKind != SttModelKind::kFunAsrNano &&
+                             result.selectedKind != SttModelKind::kQwen3Asr);
     ApplyPathsForSttKind(result.selectedKind, candidate, result.paths);
 
     result.paths.tokens = candidate.tokens;

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

@@ -20,6 +20,7 @@ enum class SttModelKind {
     kZipformerCtc,
     kWhisper,
     kFunAsrNano,
+    kQwen3Asr,
     kFireRedAsr,
     kMoonshine,
     kMoonshineV2,
@@ -57,6 +58,11 @@ struct SttModelPaths {
     std::string funasrLLM;
     std::string funasrEmbedding;
     std::string funasrTokenizer;
+    /** Qwen3-ASR: conv_frontend + encoder + decoder + tokenizer directory. */
+    std::string qwen3ConvFrontend;
+    std::string qwen3Encoder;
+    std::string qwen3Decoder;
+    std::string qwen3Tokenizer;
     // Moonshine
     std::string moonshinePreprocessor;
     std::string moonshineEncoder;
@@ -89,6 +95,8 @@ struct SttCandidatePaths {
     std::string funasrLLM;
     std::string funasrEmbedding;
     std::string funasrTokenizerDir;
+    std::string qwen3ConvFrontend;
+    std::string qwen3TokenizerDir;
     std::string moonshinePreprocessor;
     std::string moonshineEncoder;
     std::string moonshineUncachedDecoder;
@@ -104,6 +112,7 @@ struct SttPathHints {
     bool isLikelyWenetCtc = false;
     bool isLikelySenseVoice = false;
     bool isLikelyFunAsrNano = false;
+    bool isLikelyQwen3Asr = false;
     bool isLikelyZipformer = false;
     bool isLikelyMoonshine = false;
     bool isLikelyDolphin = false;
@@ -128,6 +137,7 @@ struct SttCapabilities {
     bool hasMoonshineV2 = false;
     bool hasParaformer = false;
     bool hasFunAsrNano = false;
+    bool hasQwen3Asr = 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. */

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

@@ -23,6 +23,7 @@ const char* SttModelKindToString(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";
@@ -79,6 +80,10 @@ jobject SttDetectResultToJava(JNIEnv* env, const SttDetectResult& result) {
       PutString(env, pathsMap, mapPut, "funasrLLM", result.paths.funasrLLM);
       PutString(env, pathsMap, mapPut, "funasrEmbedding", result.paths.funasrEmbedding);
       PutString(env, pathsMap, mapPut, "funasrTokenizer", result.paths.funasrTokenizer);
+      PutString(env, pathsMap, mapPut, "qwen3ConvFrontend", result.paths.qwen3ConvFrontend);
+      PutString(env, pathsMap, mapPut, "qwen3Encoder", result.paths.qwen3Encoder);
+      PutString(env, pathsMap, mapPut, "qwen3Decoder", result.paths.qwen3Decoder);
+      PutString(env, pathsMap, mapPut, "qwen3Tokenizer", result.paths.qwen3Tokenizer);
       PutString(env, pathsMap, mapPut, "moonshinePreprocessor", result.paths.moonshinePreprocessor);
       PutString(env, pathsMap, mapPut, "moonshineEncoder", result.paths.moonshineEncoder);
       PutString(env, pathsMap, mapPut, "moonshineUncachedDecoder", result.paths.moonshineUncachedDecoder);

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

@@ -52,6 +52,13 @@ static const SttFieldRequirement kFunAsrNanoReqs[] = {
     {"funasrTokenizer",      &SttModelPaths::funasrTokenizer,      true},
 };
 
+static const SttFieldRequirement kQwen3AsrReqs[] = {
+    {"qwen3ConvFrontend", &SttModelPaths::qwen3ConvFrontend, true},
+    {"qwen3Encoder",      &SttModelPaths::qwen3Encoder,      true},
+    {"qwen3Decoder",      &SttModelPaths::qwen3Decoder,      true},
+    {"qwen3Tokenizer",    &SttModelPaths::qwen3Tokenizer,    true},
+};
+
 static const SttFieldRequirement kMoonshineReqs[] = {
     {"moonshinePreprocessor",    &SttModelPaths::moonshinePreprocessor,    true},
     {"moonshineEncoder",         &SttModelPaths::moonshineEncoder,         true},
@@ -120,6 +127,9 @@ static const SttFieldRequirement* GetRequirements(SttModelKind kind, size_t& cou
         case SttModelKind::kFunAsrNano:
             count = std::size(kFunAsrNanoReqs);
             return kFunAsrNanoReqs;
+        case SttModelKind::kQwen3Asr:
+            count = std::size(kQwen3AsrReqs);
+            return kQwen3AsrReqs;
         case SttModelKind::kMoonshine:
             count = std::size(kMoonshineReqs);
             return kMoonshineReqs;
@@ -161,6 +171,7 @@ static const char* SttKindToName(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";