react-native-sherpa-onnx 0.3.7 → 0.3.9

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

@@ -20,6 +20,7 @@ const char* TtsModelKindToString(TtsModelKind k) {
     case TtsModelKind::kKitten: return "kitten";
     case TtsModelKind::kPocket: return "pocket";
     case TtsModelKind::kZipvoice: return "zipvoice";
+    case TtsModelKind::kSupertonic: return "supertonic";
     default: return "unknown";
   }
 }
@@ -78,6 +79,12 @@ jobject TtsDetectResultToJava(JNIEnv* env, const TtsDetectResult& result) {
       PutString(env, pathsMap, mapPut, "textConditioner", result.paths.textConditioner);
       PutString(env, pathsMap, mapPut, "vocabJson", result.paths.vocabJson);
       PutString(env, pathsMap, mapPut, "tokenScoresJson", result.paths.tokenScoresJson);
+      PutString(env, pathsMap, mapPut, "durationPredictor", result.paths.durationPredictor);
+      PutString(env, pathsMap, mapPut, "textEncoder", result.paths.textEncoder);
+      PutString(env, pathsMap, mapPut, "vectorEstimator", result.paths.vectorEstimator);
+      PutString(env, pathsMap, mapPut, "ttsJson", result.paths.ttsJson);
+      PutString(env, pathsMap, mapPut, "unicodeIndexer", result.paths.unicodeIndexer);
+      PutString(env, pathsMap, mapPut, "voiceStyle", result.paths.voiceStyle);
       jstring keyPaths = env->NewStringUTF("paths");
       env->CallObjectMethod(map, mapPut, keyPaths, pathsMap);
       env->DeleteLocalRef(keyPaths);

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";

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

@@ -59,6 +59,16 @@ static const TtsFieldRequirement kZipvoiceReqs[] = {
     {"lexicon",  &TtsModelPaths::lexicon,  true},
 };
 
+static const TtsFieldRequirement kSupertonicReqs[] = {
+    {"durationPredictor", &TtsModelPaths::durationPredictor, true},
+    {"textEncoder",       &TtsModelPaths::textEncoder,       true},
+    {"vectorEstimator",   &TtsModelPaths::vectorEstimator,   true},
+    {"vocoder",           &TtsModelPaths::vocoder,           true},
+    {"ttsJson",           &TtsModelPaths::ttsJson,           true},
+    {"unicodeIndexer",    &TtsModelPaths::unicodeIndexer,    true},
+    {"voiceStyle",        &TtsModelPaths::voiceStyle,        true},
+};
+
 // ============================================================
 
 static const TtsFieldRequirement* GetRequirements(TtsModelKind kind, size_t& count) {
@@ -79,6 +89,9 @@ static const TtsFieldRequirement* GetRequirements(TtsModelKind kind, size_t& cou
         case TtsModelKind::kZipvoice:
             count = std::size(kZipvoiceReqs);
             return kZipvoiceReqs;
+        case TtsModelKind::kSupertonic:
+            count = std::size(kSupertonicReqs);
+            return kSupertonicReqs;
         default:
             count = 0;
             return nullptr;
@@ -93,6 +106,7 @@ static const char* TtsKindToName(TtsModelKind k) {
         case TtsModelKind::kKitten:   return "Kitten";
         case TtsModelKind::kPocket:   return "Pocket";
         case TtsModelKind::kZipvoice: return "Zipvoice";
+        case TtsModelKind::kSupertonic: return "Supertonic";
         default:                      return "Unknown";
     }
 }

package/android/src/main/java/com/sherpaonnx/SherpaOnnxArchiveHelper.kt

@@ -54,7 +54,8 @@ class SherpaOnnxArchiveHelper {
     targetPath: String,
     force: Boolean,
     promise: Promise,
-    onProgress: (bytes: Long, totalBytes: Long, percent: Double) -> Unit
+    onProgress: (bytes: Long, totalBytes: Long, percent: Double) -> Unit,
+    extractionNotification: SherpaOnnxExtractionNotificationHelper? = null,
   ) {
     val promiseSettled = AtomicBoolean(false)
     fun resolveOnce(success: Boolean, reason: String? = null) {
@@ -70,26 +71,28 @@ class SherpaOnnxArchiveHelper {
       val cancelFlag = AtomicBoolean(false)
       cancelFlags[sourcePath] = cancelFlag
 
-      // Create a progress callback object that JNI can call
-      val progressCallback = object : Any() {
-        fun invoke(bytesExtracted: Long, totalBytes: Long, percent: Double) {
-          onProgress(bytesExtracted, totalBytes, percent)
-        }
-      }
-
       // Run extraction on a background thread so the React Native bridge thread is not blocked.
       // The thread pool allows multiple extractions in parallel.
       extractExecutor.execute {
+        val notif = extractionNotification
         try {
           // Check per-path cancel flag before starting the native extraction.
           if (cancelFlag.get()) {
             resolveOnce(false, "Cancelled")
             return@execute
           }
-          nativeExtractTarBz2(sourcePath, targetPath, force, progressCallback, promise)
+          notif?.start()
+          val wrappedCallback = object : Any() {
+            fun invoke(bytesExtracted: Long, totalBytes: Long, percent: Double) {
+              onProgress(bytesExtracted, totalBytes, percent)
+              notif?.updateProgress(percent)
+            }
+          }
+          nativeExtractTarBz2(sourcePath, targetPath, force, wrappedCallback, promise)
         } catch (e: Exception) {
           resolveOnce(false, "Archive extraction error: ${e.message}")
         } finally {
+          notif?.finish()
           cancelFlags.remove(sourcePath)
         }
       }
@@ -104,7 +107,8 @@ class SherpaOnnxArchiveHelper {
     targetPath: String,
     force: Boolean,
     promise: Promise,
-    onProgress: (bytes: Long, totalBytes: Long, percent: Double) -> Unit
+    onProgress: (bytes: Long, totalBytes: Long, percent: Double) -> Unit,
+    extractionNotification: SherpaOnnxExtractionNotificationHelper? = null,
   ) {
     val promiseSettled = AtomicBoolean(false)
     fun resolveOnce(success: Boolean, reason: String? = null) {
@@ -119,22 +123,26 @@ class SherpaOnnxArchiveHelper {
       val cancelFlag = AtomicBoolean(false)
       cancelFlags[sourcePath] = cancelFlag
 
-      val progressCallback = object : Any() {
-        fun invoke(bytesExtracted: Long, totalBytes: Long, percent: Double) {
-          onProgress(bytesExtracted, totalBytes, percent)
-        }
-      }
       extractExecutor.execute {
+        val notif = extractionNotification
         try {
           // Check per-path cancel flag before starting the native extraction.
           if (cancelFlag.get()) {
             resolveOnce(false, "Cancelled")
             return@execute
           }
-          nativeExtractTarZst(sourcePath, targetPath, force, progressCallback, promise)
+          notif?.start()
+          val wrappedCallback = object : Any() {
+            fun invoke(bytesExtracted: Long, totalBytes: Long, percent: Double) {
+              onProgress(bytesExtracted, totalBytes, percent)
+              notif?.updateProgress(percent)
+            }
+          }
+          nativeExtractTarZst(sourcePath, targetPath, force, wrappedCallback, promise)
         } catch (e: Exception) {
           resolveOnce(false, "Archive extraction error: ${e.message}")
         } finally {
+          notif?.finish()
           cancelFlags.remove(sourcePath)
         }
       }
@@ -144,47 +152,106 @@ class SherpaOnnxArchiveHelper {
     }
   }
 
+  /**
+   * Which JNI stream entry to use for APK asset extraction.
+   *
+   * Both paths invoke libarchive’s `ExtractFromStream`, which **auto-detects** compression
+   * (`.tar.zst` vs `.tar.bz2`, etc.); `nativeExtractTarBz2FromStream` forwards to the same
+   * native implementation as zst. Keeping distinct JNI symbols preserves a clear API and avoids
+   * the impression that bz2 assets are mistakenly wired only to a “zst” method.
+   */
+  private enum class AssetTarStreamKind {
+    ZST,
+    BZ2,
+  }
+
   fun extractTarZstFromAsset(
     context: Context,
     assetPath: String,
     targetPath: String,
     force: Boolean,
     promise: Promise,
-    onProgress: (bytes: Long, totalBytes: Long, percent: Double) -> Unit
+    onProgress: (bytes: Long, totalBytes: Long, percent: Double) -> Unit,
+    extractionNotification: SherpaOnnxExtractionNotificationHelper? = null,
+  ) {
+    extractTarArchiveFromAsset(
+      context,
+      assetPath,
+      targetPath,
+      force,
+      promise,
+      onProgress,
+      extractionNotification,
+      AssetTarStreamKind.ZST,
+    )
+  }
+
+  fun extractTarBz2FromAsset(
+    context: Context,
+    assetPath: String,
+    targetPath: String,
+    force: Boolean,
+    promise: Promise,
+    onProgress: (bytes: Long, totalBytes: Long, percent: Double) -> Unit,
+    extractionNotification: SherpaOnnxExtractionNotificationHelper? = null,
+  ) {
+    extractTarArchiveFromAsset(
+      context,
+      assetPath,
+      targetPath,
+      force,
+      promise,
+      onProgress,
+      extractionNotification,
+      AssetTarStreamKind.BZ2,
+    )
+  }
+
+  private fun extractTarArchiveFromAsset(
+    context: Context,
+    assetPath: String,
+    targetPath: String,
+    force: Boolean,
+    promise: Promise,
+    onProgress: (bytes: Long, totalBytes: Long, percent: Double) -> Unit,
+    extractionNotification: SherpaOnnxExtractionNotificationHelper? = null,
+    kind: AssetTarStreamKind,
   ) {
     if (BuildConfig.DEBUG) {
-      Log.i("SherpaOnnx", "extractTarZstFromAsset assetPath=$assetPath targetPath=$targetPath")
-    }
-    val progressCallback = object : Any() {
-      fun invoke(bytesExtracted: Long, totalBytes: Long, percent: Double) {
-        onProgress(bytesExtracted, totalBytes, percent)
-      }
+      Log.i(
+        "SherpaOnnx",
+        "extractTar${if (kind == AssetTarStreamKind.ZST) "Zst" else "Bz2"}FromAsset assetPath=$assetPath targetPath=$targetPath",
+      )
     }
     extractExecutor.execute {
+      val notif = extractionNotification
       try {
+        notif?.start()
+        val progressCallback = object : Any() {
+          fun invoke(bytesExtracted: Long, totalBytes: Long, percent: Double) {
+            onProgress(bytesExtracted, totalBytes, percent)
+            notif?.updateProgress(percent)
+          }
+        }
         context.assets.open(assetPath).use { stream ->
-          nativeExtractTarZstFromStream(stream, targetPath, force, progressCallback, promise)
+          when (kind) {
+            AssetTarStreamKind.ZST ->
+              nativeExtractTarZstFromStream(stream, targetPath, force, progressCallback, promise)
+            AssetTarStreamKind.BZ2 ->
+              nativeExtractTarBz2FromStream(stream, targetPath, force, progressCallback, promise)
+          }
         }
       } catch (e: Exception) {
         val result = Arguments.createMap()
         result.putBoolean("success", false)
         result.putString("reason", e.message ?: "Failed to open asset")
         promise.resolve(result)
+      } finally {
+        notif?.finish()
       }
     }
   }
 
-  fun extractTarBz2FromAsset(
-    context: Context,
-    assetPath: String,
-    targetPath: String,
-    force: Boolean,
-    promise: Promise,
-    onProgress: (bytes: Long, totalBytes: Long, percent: Double) -> Unit
-  ) {
-    extractTarZstFromAsset(context, assetPath, targetPath, force, promise, onProgress)
-  }
-
   fun computeFileSha256(filePath: String, promise: Promise) {
     nativeComputeFileSha256(filePath, promise)
   }
@@ -214,6 +281,14 @@ class SherpaOnnxArchiveHelper {
     promise: Promise
   )
 
+  private external fun nativeExtractTarBz2FromStream(
+    inputStream: java.io.InputStream,
+    targetPath: String,
+    force: Boolean,
+    progressCallback: Any?,
+    promise: Promise
+  )
+
   private external fun nativeCancelExtract()
 
   private external fun nativeComputeFileSha256(

package/android/src/main/java/com/sherpaonnx/SherpaOnnxExtractionNotificationHelper.kt

@@ -0,0 +1,102 @@
+package com.sherpaonnx
+
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.content.Context
+import android.os.Build
+import android.util.Log
+import androidx.core.app.NotificationCompat
+
+/**
+ * Android-only progress notification for archive extraction (mirrors background download visibility).
+ * Safe no-ops if posting fails (e.g. POST_NOTIFICATIONS denied).
+ */
+class SherpaOnnxExtractionNotificationHelper private constructor(
+  private val context: Context,
+  private val notificationId: Int,
+  private val title: String,
+  private val baseText: String,
+) {
+  private val nm = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+  @Volatile private var lastBucket: Int = -1
+
+  companion object {
+    private const val TAG = "SherpaOnnxExtractNotif"
+    const val CHANNEL_ID = "sherpa_onnx_extraction"
+    private val nextNotificationId = java.util.concurrent.atomic.AtomicInteger(9_200_000)
+
+    private const val DEFAULT_TITLE = "Model extraction"
+    private const val DEFAULT_TEXT = "Extracting archive…"
+
+    fun maybeCreate(
+      context: Context,
+      showNotificationsEnabled: Boolean?,
+      titleOverride: String?,
+      textOverride: String?,
+    ): SherpaOnnxExtractionNotificationHelper? {
+      if (showNotificationsEnabled == false) return null
+      val title = titleOverride?.trim()?.takeIf { it.isNotEmpty() } ?: DEFAULT_TITLE
+      val text = textOverride?.trim()?.takeIf { it.isNotEmpty() } ?: DEFAULT_TEXT
+      val id = nextNotificationId.getAndIncrement()
+      return SherpaOnnxExtractionNotificationHelper(context.applicationContext, id, title, text)
+    }
+
+    fun ensureChannel(ctx: Context) {
+      if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) return
+      val nm = ctx.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+      val existing = nm.getNotificationChannel(CHANNEL_ID)
+      if (existing != null) return
+      val ch = NotificationChannel(
+        CHANNEL_ID,
+        "Model extraction",
+        NotificationManager.IMPORTANCE_LOW,
+      ).apply {
+        setShowBadge(false)
+      }
+      nm.createNotificationChannel(ch)
+    }
+  }
+
+  private fun buildProgress(percentInt: Int): NotificationCompat.Builder {
+    val p = percentInt.coerceIn(0, 100)
+    val line = "$baseText $p%"
+    return NotificationCompat.Builder(context, CHANNEL_ID)
+      .setSmallIcon(android.R.drawable.stat_sys_download)
+      .setContentTitle(title)
+      .setContentText(line)
+      .setStyle(NotificationCompat.BigTextStyle().bigText(line))
+      .setOnlyAlertOnce(true)
+      .setPriority(NotificationCompat.PRIORITY_LOW)
+      .setOngoing(true)
+      .setProgress(100, p, false)
+  }
+
+  fun start() {
+    try {
+      ensureChannel(context)
+      nm.notify(notificationId, buildProgress(0).build())
+    } catch (e: Exception) {
+      Log.w(TAG, "start: ${e.message}")
+    }
+  }
+
+  fun updateProgress(percent: Double) {
+    val p = percent.toInt().coerceIn(0, 100)
+    val bucket = p / 4
+    if (bucket == lastBucket && p != 0 && p != 100) return
+    lastBucket = bucket
+    try {
+      nm.notify(notificationId, buildProgress(p).build())
+    } catch (e: Exception) {
+      Log.w(TAG, "updateProgress: ${e.message}")
+    }
+  }
+
+  fun finish() {
+    try {
+      nm.cancel(notificationId)
+    } catch (e: Exception) {
+      Log.w(TAG, "finish: ${e.message}")
+    }
+  }
+}

package/android/src/main/java/com/sherpaonnx/SherpaOnnxModule.kt

@@ -293,10 +293,30 @@ class SherpaOnnxModule(reactContext: ReactApplicationContext) :
     assetHelper.resolveModelPath(config, promise)
   }
 
-  override fun extractTarBz2(sourcePath: String, targetPath: String, force: Boolean, promise: Promise) {
-    archiveHelper.extractTarBz2(sourcePath, targetPath, force, promise) { bytes, total, percent ->
-      emitExtractProgress(sourcePath, bytes, total, percent)
-    }
+  override fun extractTarBz2(
+    sourcePath: String,
+    targetPath: String,
+    force: Boolean,
+    showNotificationsEnabled: Boolean?,
+    notificationTitle: String?,
+    notificationText: String?,
+    promise: Promise,
+  ) {
+    val notif = extractionNotificationOrNull(
+      showNotificationsEnabled,
+      notificationTitle,
+      notificationText,
+    )
+    archiveHelper.extractTarBz2(
+      sourcePath,
+      targetPath,
+      force,
+      promise,
+      { bytes, total, percent ->
+        emitExtractProgress(sourcePath, bytes, total, percent)
+      },
+      notif,
+    )
   }
 
   override fun cancelExtractTarBz2(promise: Promise) {
@@ -304,10 +324,30 @@ class SherpaOnnxModule(reactContext: ReactApplicationContext) :
     promise.resolve(null)
   }
 
-  override fun extractTarZst(sourcePath: String, targetPath: String, force: Boolean, promise: Promise) {
-    archiveHelper.extractTarZst(sourcePath, targetPath, force, promise) { bytes, total, percent ->
-      emitExtractTarZstProgress(sourcePath, bytes, total, percent)
-    }
+  override fun extractTarZst(
+    sourcePath: String,
+    targetPath: String,
+    force: Boolean,
+    showNotificationsEnabled: Boolean?,
+    notificationTitle: String?,
+    notificationText: String?,
+    promise: Promise,
+  ) {
+    val notif = extractionNotificationOrNull(
+      showNotificationsEnabled,
+      notificationTitle,
+      notificationText,
+    )
+    archiveHelper.extractTarZst(
+      sourcePath,
+      targetPath,
+      force,
+      promise,
+      { bytes, total, percent ->
+        emitExtractTarZstProgress(sourcePath, bytes, total, percent)
+      },
+      notif,
+    )
   }
 
   override fun cancelExtractTarZst(promise: Promise) {
@@ -346,6 +386,20 @@ class SherpaOnnxModule(reactContext: ReactApplicationContext) :
     eventEmitter.emit("extractTarZstProgress", payload)
   }
 
+  /** Null when extraction notifications are disabled (`showNotificationsEnabled == false`). */
+  private fun extractionNotificationOrNull(
+    showNotificationsEnabled: Boolean?,
+    notificationTitle: String?,
+    notificationText: String?,
+  ): SherpaOnnxExtractionNotificationHelper? {
+    return SherpaOnnxExtractionNotificationHelper.maybeCreate(
+      reactApplicationContext,
+      showNotificationsEnabled,
+      notificationTitle,
+      notificationText,
+    )
+  }
+
   /**
    * Resolve asset path - copy from assets to internal storage if needed
    * Preserves the directory structure from assets (e.g., test_wavs/ stays as test_wavs/)
@@ -1101,34 +1155,54 @@ class SherpaOnnxModule(reactContext: ReactApplicationContext) :
     assetPath: String,
     targetPath: String,
     force: Boolean,
-    promise: Promise
+    showNotificationsEnabled: Boolean?,
+    notificationTitle: String?,
+    notificationText: String?,
+    promise: Promise,
   ) {
+    val notif = extractionNotificationOrNull(
+      showNotificationsEnabled,
+      notificationTitle,
+      notificationText,
+    )
     archiveHelper.extractTarZstFromAsset(
       reactApplicationContext,
       assetPath,
       targetPath,
       force,
-      promise
-    ) { bytes, total, percent ->
-      emitExtractTarZstProgress(assetPath, bytes, total, percent)
-    }
+      promise,
+      { bytes, total, percent ->
+        emitExtractTarZstProgress(assetPath, bytes, total, percent)
+      },
+      notif,
+    )
   }
 
   override fun extractTarBz2FromAsset(
     assetPath: String,
     targetPath: String,
     force: Boolean,
-    promise: Promise
+    showNotificationsEnabled: Boolean?,
+    notificationTitle: String?,
+    notificationText: String?,
+    promise: Promise,
   ) {
+    val notif = extractionNotificationOrNull(
+      showNotificationsEnabled,
+      notificationTitle,
+      notificationText,
+    )
     archiveHelper.extractTarBz2FromAsset(
       reactApplicationContext,
       assetPath,
       targetPath,
       force,
-      promise
-    ) { bytes, total, percent ->
-      emitExtractProgress(assetPath, bytes, total, percent)
-    }
+      promise,
+      { bytes, total, percent ->
+        emitExtractProgress(assetPath, bytes, total, percent)
+      },
+      notif,
+    )
   }
 
   override fun readAssetFileAsUtf8(assetPath: String, promise: Promise) {

package/android/src/main/java/com/sherpaonnx/SherpaOnnxSttHelper.kt

@@ -22,6 +22,7 @@ import com.k2fsa.sherpa.onnx.OfflineSenseVoiceModelConfig
 import com.k2fsa.sherpa.onnx.OfflineZipformerCtcModelConfig
 import com.k2fsa.sherpa.onnx.OfflineWenetCtcModelConfig
 import com.k2fsa.sherpa.onnx.OfflineFunAsrNanoModelConfig
+import com.k2fsa.sherpa.onnx.OfflineQwen3AsrModelConfig
 import com.k2fsa.sherpa.onnx.OfflineMoonshineModelConfig
 import com.k2fsa.sherpa.onnx.OfflineDolphinModelConfig
 import com.k2fsa.sherpa.onnx.OfflineFireRedAsrModelConfig
@@ -541,6 +542,10 @@ internal class SherpaOnnxSttHelper(
       val hasHotwords = fn.hasKey("hotwords") && fn.getString("hotwords")?.isNotBlank() == true
       parts.add("funasrNano:lang=$lang,hotwords=$hasHotwords")
     }
+    modelOptions.getMap("qwen3Asr")?.let { q ->
+      val mnt = if (q.hasKey("maxNewTokens")) q.getInt("maxNewTokens") else null
+      parts.add("qwen3Asr:maxNewTokens=$mnt")
+    }
     return parts.joinToString(";").take(200)
   }
 
@@ -699,6 +704,23 @@ internal class SherpaOnnxSttHelper(
           tokens = ""
         )
       }
+      "qwen3_asr" -> {
+        val q3 = modelOptions?.getMap("qwen3Asr")
+        OfflineModelConfig(
+          qwen3Asr = OfflineQwen3AsrModelConfig(
+            convFrontend = path(paths, "qwen3ConvFrontend"),
+            encoder = path(paths, "qwen3Encoder"),
+            decoder = path(paths, "qwen3Decoder"),
+            tokenizer = path(paths, "qwen3Tokenizer"),
+            maxTotalLen = if (q3?.hasKey("maxTotalLen") == true) q3.getInt("maxTotalLen") else 512,
+            maxNewTokens = if (q3?.hasKey("maxNewTokens") == true) q3.getInt("maxNewTokens") else 128,
+            temperature = if (q3?.hasKey("temperature") == true) q3.getDouble("temperature").toFloat() else 1e-6f,
+            topP = if (q3?.hasKey("topP") == true) q3.getDouble("topP").toFloat() else 0.8f,
+            seed = if (q3?.hasKey("seed") == true) q3.getInt("seed") else 42
+          ),
+          tokens = ""
+        )
+      }
       else -> {
         val tokens = path(paths, "tokens")
         when {

package/android/src/main/java/com/sherpaonnx/SherpaOnnxTtsHelper.kt

@@ -31,6 +31,7 @@ import com.k2fsa.sherpa.onnx.OfflineTtsMatchaModelConfig
 import com.k2fsa.sherpa.onnx.OfflineTtsKokoroModelConfig
 import com.k2fsa.sherpa.onnx.OfflineTtsKittenModelConfig
 import com.k2fsa.sherpa.onnx.OfflineTtsZipVoiceModelConfig
+import com.k2fsa.sherpa.onnx.OfflineTtsSupertonicModelConfig
 import java.io.File
 import java.io.FileInputStream
 import java.io.FileOutputStream
@@ -1062,6 +1063,20 @@ internal class SherpaOnnxTtsHelper(
         debug = debug,
         provider = prov
       )
+      "supertonic" -> OfflineTtsModelConfig(
+        supertonic = OfflineTtsSupertonicModelConfig(
+          durationPredictor = path(paths, "durationPredictor"),
+          textEncoder = path(paths, "textEncoder"),
+          vectorEstimator = path(paths, "vectorEstimator"),
+          vocoder = path(paths, "vocoder"),
+          ttsJson = path(paths, "ttsJson"),
+          unicodeIndexer = path(paths, "unicodeIndexer"),
+          voiceStyle = path(paths, "voiceStyle")
+        ),
+        numThreads = numThreads,
+        debug = debug,
+        provider = prov
+      )
       else -> {
         if (path(paths, "acousticModel").isNotEmpty()) {
           OfflineTtsModelConfig(

package/ios/Resources/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