react-native-sherpa-onnx 0.3.0 → 0.3.2

package/ios/SherpaOnnx+OnlineSTT.mm

@@ -0,0 +1,365 @@
+/**
+ * SherpaOnnx+OnlineSTT.mm
+ *
+ * Purpose: iOS TurboModule methods for streaming (online) STT: initializeOnlineSttWithOptions,
+ * createSttStream, acceptSttWaveform, decodeSttStream, getSttStreamResult, etc.
+ * Uses sherpa-onnx-online-stt-wrapper for native OnlineRecognizer.
+ */
+
+#import "SherpaOnnx.h"
+#import <React/RCTLog.h>
+
+#include "sherpa-onnx-online-stt-wrapper.h"
+#include <memory>
+#include <mutex>
+#include <string>
+#include <unordered_map>
+
+static std::unordered_map<std::string, std::unique_ptr<sherpaonnx::OnlineSttWrapper>> g_online_stt_instances;
+static std::unordered_map<std::string, std::string> g_online_stt_stream_to_instance;
+static std::mutex g_online_stt_mutex;
+
+static sherpaonnx::OnlineSttWrapper* getOnlineSttInstance(NSString* instanceId) {
+    if (instanceId == nil || [instanceId length] == 0) return nullptr;
+    std::string key = [instanceId UTF8String];
+    std::lock_guard<std::mutex> lock(g_online_stt_mutex);
+    auto it = g_online_stt_instances.find(key);
+    return (it != g_online_stt_instances.end() && it->second != nullptr) ? it->second.get() : nullptr;
+}
+
+static sherpaonnx::OnlineSttWrapper* getOnlineSttInstanceForStream(NSString* streamId) {
+    if (streamId == nil || [streamId length] == 0) return nullptr;
+    std::string streamIdStr = [streamId UTF8String];
+    std::lock_guard<std::mutex> lock(g_online_stt_mutex);
+    auto sit = g_online_stt_stream_to_instance.find(streamIdStr);
+    if (sit == g_online_stt_stream_to_instance.end()) return nullptr;
+    auto it = g_online_stt_instances.find(sit->second);
+    return (it != g_online_stt_instances.end() && it->second != nullptr) ? it->second.get() : nullptr;
+}
+
+
+@implementation SherpaOnnx (OnlineSTT)
+
+- (void)initializeOnlineSttWithOptions:(NSString *)instanceId
+                               options:(JS::NativeSherpaOnnx::SpecInitializeOnlineSttWithOptionsOptions &)options
+                               resolve:(RCTPromiseResolveBlock)resolve
+                                reject:(RCTPromiseRejectBlock)reject
+{
+    if (instanceId == nil || [instanceId length] == 0) {
+        reject(@"INIT_ERROR", @"instanceId is required", nil);
+        return;
+    }
+    NSString *modelDir = options.modelDir();
+    NSString *modelType = options.modelType();
+    RCTLogInfo(@"[SherpaOnnx OnlineSTT] initializeOnlineSttWithOptions instanceId=%@ modelDir=%@ modelType=%@",
+               instanceId, modelDir, modelType);
+    if (modelDir == nil || [modelDir length] == 0) {
+        reject(@"INIT_ERROR", @"modelDir is required", nil);
+        return;
+    }
+    std::string instanceIdStr = [instanceId UTF8String];
+    std::string modelDirStr = [modelDir UTF8String];
+    std::string modelTypeStr = (modelType != nil && [modelType length] > 0) ? [modelType UTF8String] : "transducer";
+
+    auto enableEndpoint = options.enableEndpoint();
+    NSString *decodingMethod = options.decodingMethod();
+    auto maxActivePaths = options.maxActivePaths();
+    NSString *hotwordsFile = options.hotwordsFile();
+    auto hotwordsScore = options.hotwordsScore();
+    auto numThreads = options.numThreads();
+    NSString *provider = options.provider();
+    NSString *ruleFsts = options.ruleFsts();
+    NSString *ruleFars = options.ruleFars();
+    auto blankPenalty = options.blankPenalty();
+    auto debug = options.debug();
+    auto rule1MustContainNonSilence = options.rule1MustContainNonSilence();
+    auto rule1MinTrailingSilence = options.rule1MinTrailingSilence();
+    auto rule1MinUtteranceLength = options.rule1MinUtteranceLength();
+    auto rule2MustContainNonSilence = options.rule2MustContainNonSilence();
+    auto rule2MinTrailingSilence = options.rule2MinTrailingSilence();
+    auto rule2MinUtteranceLength = options.rule2MinUtteranceLength();
+    auto rule3MustContainNonSilence = options.rule3MustContainNonSilence();
+    auto rule3MinTrailingSilence = options.rule3MinTrailingSilence();
+    auto rule3MinUtteranceLength = options.rule3MinUtteranceLength();
+
+    @try {
+        std::lock_guard<std::mutex> lock(g_online_stt_mutex);
+        if (g_online_stt_instances.find(instanceIdStr) != g_online_stt_instances.end()) {
+            reject(@"INIT_ERROR", @"Online STT instance already exists", nil);
+            return;
+        }
+        RCTLogInfo(@"[SherpaOnnx OnlineSTT] creating wrapper and calling initialize");
+        auto wrapper = std::make_unique<sherpaonnx::OnlineSttWrapper>();
+        sherpaonnx::OnlineSttInitResult result = wrapper->initialize(
+            modelDirStr,
+            modelTypeStr,
+            enableEndpoint.has_value() && enableEndpoint.value(),
+            decodingMethod != nil ? [decodingMethod UTF8String] : "greedy_search",
+            maxActivePaths.has_value() ? (int32_t)maxActivePaths.value() : 4,
+            hotwordsFile != nil ? [hotwordsFile UTF8String] : "",
+            hotwordsScore.has_value() ? (float)hotwordsScore.value() : 1.5f,
+            numThreads.has_value() ? (int32_t)numThreads.value() : 1,
+            provider != nil ? [provider UTF8String] : "cpu",
+            ruleFsts != nil ? [ruleFsts UTF8String] : "",
+            ruleFars != nil ? [ruleFars UTF8String] : "",
+            blankPenalty.has_value() ? (float)blankPenalty.value() : 0.f,
+            debug.has_value() && debug.value(),
+            rule1MustContainNonSilence.has_value() && rule1MustContainNonSilence.value(),
+            rule1MinTrailingSilence.has_value() ? (float)rule1MinTrailingSilence.value() : 2.4f,
+            rule1MinUtteranceLength.has_value() ? (float)rule1MinUtteranceLength.value() : 0.f,
+            rule2MustContainNonSilence.has_value() && rule2MustContainNonSilence.value(),
+            rule2MinTrailingSilence.has_value() ? (float)rule2MinTrailingSilence.value() : 1.2f,
+            rule2MinUtteranceLength.has_value() ? (float)rule2MinUtteranceLength.value() : 0.f,
+            rule3MustContainNonSilence.has_value() && rule3MustContainNonSilence.value(),
+            rule3MinTrailingSilence.has_value() ? (float)rule3MinTrailingSilence.value() : 0.f,
+            rule3MinUtteranceLength.has_value() ? (float)rule3MinUtteranceLength.value() : 20.f
+        );
+        if (!result.success) {
+            RCTLogError(@"[SherpaOnnx OnlineSTT] initialize failed: %s", result.error.c_str());
+            reject(@"INIT_ERROR", [NSString stringWithUTF8String:result.error.c_str()], nil);
+            return;
+        }
+        g_online_stt_instances[instanceIdStr] = std::move(wrapper);
+        RCTLogInfo(@"[SherpaOnnx OnlineSTT] init success for instanceId=%@", instanceId);
+        resolve(@{ @"success": @YES });
+    } @catch (NSException *exception) {
+        NSString *errorMsg = [NSString stringWithFormat:@"Online STT init failed: %@", exception.reason];
+        RCTLogError(@"%@", errorMsg);
+        reject(@"INIT_ERROR", errorMsg, nil);
+    }
+}
+
+- (void)createSttStream:(NSString *)instanceId
+              streamId:(NSString *)streamId
+              hotwords:(NSString *)hotwords
+               resolve:(RCTPromiseResolveBlock)resolve
+                reject:(RCTPromiseRejectBlock)reject
+{
+    sherpaonnx::OnlineSttWrapper* wrapper = getOnlineSttInstance(instanceId);
+    if (wrapper == nullptr) {
+        reject(@"STREAM_ERROR", @"Online STT instance not found", nil);
+        return;
+    }
+    std::string instanceIdStr = [instanceId UTF8String];
+    std::string streamIdStr = [streamId UTF8String];
+    std::string hotwordsStr = hotwords != nil ? [hotwords UTF8String] : "";
+    if (!wrapper->createStream(streamIdStr, hotwordsStr)) {
+        reject(@"STREAM_ERROR", @"Stream already exists or create failed", nil);
+        return;
+    }
+    std::lock_guard<std::mutex> lock(g_online_stt_mutex);
+    g_online_stt_stream_to_instance[streamIdStr] = instanceIdStr;
+    resolve(nil);
+}
+
+- (void)acceptSttWaveform:(NSString *)streamId
+                  samples:(NSArray *)samples
+               sampleRate:(double)sampleRate
+                  resolve:(RCTPromiseResolveBlock)resolve
+                   reject:(RCTPromiseRejectBlock)reject
+{
+    sherpaonnx::OnlineSttWrapper* wrapper = getOnlineSttInstanceForStream(streamId);
+    if (wrapper == nullptr) {
+        reject(@"STREAM_ERROR", @"Stream not found", nil);
+        return;
+    }
+    std::vector<float> floatSamples;
+    floatSamples.reserve([samples count]);
+    for (NSNumber* n in samples) {
+        floatSamples.push_back([n floatValue]);
+    }
+    std::string streamIdStr = [streamId UTF8String];
+    wrapper->acceptWaveform(streamIdStr, (int32_t)sampleRate, floatSamples.data(), floatSamples.size());
+    resolve(nil);
+}
+
+- (void)sttStreamInputFinished:(NSString *)streamId
+                       resolve:(RCTPromiseResolveBlock)resolve
+                        reject:(RCTPromiseRejectBlock)reject
+{
+    sherpaonnx::OnlineSttWrapper* wrapper = getOnlineSttInstanceForStream(streamId);
+    if (wrapper == nullptr) {
+        reject(@"STREAM_ERROR", @"Stream not found", nil);
+        return;
+    }
+    std::string streamIdStr = [streamId UTF8String];
+    wrapper->inputFinished(streamIdStr);
+    resolve(nil);
+}
+
+- (void)decodeSttStream:(NSString *)streamId
+                resolve:(RCTPromiseResolveBlock)resolve
+                 reject:(RCTPromiseRejectBlock)reject
+{
+    sherpaonnx::OnlineSttWrapper* wrapper = getOnlineSttInstanceForStream(streamId);
+    if (wrapper == nullptr) {
+        reject(@"STREAM_ERROR", @"Stream not found", nil);
+        return;
+    }
+    std::string streamIdStr = [streamId UTF8String];
+    wrapper->decode(streamIdStr);
+    resolve(nil);
+}
+
+- (void)isSttStreamReady:(NSString *)streamId
+                 resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject
+{
+    sherpaonnx::OnlineSttWrapper* wrapper = getOnlineSttInstanceForStream(streamId);
+    if (wrapper == nullptr) {
+        reject(@"STREAM_ERROR", @"Stream not found", nil);
+        return;
+    }
+    std::string streamIdStr = [streamId UTF8String];
+    BOOL ready = wrapper->isReady(streamIdStr);
+    resolve(@(ready));
+}
+
+- (void)getSttStreamResult:(NSString *)streamId
+                   resolve:(RCTPromiseResolveBlock)resolve
+                    reject:(RCTPromiseRejectBlock)reject
+{
+    sherpaonnx::OnlineSttWrapper* wrapper = getOnlineSttInstanceForStream(streamId);
+    if (wrapper == nullptr) {
+        reject(@"STREAM_ERROR", @"Stream not found", nil);
+        return;
+    }
+    std::string streamIdStr = [streamId UTF8String];
+    sherpaonnx::OnlineSttStreamResult r = wrapper->getResult(streamIdStr);
+    NSMutableArray* tokens = [NSMutableArray arrayWithCapacity:r.tokens.size()];
+    for (const auto& t : r.tokens) {
+        [tokens addObject:[NSString stringWithUTF8String:t.c_str()]];
+    }
+    NSMutableArray* timestamps = [NSMutableArray arrayWithCapacity:r.timestamps.size()];
+    for (float ts : r.timestamps) {
+        [timestamps addObject:@(ts)];
+    }
+    resolve(@{
+        @"text": [NSString stringWithUTF8String:r.text.c_str()] ?: @"",
+        @"tokens": tokens,
+        @"timestamps": timestamps
+    });
+}
+
+- (void)isSttStreamEndpoint:(NSString *)streamId
+                    resolve:(RCTPromiseResolveBlock)resolve
+                     reject:(RCTPromiseRejectBlock)reject
+{
+    sherpaonnx::OnlineSttWrapper* wrapper = getOnlineSttInstanceForStream(streamId);
+    if (wrapper == nullptr) {
+        reject(@"STREAM_ERROR", @"Stream not found", nil);
+        return;
+    }
+    std::string streamIdStr = [streamId UTF8String];
+    BOOL endpoint = wrapper->isEndpoint(streamIdStr);
+    resolve(@(endpoint));
+}
+
+- (void)resetSttStream:(NSString *)streamId
+               resolve:(RCTPromiseResolveBlock)resolve
+                reject:(RCTPromiseRejectBlock)reject
+{
+    sherpaonnx::OnlineSttWrapper* wrapper = getOnlineSttInstanceForStream(streamId);
+    if (wrapper == nullptr) {
+        reject(@"STREAM_ERROR", @"Stream not found", nil);
+        return;
+    }
+    std::string streamIdStr = [streamId UTF8String];
+    wrapper->resetStream(streamIdStr);
+    resolve(nil);
+}
+
+- (void)releaseSttStream:(NSString *)streamId
+                 resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject
+{
+    sherpaonnx::OnlineSttWrapper* wrapper = getOnlineSttInstanceForStream(streamId);
+    std::string streamIdStr = [streamId UTF8String];
+    if (wrapper != nullptr) {
+        wrapper->releaseStream(streamIdStr);
+    }
+    {
+        std::lock_guard<std::mutex> lock(g_online_stt_mutex);
+        g_online_stt_stream_to_instance.erase(streamIdStr);
+    }
+    resolve(nil);
+}
+
+- (void)unloadOnlineStt:(NSString *)instanceId
+                resolve:(RCTPromiseResolveBlock)resolve
+                 reject:(RCTPromiseRejectBlock)reject
+{
+    if (instanceId == nil || [instanceId length] == 0) {
+        resolve(nil);
+        return;
+    }
+    std::string key = [instanceId UTF8String];
+    @try {
+        std::lock_guard<std::mutex> lock(g_online_stt_mutex);
+        auto it = g_online_stt_instances.find(key);
+        if (it != g_online_stt_instances.end()) {
+            it->second->unload();
+            for (auto sit = g_online_stt_stream_to_instance.begin(); sit != g_online_stt_stream_to_instance.end(); ) {
+                if (sit->second == key) sit = g_online_stt_stream_to_instance.erase(sit);
+                else ++sit;
+            }
+            g_online_stt_instances.erase(it);
+        }
+        resolve(nil);
+    } @catch (NSException *exception) {
+        reject(@"RELEASE_ERROR", [NSString stringWithFormat:@"unloadOnlineStt failed: %@", exception.reason], nil);
+    }
+}
+
+- (void)processSttAudioChunk:(NSString *)streamId
+                     samples:(NSArray *)samples
+                  sampleRate:(double)sampleRate
+                     resolve:(RCTPromiseResolveBlock)resolve
+                      reject:(RCTPromiseRejectBlock)reject
+{
+    sherpaonnx::OnlineSttWrapper* wrapper = getOnlineSttInstanceForStream(streamId);
+    if (wrapper == nullptr) {
+        reject(@"STREAM_ERROR", @"Stream not found", nil);
+        return;
+    }
+    std::string streamIdStr = [streamId UTF8String];
+    std::vector<float> floatSamples;
+    NSUInteger count = [samples count];
+    floatSamples.reserve(count);
+    for (NSUInteger i = 0; i < count; i++) {
+        id obj = [samples objectAtIndex:i];
+        float val = 0.0f;
+        if ([obj isKindOfClass:[NSNumber class]]) {
+            val = [(NSNumber *)obj floatValue];
+        } else if ([obj respondsToSelector:@selector(doubleValue)]) {
+            val = (float)[(id)obj doubleValue];
+        }
+        floatSamples.push_back(val);
+    }
+    if (floatSamples.empty()) {
+        RCTLogWarn(@"[SherpaOnnx OnlineSTT] processSttAudioChunk: no samples (count=%lu)", (unsigned long)count);
+    }
+
+    wrapper->acceptWaveform(streamIdStr, (int32_t)sampleRate, floatSamples.data(), floatSamples.size());
+    while (wrapper->isReady(streamIdStr)) {
+        wrapper->decode(streamIdStr);
+    }
+    sherpaonnx::OnlineSttStreamResult r = wrapper->getResult(streamIdStr);
+    BOOL isEndpoint = wrapper->isEndpoint(streamIdStr);
+    NSMutableArray* tokens = [NSMutableArray arrayWithCapacity:r.tokens.size()];
+    for (const auto& t : r.tokens) {
+        [tokens addObject:[NSString stringWithUTF8String:t.c_str()]];
+    }
+    NSMutableArray* timestamps = [NSMutableArray arrayWithCapacity:r.timestamps.size()];
+    for (float ts : r.timestamps) {
+        [timestamps addObject:@(ts)];
+    }
+    resolve(@{
+        @"text": [NSString stringWithUTF8String:r.text.c_str()] ?: @"",
+        @"tokens": tokens,
+        @"timestamps": timestamps,
+        @"isEndpoint": @(isEndpoint)
+    });
+}
+
+@end

