react-native-sherpa-onnx 0.2.0 → 0.3.0

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

@@ -0,0 +1,210 @@
+/**
+ * sherpa-onnx-model-detect-helper.mm
+ *
+ * Purpose: Shared filesystem and string helpers for model detection (file/dir listing, token-based
+ * ONNX search, path resolution). Used by sherpa-onnx-model-detect-stt.mm and -tts.mm on iOS.
+ */
+
+#include "sherpa-onnx-model-detect-helper.h"
+
+#include <algorithm>
+#include <cctype>
+#include <cstdint>
+#include <filesystem>
+#include <string>
+#include <vector>
+
+namespace fs = std::filesystem;
+
+namespace sherpaonnx {
+namespace model_detect {
+
+namespace {
+
+bool EndsWith(const std::string& value, const std::string& suffix) {
+    if (suffix.size() > value.size()) return false;
+    return std::equal(suffix.rbegin(), suffix.rend(), value.rbegin());
+}
+
+bool ContainsToken(const std::string& value, const std::string& token) {
+    return value.find(token) != std::string::npos;
+}
+
+std::string ChooseLargest(const std::vector<FileEntry>& files,
+    const std::vector<std::string>& excludeTokens, bool onlyInt8, bool onlyNonInt8) {
+    std::string chosen;
+    std::uint64_t bestSize = 0;
+    for (const auto& entry : files) {
+        if (!EndsWith(entry.nameLower, ".onnx")) continue;
+        bool hasExcluded = false;
+        for (const auto& token : excludeTokens) {
+            if (ContainsToken(entry.nameLower, token)) { hasExcluded = true; break; }
+        }
+        if (hasExcluded) continue;
+        bool isInt8 = ContainsToken(entry.nameLower, "int8");
+        if (onlyInt8 && !isInt8) continue;
+        if (onlyNonInt8 && isInt8) continue;
+        if (entry.size >= bestSize) {
+            bestSize = entry.size;
+            chosen = entry.path;
+        }
+    }
+    return chosen;
+}
+
+} // namespace
+
+bool FileExists(const std::string& path) {
+    return fs::exists(path);
+}
+
+bool IsDirectory(const std::string& path) {
+    return fs::is_directory(path);
+}
+
+std::string ToLower(std::string value) {
+    std::transform(value.begin(), value.end(), value.begin(), [](unsigned char c) {
+        return static_cast<char>(std::tolower(c));
+    });
+    return value;
+}
+
+std::vector<std::string> ListDirectories(const std::string& path) {
+    std::vector<std::string> results;
+    try {
+        for (const auto& entry : fs::directory_iterator(path)) {
+            if (entry.is_directory()) results.push_back(entry.path().string());
+        }
+    } catch (const std::exception&) {}
+    return results;
+}
+
+std::vector<FileEntry> ListFiles(const std::string& dir) {
+    std::vector<FileEntry> results;
+    try {
+        for (const auto& entry : fs::directory_iterator(dir)) {
+            if (!entry.is_regular_file()) continue;
+            FileEntry file;
+            file.path = entry.path().string();
+            std::string name = entry.path().filename().string();
+            file.nameLower = ToLower(name);
+            file.size = static_cast<std::uint64_t>(entry.file_size());
+            results.push_back(file);
+        }
+    } catch (const std::exception&) {}
+    return results;
+}
+
+std::vector<FileEntry> ListFilesRecursive(const std::string& path, int maxDepth) {
+    std::vector<FileEntry> results = ListFiles(path);
+    if (maxDepth <= 0) return results;
+    for (const auto& dir : ListDirectories(path)) {
+        auto nested = ListFilesRecursive(dir, maxDepth - 1);
+        results.insert(results.end(), nested.begin(), nested.end());
+    }
+    return results;
+}
+
+std::string FindLargestOnnxExcludingTokens(const std::vector<FileEntry>& files,
+    const std::vector<std::string>& excludeTokens) {
+    return ChooseLargest(files, excludeTokens, false, false);
+}
+
+std::string FindOnnxByToken(const std::vector<FileEntry>& files,
+    const std::string& token, const std::optional<bool>& preferInt8) {
+    std::string tokenLower = ToLower(token);
+    std::vector<FileEntry> matches;
+    for (const auto& entry : files) {
+        if (!EndsWith(entry.nameLower, ".onnx")) continue;
+        if (ContainsToken(entry.nameLower, tokenLower)) matches.push_back(entry);
+    }
+    if (matches.empty()) return "";
+    std::vector<std::string> emptyTokens;
+    bool wantInt8 = preferInt8.has_value() && preferInt8.value();
+    bool wantNonInt8 = preferInt8.has_value() && !preferInt8.value();
+    std::string preferred = ChooseLargest(matches, emptyTokens, wantInt8, wantNonInt8);
+    if (!preferred.empty()) return preferred;
+    return ChooseLargest(matches, emptyTokens, false, false);
+}
+
+std::string FindOnnxByAnyToken(const std::vector<FileEntry>& files,
+    const std::vector<std::string>& tokens, const std::optional<bool>& preferInt8) {
+    for (const auto& token : tokens) {
+        std::string match = FindOnnxByToken(files, token, preferInt8);
+        if (!match.empty()) return match;
+    }
+    return "";
+}
+
+std::string FindFileEndingWith(const std::vector<FileEntry>& files, const std::string& suffix) {
+    std::string targetSuffix = ToLower(suffix);
+    for (const auto& entry : files) {
+        if (entry.nameLower == targetSuffix) return entry.path;
+    }
+    for (const auto& entry : files) {
+        if (EndsWith(entry.nameLower, targetSuffix)) return entry.path;
+    }
+    return "";
+}
+
+std::string FindFileByName(const std::string& baseDir, const std::string& fileName, int maxDepth) {
+    std::string target = ToLower(fileName);
+    auto files = ListFilesRecursive(baseDir, maxDepth);
+    for (const auto& entry : files) {
+        if (entry.nameLower == target) 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 = fs::path(dir).filename().string();
+            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;
+    }
+
+    try {
+        for (const auto& entry : fs::directory_iterator(modelDir)) {
+            if (entry.is_directory()) {
+                std::string dirName = entry.path().filename().string();
+                std::string dirNameLower = ToLower(dirName);
+                if (dirNameLower.find("qwen3") != std::string::npos) {
+                    std::string vocabPath = entry.path().string() + "/vocab.json";
+                    if (FileExists(vocabPath)) {
+                        return entry.path().string();
+                    }
+                }
+            }
+        }
+    } catch (const std::exception&) {
+    }
+
+    std::string commonPath = modelDir + "/Qwen3-0.6B";
+    if (FileExists(commonPath + "/vocab.json")) {
+        return commonPath;
+    }
+
+    return "";
+}
+
+} // namespace model_detect
+} // namespace sherpaonnx

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

