react-native-sherpa-onnx 0.3.8 → 0.3.9

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/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

package/ios/SherpaOnnx+STT.mm

@@ -36,6 +36,7 @@ static NSString *sttModelKindToNSString(sherpaonnx::SttModelKind kind) {
         case K::kZipformerCtc: return @"zipformer_ctc";
         case K::kWhisper: return @"whisper";
         case K::kFunAsrNano: return @"funasr_nano";
+        case K::kQwen3Asr: return @"qwen3_asr";
         case K::kFireRedAsr: return @"fire_red_asr";
         case K::kMoonshine: return @"moonshine";
         case K::kMoonshineV2: return @"moonshine_v2";
@@ -164,10 +165,12 @@ static NSDictionary *sttResultToDict(const sherpaonnx::SttRecognitionResult& r)
         sherpaonnx::SttSenseVoiceOptions senseVoiceOpts;
         sherpaonnx::SttCanaryOptions canaryOpts;
         sherpaonnx::SttFunAsrNanoOptions funasrNanoOpts;
+        sherpaonnx::SttQwen3AsrOptions qwen3AsrOpts;
         const sherpaonnx::SttWhisperOptions *whisperOptsPtr = nullptr;
         const sherpaonnx::SttSenseVoiceOptions *senseVoiceOptsPtr = nullptr;
         const sherpaonnx::SttCanaryOptions *canaryOptsPtr = nullptr;
         const sherpaonnx::SttFunAsrNanoOptions *funasrNanoOptsPtr = nullptr;
+        const sherpaonnx::SttQwen3AsrOptions *qwen3AsrOptsPtr = nullptr;
         if (modelOptions != nil && [modelOptions isKindOfClass:[NSDictionary class]]) {
             NSDictionary *w = modelOptions[@"whisper"];
             if ([w isKindOfClass:[NSDictionary class]]) {
@@ -202,12 +205,21 @@ static NSDictionary *sttResultToDict(const sherpaonnx::SttRecognitionResult& r)
                 if (fn[@"hotwords"] != nil) funasrNanoOpts.hotwords = std::string([(NSString *)fn[@"hotwords"] UTF8String]);
                 funasrNanoOptsPtr = &funasrNanoOpts;
             }
+            NSDictionary *q3 = modelOptions[@"qwen3Asr"];
+            if ([q3 isKindOfClass:[NSDictionary class]]) {
+                if (q3[@"maxTotalLen"] != nil) qwen3AsrOpts.max_total_len = [(NSNumber *)q3[@"maxTotalLen"] intValue];
+                if (q3[@"maxNewTokens"] != nil) qwen3AsrOpts.max_new_tokens = [(NSNumber *)q3[@"maxNewTokens"] intValue];
+                if (q3[@"temperature"] != nil) qwen3AsrOpts.temperature = [(NSNumber *)q3[@"temperature"] floatValue];
+                if (q3[@"topP"] != nil) qwen3AsrOpts.top_p = [(NSNumber *)q3[@"topP"] floatValue];
+                if (q3[@"seed"] != nil) qwen3AsrOpts.seed = [(NSNumber *)q3[@"seed"] intValue];
+                qwen3AsrOptsPtr = &qwen3AsrOpts;
+            }
         }
 
         sherpaonnx::SttInitializeResult result = inst->wrapper->initialize(
             modelDirStr, preferInt8Opt, modelTypeOpt, debugVal, hotwordsFileOpt, hotwordsScoreOpt,
             numThreadsOpt, providerOpt, ruleFstsOpt, ruleFarsOpt, ditherOpt,
-            whisperOptsPtr, senseVoiceOptsPtr, canaryOptsPtr, funasrNanoOptsPtr);
+            whisperOptsPtr, senseVoiceOptsPtr, canaryOptsPtr, funasrNanoOptsPtr, qwen3AsrOptsPtr);
 
         if (result.success) {
             RCTLogInfo(@"Sherpa-onnx initialized successfully");