package/ios/SherpaOnnx+TTS.mm

@@ -515,10 +515,11 @@ std::vector<std::string> SplitTtsTokens(const std::string &text) {
 }
 
 - (void)generateTtsStream:(NSString *)instanceId
-                    text:(NSString *)text
+                requestId:(NSString *)requestId
+                     text:(NSString *)text
                   options:(NSDictionary *)options
-             resolve:(RCTPromiseResolveBlock)resolve
-             reject:(RCTPromiseRejectBlock)reject
+                  resolve:(RCTPromiseResolveBlock)resolve
+                   reject:(RCTPromiseRejectBlock)reject
 {
     if (instanceId == nil || [instanceId length] == 0) {
         reject(@"TTS_STREAM_ERROR", @"instanceId is required", nil);
@@ -551,6 +552,7 @@ std::vector<std::string> SplitTtsTokens(const std::string &text) {
     std::string textStr = [text UTF8String];
     int32_t sampleRate = instRef->wrapper->getSampleRate();
     NSString *instanceIdCopy = [instanceId copy];
+    NSString *requestIdCopy = (requestId != nil && [requestId length] > 0) ? [requestId copy] : nil;
 
     __weak SherpaOnnx *weakSelf = self;
     dispatch_async(dispatch_get_global_queue(QOS_CLASS_USER_INITIATED, 0), ^{
@@ -560,7 +562,7 @@ std::vector<std::string> SplitTtsTokens(const std::string &text) {
                 textStr,
                 static_cast<int32_t>(sid),
                 static_cast<float>(speed),
-                [weakSelf, sampleRate, instanceIdCopy, instRef](const float *samples, int32_t numSamples, float progress) -> int32_t {
+                [weakSelf, sampleRate, instanceIdCopy, requestIdCopy, instRef](const float *samples, int32_t numSamples, float progress) -> int32_t {
                     if (instRef->streamCancelled.load()) {
                         return 0;
                     }
@@ -570,13 +572,14 @@ std::vector<std::string> SplitTtsTokens(const std::string &text) {
                         [samplesArray addObject:@(samples[i])];
                     }
 
-                    NSDictionary *payload = @{
+                    NSMutableDictionary *payload = [NSMutableDictionary dictionaryWithDictionary:@{
                         @"instanceId": instanceIdCopy,
                         @"samples": samplesArray,
                         @"sampleRate": @(sampleRate),
                         @"progress": @(progress),
                         @"isFinal": @NO
-                    };
+                    }];
+                    if (requestIdCopy != nil) payload[@"requestId"] = requestIdCopy;
 
                     dispatch_async(dispatch_get_main_queue(), ^{
                         if (weakSelf) {
@@ -589,25 +592,48 @@ std::vector<std::string> SplitTtsTokens(const std::string &text) {
             );
         } @catch (NSException *exception) {
             NSString *errorMsg = [NSString stringWithFormat:@"TTS streaming failed: %@", exception.reason];
+            NSMutableDictionary *errPayload = [NSMutableDictionary dictionaryWithDictionary:@{ @"instanceId": instanceIdCopy, @"message": errorMsg }];
+            if (requestIdCopy != nil) errPayload[@"requestId"] = requestIdCopy;
             dispatch_async(dispatch_get_main_queue(), ^{
                 if (weakSelf) {
-                    [weakSelf sendEventWithName:@"ttsStreamError" body:@{ @"instanceId": instanceIdCopy, @"message": errorMsg }];
+                    [weakSelf sendEventWithName:@"ttsStreamError" body:errPayload];
                 }
             });
         }
 
         bool cancelled = instRef->streamCancelled.load();
         if (!success && !cancelled) {
+            NSMutableDictionary *errPayload = [NSMutableDictionary dictionaryWithDictionary:@{ @"instanceId": instanceIdCopy, @"message": @"TTS streaming generation failed" }];
+            if (requestIdCopy != nil) errPayload[@"requestId"] = requestIdCopy;
+            dispatch_async(dispatch_get_main_queue(), ^{
+                if (weakSelf) {
+                    [weakSelf sendEventWithName:@"ttsStreamError" body:errPayload];
+                }
+            });
+        }
+
+        // Emit final chunk (empty, progress 1, isFinal YES) when not cancelled, matching Android behaviour
+        if (!cancelled) {
+            NSMutableDictionary *finalPayload = [NSMutableDictionary dictionaryWithDictionary:@{
+                @"instanceId": instanceIdCopy,
+                @"samples": @[],
+                @"sampleRate": @(sampleRate),
+                @"progress": @1.0f,
+                @"isFinal": @YES
+            }];
+            if (requestIdCopy != nil) finalPayload[@"requestId"] = requestIdCopy;
             dispatch_async(dispatch_get_main_queue(), ^{
                 if (weakSelf) {
-                    [weakSelf sendEventWithName:@"ttsStreamError" body:@{ @"instanceId": instanceIdCopy, @"message": @"TTS streaming generation failed" }];
+                    [weakSelf sendEventWithName:@"ttsStreamChunk" body:finalPayload];
                 }
             });
         }
 
+        NSMutableDictionary *endPayload = [NSMutableDictionary dictionaryWithDictionary:@{ @"instanceId": instanceIdCopy, @"cancelled": @(cancelled) }];
+        if (requestIdCopy != nil) endPayload[@"requestId"] = requestIdCopy;
         dispatch_async(dispatch_get_main_queue(), ^{
             if (weakSelf) {
-                [weakSelf sendEventWithName:@"ttsStreamEnd" body:@{ @"instanceId": instanceIdCopy, @"cancelled": @(cancelled) }];
+                [weakSelf sendEventWithName:@"ttsStreamEnd" body:endPayload];
             }
         });
 

package/ios/SherpaOnnx.mm

@@ -22,6 +22,12 @@
     return @"SherpaOnnx";
 }
 
+- (instancetype)init
+{
+    self = [super initWithDisabledObservation];
+    return self;
+}
+
 - (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
     (const facebook::react::ObjCTurboModule::InitParams &)params
 {

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

@@ -43,6 +43,9 @@ std::string FindLargestOnnxExcludingTokens(
     const std::vector<std::string>& excludeTokens
 );
 
+/** Returns true if \p word appears in \p haystack as a standalone token (surrounded by separators: / - _ . space). */
+bool ContainsWord(const std::string& haystack, const std::string& word);
+
 } // namespace model_detect
 } // namespace sherpaonnx
 

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

@@ -156,6 +156,22 @@ std::string FindFileByName(const std::string& baseDir, const std::string& fileNa
     return "";
 }
 
+bool ContainsWord(const std::string& haystack, const std::string& word) {
+    if (word.empty()) return false;
+    size_t pos = 0;
+    auto isSep = [](char c) {
+        return c == '\0' || c == '/' || c == '-' || c == '_' || c == '.' || c == ' ';
+    };
+    while ((pos = haystack.find(word, pos)) != std::string::npos) {
+        char before = (pos == 0) ? '\0' : haystack[pos - 1];
+        size_t afterPos = pos + word.size();
+        char after = (afterPos >= haystack.size()) ? '\0' : haystack[afterPos];
+        if (isSep(before) && isSep(after)) return true;
+        pos++;
+    }
+    return false;
+}
+
 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);

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

@@ -32,6 +32,7 @@ SttModelKind ParseSttModelType(const std::string& modelType) {
     if (modelType == "omnilingual") return SttModelKind::kOmnilingual;
     if (modelType == "medasr") return SttModelKind::kMedAsr;
     if (modelType == "telespeech_ctc") return SttModelKind::kTeleSpeechCtc;
+    if (modelType == "tone_ctc") return SttModelKind::kToneCtc;
     return SttModelKind::kUnknown;
 }
 
@@ -118,6 +119,10 @@ SttDetectResult DetectSttModel(
     bool isLikelyOmnilingual = modelDirLower.find("omnilingual") != std::string::npos;
     bool isLikelyMedAsr = modelDirLower.find("medasr") != std::string::npos;
     bool isLikelyTeleSpeech = modelDirLower.find("telespeech") != std::string::npos;
+    // Tone CTC: match "tone" only as standalone word (not e.g. "cantonese"); also accept "t-one" / "t_one"
+    bool isLikelyToneCtc = modelDirLower.find("t-one") != std::string::npos ||
+                           modelDirLower.find("t_one") != std::string::npos ||
+                           ContainsWord(modelDirLower, "tone");
 
     bool hasMoonshine = !moonshinePreprocess.empty() && !moonshineUncachedDecode.empty() &&
                         !moonshineCachedDecode.empty() && !moonshineEncode.empty();
@@ -127,6 +132,7 @@ SttDetectResult DetectSttModel(
     bool hasOmnilingual = !ctcModelPath.empty() && isLikelyOmnilingual;
     bool hasMedAsr = !ctcModelPath.empty() && isLikelyMedAsr;
     bool hasTeleSpeechCtc = (!ctcModelPath.empty() || !paraformerModelPath.empty()) && isLikelyTeleSpeech;
+    bool hasToneCtc = !ctcModelPath.empty() && isLikelyToneCtc;
 
     if (hasTransducer) {
         if (isLikelyNemo || isLikelyTdt) {
@@ -178,6 +184,9 @@ SttDetectResult DetectSttModel(
     if (hasTeleSpeechCtc) {
         result.detectedModels.push_back({"telespeech_ctc", modelDir});
     }
+    if (hasToneCtc) {
+        result.detectedModels.push_back({"tone_ctc", modelDir});
+    }
 
     SttModelKind selected = SttModelKind::kUnknown;
 
@@ -201,7 +210,8 @@ SttDetectResult DetectSttModel(
             return result;
         }
         if ((selected == SttModelKind::kNemoCtc || selected == SttModelKind::kWenetCtc ||
-             selected == SttModelKind::kSenseVoice || selected == SttModelKind::kZipformerCtc) &&
+             selected == SttModelKind::kSenseVoice || selected == SttModelKind::kZipformerCtc ||
+             selected == SttModelKind::kToneCtc) &&
             ctcModelPath.empty()) {
             result.error = "CTC model requested but model.onnx not found in " + modelDir;
             return result;
@@ -242,6 +252,10 @@ SttDetectResult DetectSttModel(
             result.error = "TeleSpeech CTC model requested but model not found in " + modelDir;
             return result;
         }
+        if (selected == SttModelKind::kToneCtc && !hasToneCtc) {
+            result.error = "Tone CTC model requested but path does not contain 'tone' (as a word), 't-one', or 't_one' (e.g. sherpa-onnx-streaming-t-one-*) in " + modelDir;
+            return result;
+        }
     } else {
         if (hasTransducer) {
             selected = (isLikelyNemo || isLikelyTdt) ? SttModelKind::kNemoTransducer : SttModelKind::kTransducer;
@@ -279,6 +293,8 @@ SttDetectResult DetectSttModel(
             selected = SttModelKind::kMedAsr;
         } else if (hasTeleSpeechCtc) {
             selected = SttModelKind::kTeleSpeechCtc;
+        } else if (hasToneCtc) {
+            selected = SttModelKind::kToneCtc;
         } else if (!ctcModelPath.empty()) {
             selected = SttModelKind::kZipformerCtc;
         }
@@ -299,7 +315,8 @@ SttDetectResult DetectSttModel(
     } else if (selected == SttModelKind::kParaformer) {
         result.paths.paraformerModel = paraformerModelPath;
     } else if (selected == SttModelKind::kNemoCtc || selected == SttModelKind::kWenetCtc ||
-               selected == SttModelKind::kSenseVoice || selected == SttModelKind::kZipformerCtc) {
+               selected == SttModelKind::kSenseVoice || selected == SttModelKind::kZipformerCtc ||
+               selected == SttModelKind::kToneCtc) {
         result.paths.ctcModel = ctcModelPath;
     } else if (selected == SttModelKind::kWhisper) {
         result.paths.whisperEncoder = encoderPath;

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

@@ -25,7 +25,8 @@ enum class SttModelKind {
     kCanary,
     kOmnilingual,
     kMedAsr,
-    kTeleSpeechCtc
+    kTeleSpeechCtc,
+    kToneCtc
 };
 
 enum class TtsModelKind {