react-native-sherpa-onnx 0.3.2 → 0.3.3

package/README.md

@@ -14,6 +14,8 @@ React Native SDK for sherpa-onnx – offline and streaming speech processing
 [![Android](https://img.shields.io/badge/Android-Supported-green)](https://www.android.com/)
 [![iOS](https://img.shields.io/badge/iOS-Supported-blue)](https://www.apple.com/ios/)
 
+<a href="https://www.buymeacoffee.com/xdcobra" target="_blank"><img src="https://cdn.buymeacoffee.com/buttons/v2/default-yellow.png" alt="Buy Me A Coffee" width="150" /></a>
+
 </div>
 
 > **⚠️ SDK 0.3.0 – Breaking changes from 0.2.0**  
@@ -75,14 +77,23 @@ A React Native TurboModule that provides offline and streaming speech processing
 
 | Model Type               | `modelType` Value | Description                                                                              | Download Links                                                                                   |
 | ------------------------ | ----------------- | ---------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------ |
-| **Zipformer/Transducer** | `'transducer'`    | Requires `encoder.onnx`, `decoder.onnx`, `joiner.onnx`, and `tokens.txt`                 | [Download](https://k2-fsa.github.io/sherpa/onnx/pretrained_models/offline-transducer/index.html) |
-| **Paraformer**           | `'paraformer'`    | Requires `model.onnx` (or `model.int8.onnx`) and `tokens.txt`                            | [Download](https://k2-fsa.github.io/sherpa/onnx/pretrained_models/offline-paraformer/index.html) |
-| **NeMo CTC**             | `'nemo_ctc'`      | Requires `model.onnx` (or `model.int8.onnx`) and `tokens.txt`                            | [Download](https://k2-fsa.github.io/sherpa/onnx/pretrained_models/offline-ctc/nemo/index.html)   |
-| **Whisper**              | `'whisper'`       | Requires `encoder.onnx`, `decoder.onnx`, and `tokens.txt`                                | [Download](https://k2-fsa.github.io/sherpa/onnx/pretrained_models/whisper/index.html)            |
-| **WeNet CTC**            | `'wenet_ctc'`     | Requires `model.onnx` (or `model.int8.onnx`) and `tokens.txt`                            | [Download](https://k2-fsa.github.io/sherpa/onnx/pretrained_models/offline-ctc/wenet/index.html)  |
-| **SenseVoice**           | `'sense_voice'`   | Requires `model.onnx` (or `model.int8.onnx`) and `tokens.txt`                            | [Download](https://k2-fsa.github.io/sherpa/onnx/pretrained_models/sense-voice/index.html)        |
-| **FunASR Nano**          | `'funasr_nano'`   | Requires `encoder_adaptor.onnx`, `llm.onnx`, `embedding.onnx`, and `tokenizer` directory | [Download](https://k2-fsa.github.io/sherpa/onnx/pretrained_models/funasr-nano/index.html)        |
-| **Tone CTC (t-one)**     | `'tone_ctc'`      | Single `model.onnx` + `tokens.txt`. Folder name usually contains `t-one`, `t_one` or `tone` | [Download](https://k2-fsa.github.io/sherpa/onnx/pretrained_models/online-ctc/index.html) |
+| **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) |
+| **NeMo CTC**             | `'nemo_ctc'`      | NeMo CTC; good for English and streaming. Folder name should contain **nemo** or **parakeet**. | [Download](https://k2-fsa.github.io/sherpa/onnx/pretrained_models/offline-ctc/nemo/index.html)   |
+| **Whisper**              | `'whisper'`       | Multilingual, encoder–decoder; strong zero-shot. Detected by encoder+decoder (no joiner); folder token optional. | [Download](https://k2-fsa.github.io/sherpa/onnx/pretrained_models/whisper/index.html)            |
+| **WeNet CTC**            | `'wenet_ctc'`     | CTC from WeNet; compact. Folder name should contain **wenet**. | [Download](https://k2-fsa.github.io/sherpa/onnx/pretrained_models/offline-ctc/wenet/index.html)  |
+| **SenseVoice**           | `'sense_voice'`   | Multilingual with emotion/punctuation. Folder name should contain **sense** or **sensevoice**. | [Download](https://k2-fsa.github.io/sherpa/onnx/pretrained_models/sense-voice/index.html)        |
+| **FunASR Nano**          | `'funasr_nano'`   | Lightweight LLM-based ASR. Folder name should contain **funasr** or **funasr-nano**. | [Download](https://k2-fsa.github.io/sherpa/onnx/pretrained_models/funasr-nano/index.html)        |
+| **Moonshine (v1)**        | `'moonshine'`     | Four-part streaming-capable ASR (preprocess, encode, uncached/cached decode). Folder name should contain **moonshine**. | [Download](https://k2-fsa.github.io/sherpa/onnx/moonshine/index.html) |
+| **Moonshine (v2)**        | `'moonshine_v2'`   | Two-part Moonshine (encoder + merged decoder); `.onnx` or `.ort`. Folder name should contain **moonshine** (v2 preferred if both layouts present). | [Download](https://k2-fsa.github.io/sherpa/onnx/moonshine/index.html) |
+| **Fire Red ASR**         | `'fire_red_asr'`  | Fire Red encoder–decoder ASR. Folder name should contain **fire_red** or **fire-red**. | [Download](https://k2-fsa.github.io/sherpa/onnx/FireRedAsr/index.html) |
+| **Dolphin**              | `'dolphin'`       | Single-model CTC. Folder name should contain **dolphin**. | [Download](https://k2-fsa.github.io/sherpa/onnx/Dolphin/index.html) |
+| **Canary**               | `'canary'`        | NeMo Canary multilingual. Folder name should contain **canary**. | [Download](https://k2-fsa.github.io/sherpa/onnx/nemo/canary.html) |
+| **Omnilingual**          | `'omnilingual'`   | Omnilingual CTC. Folder name should contain **omnilingual**. | [Download](https://k2-fsa.github.io/sherpa/onnx/omnilingual-asr/index.html) |
+| **MedASR**               | `'medasr'`        | Medical ASR CTC. Folder name should contain **medasr**. | [Download](https://github.com/k2-fsa/sherpa-onnx) |
+| **Telespeech CTC**       | `'telespeech_ctc'`| Telespeech CTC. Folder name should contain **telespeech**. | [Download](https://k2-fsa.github.io/sherpa/onnx/pretrained_models/telespeech/index.html) |
+| **Tone CTC (t-one)**     | `'tone_ctc'`      | Lightweight streaming CTC (e.g. t-one). Folder name should contain **t-one**, **t_one**, or **tone** (as word). | [Download](https://k2-fsa.github.io/sherpa/onnx/pretrained_models/online-ctc/index.html) |
 
 For **real-time (streaming) recognition** from a microphone or audio stream, use streaming-capable model types: `transducer`, `paraformer`, `zipformer2_ctc`, `nemo_ctc`, or `tone_ctc`. See [Streaming (Online) Speech-to-Text](./docs/stt_streaming.md).
 
@@ -90,12 +101,12 @@ For **real-time (streaming) recognition** from a microphone or audio stream, use
 
 | Model Type       | `modelType` Value | Description                                                                                          | Download Links                                                                      |
 | ---------------- | ----------------- | ---------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------- |
-| **VITS**         | `'vits'`          | Fast, high-quality TTS. Includes Piper, Coqui, MeloTTS, MMS variants. Requires `model.onnx`, `tokens.txt` | [Download](https://github.com/k2-fsa/sherpa-onnx/releases/tag/tts-models)          |
-| **Matcha**       | `'matcha'`        | High-quality acoustic model + vocoder. Requires `acoustic_model.onnx`, `vocoder.onnx`, `tokens.txt` | [Download](https://k2-fsa.github.io/sherpa/onnx/tts/pretrained_models/matcha.html) |
-| **Kokoro**       | `'kokoro'`        | Multi-speaker, multi-language. Requires `model.onnx`, `voices.bin`, `tokens.txt`, `espeak-ng-data/` | [Download](https://github.com/k2-fsa/sherpa-onnx/releases/tag/tts-models)          |
-| **KittenTTS**    | `'kitten'`        | Lightweight, multi-speaker. Requires `model.onnx`, `voices.bin`, `tokens.txt`, `espeak-ng-data/`    | [Download](https://github.com/k2-fsa/sherpa-onnx/releases/tag/tts-models)          |
-| **Zipvoice**     | `'zipvoice'`      | Voice cloning capable. Requires `encoder.onnx`, `decoder.onnx`, `vocoder.onnx`, `tokens.txt`        | [Download](https://k2-fsa.github.io/sherpa/onnx/tts/pretrained_models/zipvoice.html) |
-| **Pocket**       | `'pocket'`        | Flow-matching TTS. Requires `lm_flow.onnx`, `lm_main.onnx`, `encoder.onnx`, `decoder.onnx`, `text_conditioner.onnx`, `vocab.json`, `token_scores.json` | [Download](https://github.com/k2-fsa/sherpa-onnx/releases/tag/tts-models) |
+| **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)          |
+| **KittenTTS**    | `'kitten'`        | Lightweight, multi-speaker. Folder name should contain **kitten** (not kokoro) for auto-detection. | [Download](https://github.com/k2-fsa/sherpa-onnx/releases/tag/tts-models)          |
+| **Zipvoice**     | `'zipvoice'`      | Voice cloning (encoder + decoder + vocoder). Detected by file layout; folder token optional. | [Download](https://k2-fsa.github.io/sherpa/onnx/tts/pretrained_models/zipvoice.html) |
+| **Pocket**       | `'pocket'`        | Flow-matching TTS. Detected by lm_flow, lm_main, text_conditioner, vocab/token_scores; no folder token required. | [Download](https://github.com/k2-fsa/sherpa-onnx/releases/tag/tts-models) |
 
 For **streaming TTS** (incremental generation, low latency), use `createStreamingTTS()` with supported model types. See [Streaming Text-to-Speech](./docs/tts_streaming.md).
 
@@ -151,6 +162,7 @@ The XCFramework must include the C++ API (`libsherpa-onnx-cxx-api.a` merged or l
 
 - [Speech-to-Text (STT)](./docs/stt.md) – Offline transcription (file or samples)
 - [Streaming (Online) Speech-to-Text](./docs/stt_streaming.md) – Real-time recognition, partial results, endpoint detection
+- [PCM Live Stream](./docs/pcm_live_stream.md) – Native microphone capture with resampling for live transcription (use with streaming STT)
 - [Text-to-Speech (TTS)](./docs/tts.md) – Offline and streaming generation
 - [Streaming Text-to-Speech](./docs/tts_streaming.md) – Incremental TTS (createStreamingTTS)
 - [Execution provider support (QNN, NNAPI, XNNPACK, Core ML)](./docs/execution-providers.md) – Checking and using acceleration backends
@@ -179,7 +191,7 @@ We provide example applications to help you get started with `react-native-sherp
 
 The example app included in this repository demonstrates audio-to-text transcription, text-to-speech, and streaming features. It includes:
 
-- Multiple model type support (Zipformer, Paraformer, NeMo CTC, Whisper, WeNet CTC, SenseVoice, FunASR Nano)
+- Multiple model type support (Zipformer, Paraformer, NeMo CTC, Whisper, WeNet CTC, SenseVoice, FunASR Nano, Moonshine, and more)
 - Model selection and configuration
 - **Offline** audio file transcription
 - **Online (streaming) STT** – live transcription from the microphone with partial results
@@ -202,6 +214,7 @@ yarn android  # or yarn ios
 <td><img src="./docs/images/example_stt_2.png" alt="Transcribe cantonese audio" width="240" /></td>
 </tr>
 <tr>
+<td><img src="./docs/images/example_streaming.png" alt="Text to speech generation" width="240" /></td>
 <td><img src="./docs/images/example_tts.png" alt="Text to speech generation" width="240" /></td>
 <td><img src="./docs/images/example_provider.png" alt="Text to speech generation" width="240" /></td>
 </tr>

package/SherpaOnnx.podspec

@@ -37,6 +37,18 @@ if libarchive_sources.empty?
   abort("[SherpaOnnx] Libarchive sources missing. Ensure third_party/libarchive_prebuilt/libarchive-ios-layout exists (run third_party/libarchive_prebuilt/build_libarchive_ios.sh) or ios/scripts/setup-ios-libarchive.sh has run, and that ios/scripts/patch-libarchive-includes.sh succeeds. Check pod install logs for patch script errors.")
 end
 
+# Run iOS framework setup when podspec is loaded (works for :path pods).
+setup_script = File.join(pod_root, "scripts", "setup-ios-framework.sh")
+if File.exist?(setup_script)
+  prev = ENV["SHERPA_ONNX_PROJECT_ROOT"]
+  ENV["SHERPA_ONNX_PROJECT_ROOT"] = pod_root
+  unless system("bash", setup_script)
+    ENV["SHERPA_ONNX_PROJECT_ROOT"] = prev
+    abort("[SherpaOnnx] setup-ios-framework.sh failed. Check third_party/sherpa-onnx-prebuilt/IOS_RELEASE_TAG and network. Run manually: bash #{setup_script}")
+  end
+  ENV["SHERPA_ONNX_PROJECT_ROOT"] = prev
+end
+
 Pod::Spec.new do |s|
   s.name         = "SherpaOnnx"
   s.version      = package["version"]
@@ -48,14 +60,10 @@ Pod::Spec.new do |s|
   s.platforms    = { :ios => min_ios_version_supported }
   s.source       = { :git => "https://github.com/XDcobra/react-native-sherpa-onnx.git", :tag => "#{s.version}" }
 
-  # Download sherpa-onnx XCFramework from GitHub Releases before pod install (uses IOS_RELEASE_TAG for pinned version).
-  setup_script = File.join(pod_root, "scripts", "setup-ios-framework.sh")
-  s.prepare_command = "bash \"#{setup_script}\""
-
   s.source_files = ["ios/**/*.{h,m,mm,swift,cpp}", *libarchive_sources]
   s.private_header_files = "ios/**/*.h"
 
-  s.frameworks = "Foundation", "Accelerate", "CoreML"
+  s.frameworks = "Foundation", "Accelerate", "CoreML", "AVFoundation", "AudioToolbox"
   s.vendored_frameworks = "ios/Frameworks/sherpa_onnx.xcframework"
   # Absolute paths so headers are found regardless of PODS_TARGET_SRCROOT (e.g. when building via React Native CLI).
   xcframework_root = File.join(pod_root, "ios", "Frameworks", "sherpa_onnx.xcframework")

package/android/prebuilt-download.gradle

@@ -99,12 +99,20 @@ def readReleaseTag = { File tagFile ->
 project.tasks.register("downloadNativeLibsIfNeeded") {
   doLast {
     def downloadDir = file("${project.buildDir}/prebuilt-downloads")
+    def currentSherpaVersion = project.ext.sherpaOnnxVersion
+    def sherpaVersionFile = new File(downloadDir, "sherpa-onnx-version.txt")
+    def storedSherpaVersion = (sherpaVersionFile.exists() ? sherpaVersionFile.text.trim() : null)
+    def sherpaNeedsUpdate = !hasAllSherpaLibs() || !hasSherpaHeaders() || storedSherpaVersion == null || storedSherpaVersion != currentSherpaVersion
 
-    if (hasAllSherpaLibs() && hasSherpaHeaders()) {
-      println "[sherpa-onnx] Native libs + headers: (1) local third_party (jniLibs + cpp/include already present)"
+    if (hasAllSherpaLibs() && hasSherpaHeaders() && !sherpaNeedsUpdate) {
+      println "[sherpa-onnx] Native libs + headers: (1) already present, version ${currentSherpaVersion}"
+    }
+    if (sherpaNeedsUpdate && storedSherpaVersion != null && storedSherpaVersion != currentSherpaVersion) {
+      println "[sherpa-onnx] Version change detected (${storedSherpaVersion} -> ${currentSherpaVersion}), refreshing libs and headers"
     }
 
-    if (!hasAllSherpaLibs() || !hasSherpaHeaders()) {
+    def sherpaUpdatedFromAar = [false]
+    if (sherpaNeedsUpdate) {
       try {
         def aarFiles = project.configurations.sherpaOnnxAar.files
         if (!aarFiles.isEmpty()) {
@@ -127,6 +135,9 @@ project.tasks.register("downloadNativeLibsIfNeeded") {
             copy { from fileTree(aarExtractDir) { include 'c-api/**' }; into includeSherpaDir }
             println "Extracted sherpa-onnx C-API headers from Maven AAR"
           }
+          downloadDir.mkdirs()
+          sherpaVersionFile.text = currentSherpaVersion
+          sherpaUpdatedFromAar[0] = true
           println "[sherpa-onnx] Native libs + headers: (2) Maven AAR (${aar.name})"
         }
       } catch (Exception e) {
@@ -228,7 +239,7 @@ project.tasks.register("downloadNativeLibsIfNeeded") {
     if (!repo) {
       def needFfmpeg = !sherpaOnnxDisableFfmpeg && (!hasAllFfmpegLibs() || !hasFfmpegHeaders())
       def needLibarchive = !sherpaOnnxDisableLibarchive && (!hasAllLibarchiveLibs() || !hasLibarchiveHeaders())
-      if (needFfmpeg || needLibarchive || !hasAllSherpaLibs() || !hasSherpaHeaders()) {
+      if (needFfmpeg || needLibarchive || (sherpaNeedsUpdate && !sherpaUpdatedFromAar[0])) {
         throw new RuntimeException(
           "Native libs/headers still missing and GitHub repo unknown. Set -PprebuiltGitHubRepo=owner/repo or ensure git remote origin is a GitHub URL. " +
           "Alternatively run third_party/ffmpeg_prebuilt/copy_prebuilts_to_sdk.js, third_party/sherpa-onnx-prebuilt/copy_prebuilts_to_sdk.js, third_party/libarchive_prebuilt/copy_prebuilts_to_sdk.js, or use Maven (com.xdcobra.sherpa:ffmpeg / sherpa-onnx / libarchive), or ensure ANDROID_RELEASE_TAG releases exist. " +
@@ -290,7 +301,7 @@ project.tasks.register("downloadNativeLibsIfNeeded") {
       println "Downloaded and extracted libarchive prebuilts (libs + include) from ${tag}"
     }
 
-    if (!hasAllSherpaLibs() || !hasSherpaHeaders()) {
+    if (sherpaNeedsUpdate && !sherpaUpdatedFromAar[0]) {
       def tagFile = file("${project.projectDir.parent}/third_party/sherpa-onnx-prebuilt/ANDROID_RELEASE_TAG")
       def tag = readReleaseTag(tagFile)
       if (!tag) throw new RuntimeException("Missing or empty third_party/sherpa-onnx-prebuilt/ANDROID_RELEASE_TAG")
@@ -319,6 +330,8 @@ project.tasks.register("downloadNativeLibsIfNeeded") {
         sherpaOnnxClassesDir.mkdirs()
         copy { from sherpaJavaJar; into sherpaOnnxClassesDir }
       }
+      downloadDir.mkdirs()
+      sherpaVersionFile.text = currentSherpaVersion
       println "[sherpa-onnx] Native libs + headers: (3) GitHub release (${tag})"
     } else {
       def sherpaClassesJar = file("${project.projectDir.parent}/third_party/sherpa-onnx-prebuilt/android/java/classes.jar")

package/android/prebuilt-versions.gradle

@@ -11,18 +11,22 @@ def readVersionFromTagFile(File tagFile, String prefix) {
   return null
 }
 
+// Module root: parent of android/ (so tag files resolve when SDK is used as dependency, e.g. node_modules/react-native-sherpa-onnx).
+def moduleRoot = project.projectDir.parentFile
+
 // sherpa-onnx: 1. SHERPA_ONNX_VERSION env 2. ANDROID_RELEASE_TAG 3. property 4. default
 def sherpaOnnxVersion = System.getenv('SHERPA_ONNX_VERSION')
 if (!sherpaOnnxVersion) {
-  def v = readVersionFromTagFile(new File(rootDir, 'third_party/sherpa-onnx-prebuilt/ANDROID_RELEASE_TAG'), 'sherpa-onnx-android-v')
-  sherpaOnnxVersion = v ?: (project.hasProperty('sherpaOnnxVersion') ? project.sherpaOnnxVersion : '1.12.24')
+  def v = readVersionFromTagFile(new File(moduleRoot, 'third_party/sherpa-onnx-prebuilt/ANDROID_RELEASE_TAG'), 'sherpa-onnx-android-v')
+  sherpaOnnxVersion = v ?: (project.hasProperty('sherpaOnnxVersion') ? project.sherpaOnnxVersion : '1.12.28')
 }
 project.ext.sherpaOnnxVersion = sherpaOnnxVersion
+println "[react-native-sherpa-onnx] sherpa-onnx version (extracted/used): ${sherpaOnnxVersion}"
 
 // FFmpeg: 1. FFMPEG_VERSION env 2. ANDROID_RELEASE_TAG 3. property 4. default
 def ffmpegVersion = System.getenv('FFMPEG_VERSION')
 if (!ffmpegVersion) {
-  def v = readVersionFromTagFile(new File(rootDir, 'third_party/ffmpeg_prebuilt/ANDROID_RELEASE_TAG'), 'ffmpeg-android-v')
+  def v = readVersionFromTagFile(new File(moduleRoot, 'third_party/ffmpeg_prebuilt/ANDROID_RELEASE_TAG'), 'ffmpeg-android-v')
   ffmpegVersion = v ?: (project.hasProperty('ffmpegVersion') ? project.ffmpegVersion : '8.0.1')
 }
 project.ext.ffmpegVersion = ffmpegVersion
@@ -30,7 +34,7 @@ project.ext.ffmpegVersion = ffmpegVersion
 // libarchive: 1. LIBARCHIVE_VERSION env 2. ANDROID_RELEASE_TAG 3. property 4. default
 def libarchiveVersion = System.getenv('LIBARCHIVE_VERSION')
 if (!libarchiveVersion) {
-  def v = readVersionFromTagFile(new File(rootDir, 'third_party/libarchive_prebuilt/ANDROID_RELEASE_TAG'), 'libarchive-android-v')
+  def v = readVersionFromTagFile(new File(moduleRoot, 'third_party/libarchive_prebuilt/ANDROID_RELEASE_TAG'), 'libarchive-android-v')
   libarchiveVersion = v ?: (project.hasProperty('libarchiveVersion') ? project.libarchiveVersion : '3.8.5')
 }
 project.ext.libarchiveVersion = libarchiveVersion

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

@@ -35,8 +35,8 @@ bool ContainsToken(const std::string& value, const std::string& token) {
     return value.find(token) != std::string::npos;
 }
 
-bool IsOnnxFile(const FileEntry& entry) {
-    return EndsWith(entry.nameLower, ".onnx");
+bool IsOnnxOrOrtFile(const FileEntry& entry) {
+    return EndsWith(entry.nameLower, ".onnx") || EndsWith(entry.nameLower, ".ort");
 }
 
 std::string BaseName(const std::string& path) {
@@ -55,7 +55,7 @@ std::string ChooseLargest(
     std::uint64_t bestSize = 0;
 
     for (const auto& entry : files) {
-        if (!IsOnnxFile(entry)) continue;
+        if (!IsOnnxOrOrtFile(entry)) continue;
 
         bool hasExcluded = false;
         for (const auto& token : excludeTokens) {
@@ -212,9 +212,8 @@ std::string ToLower(std::string value) {
     return value;
 }
 
-std::string FindFileByName(const std::string& baseDir, const std::string& fileName, int maxDepth) {
+std::string FindFileByName(const std::vector<FileEntry>& files, const std::string& fileName) {
     std::string target = ToLower(fileName);
-    auto files = ListFilesRecursive(baseDir, maxDepth);
     for (const auto& entry : files) {
         if (entry.nameLower == target) {
             return entry.path;
@@ -223,149 +222,17 @@ std::string FindFileByName(const std::string& baseDir, const std::string& fileNa
     return "";
 }
 
-std::string FindFileEndingWith(const std::string& baseDir, const std::string& suffix, int maxDepth) {
+std::string FindFileEndingWith(const std::vector<FileEntry>& files, const std::string& suffix) {
     std::string targetSuffix = ToLower(suffix);
-    auto files = ListFilesRecursive(baseDir, maxDepth);
-    // 1) exact match (e.g. "tokens.txt")
     for (const auto& entry : files) {
-        if (entry.nameLower == targetSuffix) {
-            return entry.path;
-        }
+        if (entry.nameLower == targetSuffix) return entry.path;
     }
-
-    // 2) true suffix match (preferred over substring to avoid false positives
-    //    like "tokens.txt.bak" or "mytokens.txt.tmp").
     for (const auto& entry : files) {
-        if (EndsWith(entry.nameLower, targetSuffix)) {
+        if (targetSuffix.size() <= entry.nameLower.size() &&
+            std::equal(targetSuffix.rbegin(), targetSuffix.rend(), entry.nameLower.rbegin())) {
             return entry.path;
         }
     }
-
-    // 3) If we are looking for tokens, fallback to inspecting .txt files' contents.
-    //    Heuristic: many token files are plain text with lines like "token <index>".
-    if (targetSuffix.find("tokens") != std::string::npos) {
-        auto IsLikelyTokensFile = [](const std::string& path) -> bool {
-            std::ifstream ifs(path);
-            if (!ifs.is_open()) return false;
-            std::string line;
-            int total = 0;
-            int matched = 0;
-            const int maxLines = 2000;
-
-            while (total < maxLines && std::getline(ifs, line)) {
-                ++total;
-                if (line.empty()) continue;
-                // Trim trailing CR if present
-                if (!line.empty() && line.back() == '\r') line.pop_back();
-
-                // Check if the line ends with an integer index (common token format)
-                size_t sp = line.find_last_of(" \t");
-                if (sp != std::string::npos && sp + 1 < line.size()) {
-                    std::string idx = line.substr(sp + 1);
-                    bool allDigits = !idx.empty();
-                    for (char c : idx) {
-                        if (!std::isdigit(static_cast<unsigned char>(c))) { allDigits = false; break; }
-                    }
-                    if (allDigits) ++matched;
-                }
-            }
-
-            ifs.close();
-            if (total < 2) return false;
-            // Heuristic: at least half of non-empty lines should match the token pattern
-            return matched >= std::max(1, total / 2);
-        };
-
-        for (const auto& entry : files) {
-            if (EndsWith(entry.nameLower, ".txt")) {
-                if (IsLikelyTokensFile(entry.path)) {
-                    return entry.path;
-                }
-            }
-        }
-    }
-    return "";
-}
-
-std::string FindDirectoryByName(const std::string& baseDir, const std::string& dirName, int maxDepth) {
-    std::string target = ToLower(dirName);
-    std::vector<std::string> toVisit = ListDirectories(baseDir);
-    int depth = 0;
-
-    while (!toVisit.empty() && depth <= maxDepth) {
-        std::vector<std::string> next;
-        for (const auto& dir : toVisit) {
-            std::string name = dir;
-#if __cplusplus >= 201703L && __has_include(<filesystem>)
-            try {
-                name = fs::path(dir).filename().string();
-            } catch (const std::exception&) {
-            }
-#elif __has_include(<experimental/filesystem>)
-            try {
-                name = fs::path(dir).filename().string();
-            } catch (const std::exception&) {
-            }
-#else
-            name = BaseName(dir);
-#endif
-            if (ToLower(name) == target) {
-                return dir;
-            }
-            if (depth < maxDepth) {
-                auto nested = ListDirectories(dir);
-                next.insert(next.end(), nested.begin(), nested.end());
-            }
-        }
-        toVisit.swap(next);
-        depth += 1;
-    }
-
-    return "";
-}
-
-std::string ResolveTokenizerDir(const std::string& modelDir) {
-    std::string vocabInMain = modelDir + "/vocab.json";
-    if (FileExists(vocabInMain)) {
-        return modelDir;
-    }
-
-    std::vector<std::string> toVisit = ListDirectories(modelDir);
-    int depth = 0;
-    while (!toVisit.empty() && depth <= 2) {
-        std::vector<std::string> next;
-        for (const auto& dir : toVisit) {
-            std::string dirName = dir;
-#if __cplusplus >= 201703L && __has_include(<filesystem>)
-            try {
-                dirName = fs::path(dir).filename().string();
-            } catch (const std::exception&) {
-            }
-#elif __has_include(<experimental/filesystem>)
-            try {
-                dirName = fs::path(dir).filename().string();
-            } catch (const std::exception&) {
-            }
-#else
-            dirName = BaseName(dir);
-#endif
-            std::string dirNameLower = ToLower(dirName);
-            if (dirNameLower.find("qwen3") != std::string::npos) {
-                std::string vocabPath = dir + "/vocab.json";
-                if (FileExists(vocabPath)) {
-                    return dir;
-                }
-            }
-
-            if (depth < 2) {
-                auto nested = ListDirectories(dir);
-                next.insert(next.end(), nested.begin(), nested.end());
-            }
-        }
-        toVisit.swap(next);
-        depth += 1;
-    }
-
     return "";
 }
 
@@ -377,7 +244,7 @@ std::string FindOnnxByToken(
     std::vector<FileEntry> matches;
     std::string tokenLower = ToLower(token);
     for (const auto& entry : files) {
-        if (!IsOnnxFile(entry)) continue;
+        if (!IsOnnxOrOrtFile(entry)) continue;
         if (ContainsToken(entry.nameLower, tokenLower)) {
             matches.push_back(entry);
         }
@@ -407,6 +274,40 @@ std::string FindOnnxByAnyToken(
     return "";
 }
 
+std::string FindOnnxByAnyTokenExcluding(
+    const std::vector<FileEntry>& files,
+    const std::vector<std::string>& tokens,
+    const std::vector<std::string>& excludeInName,
+    const std::optional<bool>& preferInt8
+) {
+    for (const auto& token : tokens) {
+        std::string tokenLower = ToLower(token);
+        std::vector<FileEntry> matches;
+        for (const auto& entry : files) {
+            if (!IsOnnxOrOrtFile(entry)) continue;
+            if (!ContainsToken(entry.nameLower, tokenLower)) continue;
+            bool excluded = false;
+            for (const auto& ex : excludeInName) {
+                std::string exLower = ToLower(ex);
+                if (ContainsToken(entry.nameLower, exLower)) {
+                    excluded = true;
+                    break;
+                }
+            }
+            if (!excluded) matches.push_back(entry);
+        }
+        if (matches.empty()) continue;
+        std::vector<std::string> emptyTokens;
+        bool wantInt8 = preferInt8.has_value() && preferInt8.value();
+        bool wantNonInt8 = preferInt8.has_value() && !preferInt8.value();
+        std::string chosen = ChooseLargest(matches, emptyTokens, wantInt8, wantNonInt8);
+        if (!chosen.empty()) return chosen;
+        chosen = ChooseLargest(matches, emptyTokens, false, false);
+        if (!chosen.empty()) return chosen;
+    }
+    return "";
+}
+
 std::string FindLargestOnnx(const std::vector<FileEntry>& files) {
     std::vector<std::string> emptyTokens;
     return ChooseLargest(files, emptyTokens, false, false);

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

@@ -22,11 +22,11 @@ std::vector<std::string> ListDirectories(const std::string& path);
 std::vector<FileEntry> ListFiles(const std::string& path);
 std::vector<FileEntry> ListFilesRecursive(const std::string& path, int maxDepth = 2);
 std::string ToLower(std::string value);
-std::string ResolveTokenizerDir(const std::string& modelDir);
 
-std::string FindFileByName(const std::string& baseDir, const std::string& fileName, int maxDepth = 2);
-std::string FindFileEndingWith(const std::string& baseDir, const std::string& suffix, int maxDepth = 2);
-std::string FindDirectoryByName(const std::string& baseDir, const std::string& dirName, int maxDepth = 2);
+/** Find file in \p files whose name equals \p fileName (case-insensitive). Uses file tree only, no filesystem. */
+std::string FindFileByName(const std::vector<FileEntry>& files, const std::string& fileName);
+/** Find file in \p files whose name equals or ends with \p suffix (e.g. tokens.txt). Case-insensitive. */
+std::string FindFileEndingWith(const std::vector<FileEntry>& files, const std::string& suffix);
 
 std::string FindOnnxByToken(
     const std::vector<FileEntry>& files,
@@ -40,6 +40,14 @@ std::string FindOnnxByAnyToken(
     const std::optional<bool>& preferInt8
 );
 
+/** Like FindOnnxByAnyToken but skips any file whose nameLower contains any of \p excludeInName. */
+std::string FindOnnxByAnyTokenExcluding(
+    const std::vector<FileEntry>& files,
+    const std::vector<std::string>& tokens,
+    const std::vector<std::string>& excludeInName,
+    const std::optional<bool>& preferInt8
+);
+
 std::string FindLargestOnnx(
     const std::vector<FileEntry>& files
 );