Add JavaScript async api for OfflineRecongizer decodeStream. (k2-fsa#3049)

This pull request enhances the sherpa-onnx-node JavaScript bindings by introducing an asynchronous API for offline speech recognition stream decoding. By leveraging Node.js NAPI's AsyncWorker, the decodeStream operation can now be performed in a non-blocking manner, allowing for concurrent processing of multiple audio streams. This significantly improves application responsiveness, especially for batch processing or scenarios where the main thread needs to remain unblocked.

Author: csukuangfj

.github/scripts/test-nodejs-npm.sh

@@ -15,6 +15,10 @@ rm sherpa-onnx-funasr-nano-int8-2025-12-30.tar.bz2
 
 node ./test-offline-funasr-nano.js
 
+echo "---async---"
+
+node ./test-offline-funasr-nano_async.js
+
 rm -rf sherpa-onnx-funasr-nano-int8-2025-12-30
 
 curl -SL -O https://github.com/k2-fsa/sherpa-onnx/releases/download/asr-models/sherpa-onnx-medasr-ctc-en-int8-2025-12-25.tar.bz2

harmony-os/SherpaOnnxHar/sherpa_onnx/src/main/cpp/non-streaming-asr.cc

@@ -632,6 +632,74 @@ static void OfflineRecognizerSetConfigWrapper(const Napi::CallbackInfo &info) {
   FreeConfig(c);
 }
 
+class DecodeOfflineStreamAsyncWorker : public Napi::AsyncWorker {
+ public:
+  DecodeOfflineStreamAsyncWorker(Napi::Env env,
+                                 const SherpaOnnxOfflineRecognizer *recognizer,
+                                 const SherpaOnnxOfflineStream *stream,
+                                 Napi::Promise::Deferred deferred)
+      : Napi::AsyncWorker(env),
+        recognizer_(recognizer),
+        stream_(stream),
+        deferred_(deferred) {}
+
+  void Execute() override {
+    try {
+      SherpaOnnxDecodeOfflineStream(recognizer_, stream_);
+    } catch (const std::exception &e) {
+      SetError(e.what());
+    }
+  }
+
+  void OnOK() override {
+    const char *json = SherpaOnnxGetOfflineStreamResultAsJson(stream_);
+    Napi::String s = Napi::String::New(Env(), json);
+    SherpaOnnxDestroyOfflineStreamResultJson(json);
+    deferred_.Resolve(s);
+  }
+
+  void OnError(const Napi::Error &e) override { deferred_.Reject(e.Value()); }
+
+ private:
+  const SherpaOnnxOfflineRecognizer *recognizer_;
+  const SherpaOnnxOfflineStream *stream_;
+  Napi::Promise::Deferred deferred_;
+};
+
+static Napi::Value DecodeOfflineStreamAsyncWrapper(
+    const Napi::CallbackInfo &info) {
+  Napi::Env env = info.Env();
+
+  if (info.Length() != 2) {
+    std::ostringstream os;
+    os << "Expect 2 arguments. Given: " << info.Length();
+    Napi::TypeError::New(env, os.str()).ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  if (!info[0].IsExternal() || !info[1].IsExternal()) {
+    Napi::TypeError::New(env,
+                         "Expected recognizer and stream as external pointers")
+        .ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  const SherpaOnnxOfflineRecognizer *recognizer =
+      info[0].As<Napi::External<SherpaOnnxOfflineRecognizer>>().Data();
+
+  const SherpaOnnxOfflineStream *stream =
+      info[1].As<Napi::External<SherpaOnnxOfflineStream>>().Data();
+
+  Napi::Promise::Deferred deferred = Napi::Promise::Deferred::New(env);
+
+  auto *worker =
+      new DecodeOfflineStreamAsyncWorker(env, recognizer, stream, deferred);
+
+  worker->Queue();
+
+  return deferred.Promise();
+}
+
 static void DecodeOfflineStreamWrapper(const Napi::CallbackInfo &info) {
   Napi::Env env = info.Env();
   if (info.Length() != 2) {
@@ -710,6 +778,9 @@ void InitNonStreamingAsr(Napi::Env env, Napi::Object exports) {
   exports.Set(Napi::String::New(env, "decodeOfflineStream"),
               Napi::Function::New(env, DecodeOfflineStreamWrapper));
 
+  exports.Set(Napi::String::New(env, "decodeOfflineStreamAsync"),
+              Napi::Function::New(env, DecodeOfflineStreamAsyncWrapper));
+
   exports.Set(Napi::String::New(env, "offlineRecognizerSetConfig"),
               Napi::Function::New(env, OfflineRecognizerSetConfigWrapper));
 

nodejs-addon-examples/README.md

@@ -128,6 +128,7 @@ The following tables list the examples in this folder.
 |[./test_asr_non_streaming_omnilingual_asr_ctc.js](./test_asr_non_streaming_omnilingual_asr_ctc.js)|Non-streaming speech recognition from a file using a [Omnilingual-ASR](https://github.com/facebookresearch/omnilingual-asr) CTC model with greedy search|
 |[./test_asr_non_streaming_medasr_ctc.js](./test_asr_non_streaming_medasr_ctc.js)|Non-streaming speech recognition from a file using a [Google MedASR](https://github.com/google-health/medasr) CTC model with greedy search|
 |[./test_asr_non_streaming_funasr_nano.js](./test_asr_non_streaming_funasr_nano.js)|Non-streaming speech recognition from a file using a [FunASR Nano](https://modelscope.cn/models/FunAudioLLM/Fun-ASR-Nano-2512) model|
+|[./test_asr_non_streaming_funasr_nano_async.js](./test_asr_non_streaming_funasr_nano_async.js)|Async non-streaming speech recognition from multiple files using a [FunASR Nano](https://modelscope.cn/models/FunAudioLLM/Fun-ASR-Nano-2512) model|
 |[./test_asr_non_streaming_nemo_canary.js](./test_asr_non_streaming_nemo_canary.js)|Non-streaming speech recognition from a file using a [NeMo](https://github.com/NVIDIA/NeMo) [Canary](https://k2-fsa.github.io/sherpa/onnx/nemo/canary.html#sherpa-onnx-nemo-canary-180m-flash-en-es-de-fr-int8-english-spanish-german-french) model|
 |[./test_asr_non_streaming_zipformer_ctc.js](./test_asr_non_streaming_zipformer_ctc.js)|Non-streaming speech recognition from a file using a Zipformer CTC model with greedy search|
 |[./test_asr_non_streaming_nemo_parakeet_tdt_v2.js](./test_asr_non_streaming_nemo_parakeet_tdt_v2.js)|Non-streaming speech recognition from a file using a [NeMo](https://github.com/NVIDIA/NeMo) [parakeet-tdt-0.6b-v2](https://k2-fsa.github.io/sherpa/onnx/pretrained_models/offline-transducer/nemo-transducer-models.html#sherpa-onnx-nemo-parakeet-tdt-0-6b-v2-int8-english) model with greedy search|
@@ -430,6 +431,16 @@ npm install naudiodon2
 node ./test_vad_asr_non_streaming_nemo_ctc_microphone.js
 ```
 
+### Asynchronous non-streaming speech recognition with FunASR Nano models
+
+```bash
+wget https://github.com/k2-fsa/sherpa-onnx/releases/download/asr-models/sherpa-onnx-funasr-nano-int8-2025-12-30.tar.bz2
+tar xvf sherpa-onnx-funasr-nano-int8-2025-12-30.tar.bz2
+rm sherpa-onnx-funasr-nano-int8-2025-12-30.tar.bz2
+
+node ./test_asr_non_streaming_funasr_nano_async.js
+```
+
 ### Non-streaming speech recognition with FunASR Nano models
 
 ```bash

nodejs-addon-examples/test_asr_non_streaming_funasr_nano_async.js

@@ -0,0 +1,65 @@
+// Copyright (c)  2026  Xiaomi Corporation
+//  This file shows how to use the async API to decode multiple files
+const path = require('path');
+const sherpa_onnx = require('sherpa-onnx-node');
+
+/**
+ * Create an OfflineRecognizer with FunASR Nano model.
+ */
+function createRecognizer(modelDir, numThreads = 2, debug = 1) {
+  const config = {
+    featConfig: {
+      sampleRate: 16000,
+      featureDim: 80,
+    },
+    modelConfig: {
+      funasrNano: {
+        encoderAdaptor: path.join(modelDir, 'encoder_adaptor.int8.onnx'),
+        llm: path.join(modelDir, 'llm.int8.onnx'),
+        embedding: path.join(modelDir, 'embedding.int8.onnx'),
+        tokenizer: path.join(modelDir, 'Qwen3-0.6B'),
+      },
+      tokens: '',
+      numThreads,
+      provider: 'cpu',
+      debug,
+    },
+  };
+
+  return new sherpa_onnx.OfflineRecognizer(config);
+}
+
+/**
+ * Read a waveform and create a stream for decoding.
+ */
+function createStreamFromFile(recognizer, file) {
+  const wave = sherpa_onnx.readWave(file);
+  const stream = recognizer.createStream();
+  stream.acceptWaveform({sampleRate: wave.sampleRate, samples: wave.samples});
+  return stream;
+}
+
+async function main() {
+  const modelDir = './sherpa-onnx-funasr-nano-int8-2025-12-30';
+  const recognizer = createRecognizer(modelDir);
+
+  const testFiles = [
+    'test_wavs/lyrics_en_1.wav',
+    'test_wavs/lyrics_en_2.wav',
+    'test_wavs/lyrics_en_3.wav',
+  ].map(f => path.join(modelDir, f));
+
+  // Create streams for each file
+  const streams = testFiles.map(file => createStreamFromFile(recognizer, file));
+
+  // Decode all streams concurrently
+  const results =
+      await Promise.all(streams.map(stream => recognizer.decodeAsync(stream)));
+
+  console.log('Concurrent decode results:');
+  testFiles.forEach((file, i) => {
+    console.log(`${file}: ${results[i].text}`);
+  });
+}
+
+main().catch(console.error);

scripts/node-addon-api/lib/non-streaming-asr.js

@@ -1,7 +1,11 @@
 /** @typedef {import('./types').OfflineStreamObject} OfflineStreamObject */
 /** @typedef {import('./types').Waveform} Waveform */
-/** @typedef {import('./types').OfflineRecognizerConfig} OfflineRecognizerConfig */
-/** @typedef {import('./types').OfflineRecognizerResult} OfflineRecognizerResult */
+/**
+ * @typedef {import('./types').OfflineRecognizerConfig} OfflineRecognizerConfig
+ */
+/**
+ * @typedef {import('./types').OfflineRecognizerResult} OfflineRecognizerResult
+ */
 
 const addon = require('./addon.js');
 
@@ -10,7 +14,8 @@ const addon = require('./addon.js');
  */
 class OfflineStream {
   /**
-   * @param {OfflineStreamObject|Object} handle - Internal stream object with `handle` property.
+   * @param {OfflineStreamObject|Object} handle - Internal stream object with
+   *     `handle` property.
    */
   constructor(handle) {
     this.handle = handle;
@@ -62,6 +67,17 @@ class OfflineRecognizer {
     addon.decodeOfflineStream(this.handle, stream.handle);
   }
 
+  /**
+   * Decode an offline stream asynchronously (non-blocking).
+   * @param {OfflineStream} stream
+   * @returns {Promise<OfflineRecognizerResult>}
+   */
+  async decodeAsync(stream) {
+    const jsonStr =
+        await addon.decodeOfflineStreamAsync(this.handle, stream.handle);
+    return JSON.parse(jsonStr);
+  }
+
   /**
    * Get recognition result for a stream.
    * @param {OfflineStream} stream