react-native-sherpa-onnx 0.3.7 → 0.3.9

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

package/ios/SherpaOnnx+TTS.mm

@@ -58,6 +58,7 @@ static NSString *ttsModelKindToNSString(sherpaonnx::TtsModelKind kind) {
         case K::kKitten: return @"kitten";
         case K::kPocket: return @"pocket";
         case K::kZipvoice: return @"zipvoice";
+        case K::kSupertonic: return @"supertonic";
         default: return @"unknown";
     }
 }

package/ios/SherpaOnnx.mm

@@ -138,9 +138,15 @@
 - (void)extractTarBz2:(NSString *)sourcePath
            targetPath:(NSString *)targetPath
                 force:(BOOL)force
-         resolve:(RCTPromiseResolveBlock)resolve
-         reject:(RCTPromiseRejectBlock)reject
+showNotificationsEnabled:(NSNumber *)showNotificationsEnabled
+    notificationTitle:(NSString *)notificationTitle
+     notificationText:(NSString *)notificationText
+              resolve:(RCTPromiseResolveBlock)resolve
+               reject:(RCTPromiseRejectBlock)reject
 {
+    (void)showNotificationsEnabled;
+    (void)notificationTitle;
+    (void)notificationText;
     SherpaOnnxArchiveHelper *helper = [SherpaOnnxArchiveHelper new];
     NSDictionary *result = [helper extractTarBz2:sourcePath
                                      targetPath:targetPath
@@ -165,9 +171,15 @@
 - (void)extractTarZst:(NSString *)sourcePath
            targetPath:(NSString *)targetPath
                 force:(BOOL)force
-             resolve:(RCTPromiseResolveBlock)resolve
-             reject:(RCTPromiseRejectBlock)reject
+showNotificationsEnabled:(NSNumber *)showNotificationsEnabled
+    notificationTitle:(NSString *)notificationTitle
+     notificationText:(NSString *)notificationText
+              resolve:(RCTPromiseResolveBlock)resolve
+               reject:(RCTPromiseRejectBlock)reject
 {
+    (void)showNotificationsEnabled;
+    (void)notificationTitle;
+    (void)notificationText;
     SherpaOnnxArchiveHelper *helper = [SherpaOnnxArchiveHelper new];
     NSDictionary *result = [helper extractTarZst:sourcePath
                                     targetPath:targetPath
@@ -229,19 +241,33 @@
 
 - (void)extractTarZstFromAsset:(NSString *)assetPath
                    targetPath:(NSString *)targetPath
-                       force:(NSNumber *)force
-                     resolve:(RCTPromiseResolveBlock)resolve
-                      reject:(RCTPromiseRejectBlock)reject
+                        force:(BOOL)force
+      showNotificationsEnabled:(NSNumber *)showNotificationsEnabled
+             notificationTitle:(NSString *)notificationTitle
+              notificationText:(NSString *)notificationText
+                       resolve:(RCTPromiseResolveBlock)resolve
+                        reject:(RCTPromiseRejectBlock)reject
 {
+    (void)force;
+    (void)showNotificationsEnabled;
+    (void)notificationTitle;
+    (void)notificationText;
     resolve(@{ @"success": @NO, @"reason": @"Not supported on iOS; use path-based extraction." });
 }
 
 - (void)extractTarBz2FromAsset:(NSString *)assetPath
                    targetPath:(NSString *)targetPath
-                        force:(NSNumber *)force
-                      resolve:(RCTPromiseResolveBlock)resolve
-                       reject:(RCTPromiseRejectBlock)reject
+                        force:(BOOL)force
+      showNotificationsEnabled:(NSNumber *)showNotificationsEnabled
+             notificationTitle:(NSString *)notificationTitle
+              notificationText:(NSString *)notificationText
+                       resolve:(RCTPromiseResolveBlock)resolve
+                        reject:(RCTPromiseRejectBlock)reject
 {
+    (void)force;
+    (void)showNotificationsEnabled;
+    (void)notificationTitle;
+    (void)notificationText;
     resolve(@{ @"success": @NO, @"reason": @"Not supported on iOS; use path-based extraction." });
 }
 
@@ -329,15 +355,59 @@
                nil);
         return;
     }
-    NSString *resourcePath = [[NSBundle mainBundle] resourcePath];
-    NSString *fullPath = [resourcePath stringByAppendingPathComponent:assetPath];
+    NSString *fullPath = nil;
+    NSBundle *mainBundle = [NSBundle mainBundle];
+    NSString *assetDir = [assetPath stringByDeletingLastPathComponent];
+    NSString *assetNameWithExt = [assetPath lastPathComponent];
+    NSString *assetName = [assetNameWithExt stringByDeletingPathExtension];
+    NSString *assetExt = [assetNameWithExt pathExtension];
+
+    // 1) App bundle: regular nested path (keeps generic asset support)
+    NSString *mainPath = [mainBundle pathForResource:assetName
+                                              ofType:assetExt.length > 0 ? assetExt : nil
+                                         inDirectory:assetDir.length > 0 ? assetDir : nil];
+    if (mainPath.length > 0) {
+        fullPath = mainPath;
+    }
+
+    // 2) CocoaPods resource bundle: files are flattened into bundle root
+    if (!fullPath) {
+        NSString *resBundlePath = [mainBundle pathForResource:@"SherpaOnnxResources"
+                                                       ofType:@"bundle"];
+        if (resBundlePath.length > 0) {
+            NSBundle *resBundle = [NSBundle bundleWithPath:resBundlePath];
+            if (resBundle) {
+                NSString *bundleRootPath = [resBundle pathForResource:assetName
+                                                                ofType:assetExt.length > 0 ? assetExt : nil];
+                if (bundleRootPath.length > 0) {
+                    fullPath = bundleRootPath;
+                }
+            }
+        }
+    }
+
+    if (!fullPath) {
+        reject(@"ASSET_READ_ERROR",
+               [NSString stringWithFormat:@"Failed to locate asset %@", assetPath],
+               nil);
+        return;
+    }
+
     NSError *error = nil;
-    NSString *content = [NSString stringWithContentsOfFile:fullPath encoding:NSUTF8StringEncoding error:&error];
-    if (error) {
-        reject(@"ASSET_READ_ERROR", [NSString stringWithFormat:@"Failed to read asset %@: %@", assetPath, error.localizedDescription], error);
-    } else {
-        resolve(content);
+    NSString *content = [NSString stringWithContentsOfFile:fullPath
+                                                   encoding:NSUTF8StringEncoding
+                                                      error:&error];
+    if (error || content == nil) {
+        reject(@"ASSET_READ_ERROR",
+               [NSString stringWithFormat:@"Failed to read asset %@ at %@: %@",
+                assetPath,
+                fullPath,
+                error.localizedDescription ?: @"Unknown error"],
+               error);
+        return;
     }
+
+    resolve(content);
 }
 
 @end

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

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

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

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

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

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

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

@@ -2,7 +2,7 @@
  * sherpa-onnx-model-detect-tts.mm
  *
  * Purpose: Detects TTS (text-to-speech) model type and fills TtsModelPaths from a model directory.
- * Used by the TTS wrapper on iOS. Supports Vits, Matcha, Kokoro, Kitten, Pocket, Zipvoice.
+ * Used by the TTS wrapper on iOS. Supports Vits, Matcha, Kokoro, Kitten, Pocket, Zipvoice, Supertonic.
  *
  * --- Detection pipeline (overview) ---
  *
@@ -58,6 +58,7 @@ TtsModelKind ParseTtsModelType(const std::string& modelType) {
     if (modelType == "kitten") return TtsModelKind::kKitten;
     if (modelType == "pocket") return TtsModelKind::kPocket;
     if (modelType == "zipvoice") return TtsModelKind::kZipvoice;
+    if (modelType == "supertonic") return TtsModelKind::kSupertonic;
     return TtsModelKind::kUnknown;
 }
 
@@ -70,6 +71,7 @@ static bool CapabilitySupportsTtsKind(
     bool hasMatcha,
     bool hasPocket,
     bool hasZipvoice,
+    bool hasSupertonic,
     bool hasVoicesFile,
     bool hasDataDir
 ) {
@@ -85,6 +87,8 @@ static bool CapabilitySupportsTtsKind(
             return hasPocket;
         case TtsModelKind::kZipvoice:
             return hasZipvoice;
+        case TtsModelKind::kSupertonic:
+            return hasSupertonic;
         default:
             return false;
     }
@@ -109,6 +113,7 @@ static std::vector<TtsModelKind> GetKindsFromDirNameTts(const std::string& model
     if (lower.find("matcha") != std::string::npos) add(TtsModelKind::kMatcha);
     if (lower.find("pocket") != std::string::npos) add(TtsModelKind::kPocket);
     if (lower.find("zipvoice") != std::string::npos) add(TtsModelKind::kZipvoice);
+    if (lower.find("supertonic") != std::string::npos) add(TtsModelKind::kSupertonic);
     if (lower.find("kokoro") != std::string::npos) add(TtsModelKind::kKokoro);
     if (lower.find("kitten") != std::string::npos) add(TtsModelKind::kKitten);
     if (lower.find("vits") != std::string::npos) add(TtsModelKind::kVits);
@@ -154,14 +159,27 @@ TtsDetectResult DetectTtsModel(const std::string& modelDir, const std::string& m
     std::string textConditioner = FindOnnxByAnyToken(files, {"text_conditioner", "text-conditioner"}, std::nullopt);
     std::string vocabJsonFile = FindFileByName(files, "vocab.json");
     std::string tokenScoresJsonFile = FindFileByName(files, "token_scores.json");
+    std::string durationPredictor = FindOnnxByAnyToken(files, {"duration_predictor", "duration-predictor"}, std::nullopt);
+    std::string textEncoderSupertonic = FindOnnxByAnyToken(files, {"text_encoder", "text-encoder"}, std::nullopt);
+    std::string vectorEstimator = FindOnnxByAnyToken(files, {"vector_estimator", "vector-estimator"}, std::nullopt);
+    std::string ttsJsonFile = FindFileByName(files, "tts.json");
+    std::string unicodeIndexerFile = FindFileByName(files, "unicode_indexer.bin");
+    std::string voiceStyleFile = FindFileByName(files, "voice.bin");
 
-    std::vector<std::string> modelExcludes = {"acoustic", "vocoder", "encoder", "decoder", "joiner"};
+    std::vector<std::string> modelExcludes = {
+        "acoustic", "vocoder", "encoder", "decoder", "joiner",
+        // Supertonic component models are not VITS monolithic model.onnx files.
+        "duration_predictor", "duration-predictor",
+        "text_encoder", "text-encoder",
+        "vector_estimator", "vector-estimator"
+    };
     std::string ttsModel = FindOnnxByAnyToken(files, {"model"}, std::nullopt);
     if (ttsModel.empty()) {
         ttsModel = FindLargestOnnxExcludingTokens(files, modelExcludes);
     }
 
-    bool hasVits = !ttsModel.empty();
+    // VITS requires both model.onnx-like file and tokens.txt
+    bool hasVits = !ttsModel.empty() && !tokensFile.empty();
     std::string modelDirLower = ToLower(modelDir);
     bool isLikelyMatcha = modelDirLower.find("matcha") != std::string::npos;
     bool hasMatcha = (!acousticModel.empty() && !vocoder.empty())
@@ -178,6 +196,9 @@ TtsDetectResult DetectTtsModel(const std::string& modelDir, const std::string& m
     }
     bool hasPocket = !lmFlow.empty() && !lmMain.empty() && !encoder.empty() && !decoder.empty() &&
                      !textConditioner.empty() && !vocabJsonFile.empty() && !tokenScoresJsonFile.empty();
+    bool hasSupertonic = !durationPredictor.empty() && !textEncoderSupertonic.empty() &&
+                         !vectorEstimator.empty() && !vocoder.empty() && !ttsJsonFile.empty() &&
+                         !unicodeIndexerFile.empty() && !voiceStyleFile.empty();
     bool hasDataDir = !dataDirPath.empty();
 
     bool isLikelyKitten = modelDirLower.find("kitten") != std::string::npos;
@@ -192,6 +213,9 @@ TtsDetectResult DetectTtsModel(const std::string& modelDir, const std::string& m
     if (hasZipvoice && !hasMatcha) {
         result.detectedModels.push_back({"zipvoice", modelDir});
     }
+    if (hasSupertonic) {
+        result.detectedModels.push_back({"supertonic", modelDir});
+    }
     if (hasVoicesFile) {
         if (isLikelyKitten && !isLikelyKokoro) {
             result.detectedModels.push_back({"kitten", modelDir});
@@ -228,7 +252,7 @@ TtsDetectResult DetectTtsModel(const std::string& modelDir, const std::string& m
         std::vector<TtsModelKind> nameCandidates = GetKindsFromDirNameTts(modelDir);
         if (!nameCandidates.empty()) {
             for (TtsModelKind k : nameCandidates) {
-                if (CapabilitySupportsTtsKind(k, hasVits, hasMatcha, hasPocket, hasZipvoice,
+                if (CapabilitySupportsTtsKind(k, hasVits, hasMatcha, hasPocket, hasZipvoice, hasSupertonic,
                                               hasVoicesFile, hasDataDir)) {
                     selected = k;
                     break;
@@ -243,6 +267,8 @@ TtsDetectResult DetectTtsModel(const std::string& modelDir, const std::string& m
                 selected = TtsModelKind::kPocket;
             } else if (hasZipvoice) {
                 selected = TtsModelKind::kZipvoice;
+            } else if (hasSupertonic) {
+                selected = TtsModelKind::kSupertonic;
             } else if (hasVoicesFile) {
                 if (isLikelyKitten && !isLikelyKokoro) {
                     selected = TtsModelKind::kKitten;
@@ -289,6 +315,12 @@ TtsDetectResult DetectTtsModel(const std::string& modelDir, const std::string& m
     result.paths.textConditioner = textConditioner;
     result.paths.vocabJson = vocabJsonFile;
     result.paths.tokenScoresJson = tokenScoresJsonFile;
+    result.paths.durationPredictor = durationPredictor;
+    result.paths.textEncoder = textEncoderSupertonic;
+    result.paths.vectorEstimator = vectorEstimator;
+    result.paths.ttsJson = ttsJsonFile;
+    result.paths.unicodeIndexer = unicodeIndexerFile;
+    result.paths.voiceStyle = voiceStyleFile;
 
     auto validation = ValidateTtsPaths(selected, result.paths, modelDir);
     if (!validation.ok) {

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

@@ -19,6 +19,7 @@ enum class SttModelKind {
     kZipformerCtc,
     kWhisper,
     kFunAsrNano,
+    kQwen3Asr,
     kFireRedAsr,
     kMoonshine,
     kMoonshineV2,
@@ -37,7 +38,8 @@ enum class TtsModelKind {
     kKokoro,
     kKitten,
     kPocket,
-    kZipvoice
+    kZipvoice,
+    kSupertonic
 };
 
 struct SttModelPaths {
@@ -55,6 +57,11 @@ struct SttModelPaths {
     std::string funasrLLM;
     std::string funasrEmbedding;
     std::string funasrTokenizer;
+    /** Qwen3-ASR: conv_frontend.onnx + encoder + decoder + tokenizer dir (vocab.json, merges.txt, tokenizer_config.json). */
+    std::string qwen3ConvFrontend;
+    std::string qwen3Encoder;
+    std::string qwen3Decoder;
+    std::string qwen3Tokenizer;
     std::string moonshinePreprocessor;
     std::string moonshineEncoder;
     std::string moonshineUncachedDecoder;
@@ -84,6 +91,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;
@@ -99,6 +108,7 @@ struct SttPathHints {
     bool isLikelyWenetCtc = false;
     bool isLikelySenseVoice = false;
     bool isLikelyFunAsrNano = false;
+    bool isLikelyQwen3Asr = false;
     bool isLikelyZipformer = false;
     bool isLikelyMoonshine = false;
     bool isLikelyDolphin = false;
@@ -123,6 +133,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. */
@@ -150,6 +161,13 @@ struct TtsModelPaths {
     std::string textConditioner;
     std::string vocabJson;
     std::string tokenScoresJson;
+    // Supertonic TTS
+    std::string durationPredictor;
+    std::string textEncoder;
+    std::string vectorEstimator;
+    std::string ttsJson;
+    std::string unicodeIndexer;
+    std::string voiceStyle;
 };
 
 struct SttDetectResult {

package/ios/model_detect/sherpa-onnx-validate-stt.mm

@@ -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/ios/model_detect/sherpa-onnx-validate-tts.mm

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