@@ -0,0 +1,344 @@
+/**
+ * sherpa-onnx-model-detect-stt.mm
+ *
+ * Purpose: Detects STT (speech-to-text) model type and fills SttModelPaths from a model directory.
+ * Supports transducer, paraformer, whisper, and other STT variants. Used by the STT wrapper on iOS.
+ */
+
+#include "sherpa-onnx-model-detect.h"
+#include "sherpa-onnx-model-detect-helper.h"
+
+#include <string>
+
+namespace sherpaonnx {
+namespace {
+
+using namespace model_detect;
+
+SttModelKind ParseSttModelType(const std::string& modelType) {
+    if (modelType == "transducer" || modelType == "zipformer") return SttModelKind::kTransducer;
+    if (modelType == "nemo_transducer") return SttModelKind::kNemoTransducer;
+    if (modelType == "paraformer") return SttModelKind::kParaformer;
+    if (modelType == "nemo_ctc") return SttModelKind::kNemoCtc;
+    if (modelType == "wenet_ctc") return SttModelKind::kWenetCtc;
+    if (modelType == "sense_voice") return SttModelKind::kSenseVoice;
+    if (modelType == "zipformer_ctc" || modelType == "ctc") return SttModelKind::kZipformerCtc;
+    if (modelType == "whisper") return SttModelKind::kWhisper;
+    if (modelType == "funasr_nano") return SttModelKind::kFunAsrNano;
+    if (modelType == "fire_red_asr") return SttModelKind::kFireRedAsr;
+    if (modelType == "moonshine") return SttModelKind::kMoonshine;
+    if (modelType == "dolphin") return SttModelKind::kDolphin;
+    if (modelType == "canary") return SttModelKind::kCanary;
+    if (modelType == "omnilingual") return SttModelKind::kOmnilingual;
+    if (modelType == "medasr") return SttModelKind::kMedAsr;
+    if (modelType == "telespeech_ctc") return SttModelKind::kTeleSpeechCtc;
+    return SttModelKind::kUnknown;
+}
+
+} // namespace
+
+SttDetectResult DetectSttModel(
+    const std::string& modelDir,
+    const std::optional<bool>& preferInt8,
+    const std::optional<std::string>& modelType,
+    bool debug /* = false */
+) {
+    using namespace model_detect;
+
+    SttDetectResult result;
+
+    if (modelDir.empty()) {
+        result.error = "Model directory is empty";
+        return result;
+    }
+
+    if (!FileExists(modelDir) || !IsDirectory(modelDir)) {
+        result.error = "Model directory does not exist or is not a directory: " + modelDir;
+        return result;
+    }
+
+    const int kMaxSearchDepth = 4;
+    const std::vector<FileEntry> files = ListFilesRecursive(modelDir, kMaxSearchDepth);
+
+    std::string encoderPath = FindOnnxByAnyToken(files, {"encoder"}, preferInt8);
+    std::string decoderPath = FindOnnxByAnyToken(files, {"decoder"}, preferInt8);
+    std::string joinerPath = FindOnnxByAnyToken(files, {"joiner"}, preferInt8);
+    std::string tokensPath = FindFileEndingWith(files, "tokens.txt");
+
+    std::vector<std::string> modelExcludes = {
+        "encoder", "decoder", "joiner", "vocoder", "acoustic", "embedding", "llm",
+        "encoder_adaptor", "encoder-adaptor"
+    };
+    std::string paraformerModelPath = FindOnnxByAnyToken(files, {"model"}, preferInt8);
+    if (paraformerModelPath.empty()) {
+        paraformerModelPath = FindLargestOnnxExcludingTokens(files, modelExcludes);
+    }
+    std::string ctcModelPath = FindOnnxByAnyToken(files, {"model"}, preferInt8);
+    if (ctcModelPath.empty()) {
+        ctcModelPath = FindLargestOnnxExcludingTokens(files, modelExcludes);
+    }
+
+    std::string funasrEncoderAdaptor = FindOnnxByAnyToken(files, {"encoder_adaptor", "encoder-adaptor"}, preferInt8);
+    std::string funasrLLM = FindOnnxByAnyToken(files, {"llm"}, preferInt8);
+    std::string funasrEmbedding = FindOnnxByAnyToken(files, {"embedding"}, preferInt8);
+    std::string funasrTokenizerDir = ResolveTokenizerDir(modelDir);
+
+    std::string moonshinePreprocess = FindOnnxByAnyToken(files, {"preprocess", "preprocessor"}, preferInt8);
+    std::string moonshineEncode = FindOnnxByAnyToken(files, {"encode"}, preferInt8);
+    std::string moonshineUncachedDecode = FindOnnxByAnyToken(files, {"uncached_decode", "uncached"}, preferInt8);
+    std::string moonshineCachedDecode = FindOnnxByAnyToken(files, {"cached_decode", "cached"}, preferInt8);
+
+    bool hasTransducer = !encoderPath.empty() && !decoderPath.empty() && !joinerPath.empty();
+
+    bool hasWhisperEncoder = !encoderPath.empty();
+    bool hasWhisperDecoder = !decoderPath.empty();
+    bool hasWhisper = hasWhisperEncoder && hasWhisperDecoder && joinerPath.empty();
+
+    bool hasFunAsrEncoderAdaptor = !funasrEncoderAdaptor.empty();
+    bool hasFunAsrLLM = !funasrLLM.empty();
+    bool hasFunAsrEmbedding = !funasrEmbedding.empty();
+    bool hasFunAsrTokenizer = !funasrTokenizerDir.empty() && FileExists(funasrTokenizerDir + "/vocab.json");
+    bool hasFunAsrNano = hasFunAsrEncoderAdaptor && hasFunAsrLLM && hasFunAsrEmbedding && hasFunAsrTokenizer;
+
+    std::string modelDirLower = ToLower(modelDir);
+    bool isLikelyNemo = modelDirLower.find("nemo") != std::string::npos ||
+                        modelDirLower.find("parakeet") != std::string::npos;
+    bool isLikelyTdt = modelDirLower.find("tdt") != std::string::npos;
+    bool isLikelyWenetCtc = modelDirLower.find("wenet") != std::string::npos;
+    bool isLikelySenseVoice = modelDirLower.find("sense") != std::string::npos ||
+                              modelDirLower.find("sensevoice") != std::string::npos;
+    bool isLikelyFunAsrNano = modelDirLower.find("funasr") != std::string::npos ||
+                              modelDirLower.find("funasr-nano") != std::string::npos;
+    bool isLikelyZipformer = modelDirLower.find("zipformer") != std::string::npos;
+    bool isLikelyMoonshine = modelDirLower.find("moonshine") != std::string::npos;
+    bool isLikelyDolphin = modelDirLower.find("dolphin") != std::string::npos;
+    bool isLikelyFireRedAsr = modelDirLower.find("fire_red") != std::string::npos ||
+                              modelDirLower.find("fire-red") != std::string::npos;
+    bool isLikelyCanary = modelDirLower.find("canary") != std::string::npos;
+    bool isLikelyOmnilingual = modelDirLower.find("omnilingual") != std::string::npos;
+    bool isLikelyMedAsr = modelDirLower.find("medasr") != std::string::npos;
+    bool isLikelyTeleSpeech = modelDirLower.find("telespeech") != std::string::npos;
+
+    bool hasMoonshine = !moonshinePreprocess.empty() && !moonshineUncachedDecode.empty() &&
+                        !moonshineCachedDecode.empty() && !moonshineEncode.empty();
+    bool hasDolphin = isLikelyDolphin && !ctcModelPath.empty();
+    bool hasFireRedAsr = hasTransducer && isLikelyFireRedAsr;
+    bool hasCanary = hasWhisperEncoder && hasWhisperDecoder && joinerPath.empty() && isLikelyCanary;
+    bool hasOmnilingual = !ctcModelPath.empty() && isLikelyOmnilingual;
+    bool hasMedAsr = !ctcModelPath.empty() && isLikelyMedAsr;
+    bool hasTeleSpeechCtc = (!ctcModelPath.empty() || !paraformerModelPath.empty()) && isLikelyTeleSpeech;
+
+    if (hasTransducer) {
+        if (isLikelyNemo || isLikelyTdt) {
+            result.detectedModels.push_back({"nemo_transducer", modelDir});
+        } else {
+            result.detectedModels.push_back({isLikelyZipformer ? "zipformer" : "transducer", modelDir});
+        }
+    }
+
+    if (!ctcModelPath.empty() && (isLikelyNemo || isLikelyWenetCtc || isLikelySenseVoice)) {
+        if (isLikelyNemo) {
+            result.detectedModels.push_back({"nemo_ctc", modelDir});
+        } else if (isLikelyWenetCtc) {
+            result.detectedModels.push_back({"wenet_ctc", modelDir});
+        } else if (isLikelySenseVoice) {
+            result.detectedModels.push_back({"sense_voice", modelDir});
+        } else {
+            result.detectedModels.push_back({"ctc", modelDir});
+        }
+    } else if (!paraformerModelPath.empty()) {
+        result.detectedModels.push_back({"paraformer", modelDir});
+    }
+
+    if (hasWhisper) {
+        result.detectedModels.push_back({"whisper", modelDir});
+    }
+
+    if (hasFunAsrNano) {
+        result.detectedModels.push_back({"funasr_nano", modelDir});
+    }
+    if (hasMoonshine) {
+        result.detectedModels.push_back({"moonshine", modelDir});
+    }
+    if (hasDolphin) {
+        result.detectedModels.push_back({"dolphin", modelDir});
+    }
+    if (hasFireRedAsr) {
+        result.detectedModels.push_back({"fire_red_asr", modelDir});
+    }
+    if (hasCanary) {
+        result.detectedModels.push_back({"canary", modelDir});
+    }
+    if (hasOmnilingual) {
+        result.detectedModels.push_back({"omnilingual", modelDir});
+    }
+    if (hasMedAsr) {
+        result.detectedModels.push_back({"medasr", modelDir});
+    }
+    if (hasTeleSpeechCtc) {
+        result.detectedModels.push_back({"telespeech_ctc", modelDir});
+    }
+
+    SttModelKind selected = SttModelKind::kUnknown;
+
+    if (modelType.has_value() && modelType.value() != "auto") {
+        selected = ParseSttModelType(modelType.value());
+        if (selected == SttModelKind::kUnknown) {
+            result.error = "Unknown model type: " + modelType.value();
+            return result;
+        }
+
+        if (selected == SttModelKind::kTransducer && !hasTransducer) {
+            result.error = "Transducer model requested but files not found in " + modelDir;
+            return result;
+        }
+        if (selected == SttModelKind::kNemoTransducer && !hasTransducer) {
+            result.error = "NeMo Transducer model requested but encoder/decoder/joiner not found in " + modelDir;
+            return result;
+        }
+        if (selected == SttModelKind::kParaformer && paraformerModelPath.empty()) {
+            result.error = "Paraformer model requested but model.onnx not found in " + modelDir;
+            return result;
+        }
+        if ((selected == SttModelKind::kNemoCtc || selected == SttModelKind::kWenetCtc ||
+             selected == SttModelKind::kSenseVoice || selected == SttModelKind::kZipformerCtc) &&
+            ctcModelPath.empty()) {
+            result.error = "CTC model requested but model.onnx not found in " + modelDir;
+            return result;
+        }
+        if (selected == SttModelKind::kWhisper && !hasWhisper) {
+            result.error = "Whisper model requested but encoder/decoder not found in " + modelDir;
+            return result;
+        }
+        if (selected == SttModelKind::kFunAsrNano && !hasFunAsrNano) {
+            result.error = "FunASR Nano model requested but required files not found in " + modelDir;
+            return result;
+        }
+        if (selected == SttModelKind::kMoonshine && !hasMoonshine) {
+            result.error = "Moonshine model requested but preprocess/encode/uncached_decode/cached_decode not found in " + modelDir;
+            return result;
+        }
+        if (selected == SttModelKind::kDolphin && !hasDolphin) {
+            result.error = "Dolphin model requested but model not found in " + modelDir;
+            return result;
+        }
+        if (selected == SttModelKind::kFireRedAsr && !hasFireRedAsr) {
+            result.error = "FireRed ASR model requested but encoder/decoder not found in " + modelDir;
+            return result;
+        }
+        if (selected == SttModelKind::kCanary && !hasCanary) {
+            result.error = "Canary model requested but encoder/decoder not found in " + modelDir;
+            return result;
+        }
+        if (selected == SttModelKind::kOmnilingual && !hasOmnilingual) {
+            result.error = "Omnilingual model requested but model not found in " + modelDir;
+            return result;
+        }
+        if (selected == SttModelKind::kMedAsr && !hasMedAsr) {
+            result.error = "MedASR model requested but model not found in " + modelDir;
+            return result;
+        }
+        if (selected == SttModelKind::kTeleSpeechCtc && !hasTeleSpeechCtc) {
+            result.error = "TeleSpeech CTC model requested but model not found in " + modelDir;
+            return result;
+        }
+    } else {
+        if (hasTransducer) {
+            selected = (isLikelyNemo || isLikelyTdt) ? SttModelKind::kNemoTransducer : SttModelKind::kTransducer;
+        } else if (!ctcModelPath.empty() && (isLikelyNemo || isLikelyWenetCtc || isLikelySenseVoice)) {
+            if (isLikelyNemo) {
+                selected = SttModelKind::kNemoCtc;
+            } else if (isLikelyWenetCtc) {
+                selected = SttModelKind::kWenetCtc;
+            } else {
+                selected = SttModelKind::kSenseVoice;
+            }
+        } else if (hasFunAsrNano && isLikelyFunAsrNano) {
+            selected = SttModelKind::kFunAsrNano;
+        } else if (!paraformerModelPath.empty()) {
+            selected = SttModelKind::kParaformer;
+        } else if (hasCanary) {
+            selected = SttModelKind::kCanary;
+        } else if (hasFireRedAsr) {
+            selected = SttModelKind::kFireRedAsr;
+        } else if (hasWhisper) {
+            selected = SttModelKind::kWhisper;
+        } else if (hasFunAsrNano) {
+            selected = SttModelKind::kFunAsrNano;
+        } else if (hasMoonshine && isLikelyMoonshine) {
+            selected = SttModelKind::kMoonshine;
+        } else if (hasDolphin) {
+            selected = SttModelKind::kDolphin;
+        } else if (hasFireRedAsr) {
+            selected = SttModelKind::kFireRedAsr;
+        } else if (hasCanary) {
+            selected = SttModelKind::kCanary;
+        } else if (hasOmnilingual) {
+            selected = SttModelKind::kOmnilingual;
+        } else if (hasMedAsr) {
+            selected = SttModelKind::kMedAsr;
+        } else if (hasTeleSpeechCtc) {
+            selected = SttModelKind::kTeleSpeechCtc;
+        } else if (!ctcModelPath.empty()) {
+            selected = SttModelKind::kZipformerCtc;
+        }
+    }
+
+    if (selected == SttModelKind::kUnknown) {
+        result.error = "No compatible model type detected in " + modelDir;
+        return result;
+    }
+
+    result.selectedKind = selected;
+    result.tokensRequired = (selected != SttModelKind::kFunAsrNano);
+
+    if (selected == SttModelKind::kTransducer || selected == SttModelKind::kNemoTransducer) {
+        result.paths.encoder = encoderPath;
+        result.paths.decoder = decoderPath;
+        result.paths.joiner = joinerPath;
+    } else if (selected == SttModelKind::kParaformer) {
+        result.paths.paraformerModel = paraformerModelPath;
+    } else if (selected == SttModelKind::kNemoCtc || selected == SttModelKind::kWenetCtc ||
+               selected == SttModelKind::kSenseVoice || selected == SttModelKind::kZipformerCtc) {
+        result.paths.ctcModel = ctcModelPath;
+    } else if (selected == SttModelKind::kWhisper) {
+        result.paths.whisperEncoder = encoderPath;
+        result.paths.whisperDecoder = decoderPath;
+    } else if (selected == SttModelKind::kFunAsrNano) {
+        result.paths.funasrEncoderAdaptor = funasrEncoderAdaptor;
+        result.paths.funasrLLM = funasrLLM;
+        result.paths.funasrEmbedding = funasrEmbedding;
+        result.paths.funasrTokenizer = funasrTokenizerDir;
+    } else if (selected == SttModelKind::kMoonshine) {
+        result.paths.moonshinePreprocessor = moonshinePreprocess;
+        result.paths.moonshineEncoder = moonshineEncode;
+        result.paths.moonshineUncachedDecoder = moonshineUncachedDecode;
+        result.paths.moonshineCachedDecoder = moonshineCachedDecode;
+    } else if (selected == SttModelKind::kDolphin) {
+        result.paths.dolphinModel = ctcModelPath.empty() ? paraformerModelPath : ctcModelPath;
+    } else if (selected == SttModelKind::kFireRedAsr) {
+        result.paths.fireRedEncoder = encoderPath;
+        result.paths.fireRedDecoder = decoderPath;
+    } else if (selected == SttModelKind::kCanary) {
+        result.paths.canaryEncoder = encoderPath;
+        result.paths.canaryDecoder = decoderPath;
+    } else if (selected == SttModelKind::kOmnilingual) {
+        result.paths.omnilingualModel = ctcModelPath;
+    } else if (selected == SttModelKind::kMedAsr) {
+        result.paths.medasrModel = ctcModelPath;
+    } else if (selected == SttModelKind::kTeleSpeechCtc) {
+        result.paths.telespeechCtcModel = ctcModelPath.empty() ? paraformerModelPath : ctcModelPath;
+    }
+
+    if (!tokensPath.empty() && FileExists(tokensPath)) {
+        result.paths.tokens = tokensPath;
+    } else if (result.tokensRequired) {
+        result.error = "Tokens file not found in " + modelDir;
+        return result;
+    }
+
+    result.ok = true;
+    return result;
+}
+
+} // namespace sherpaonnx