Move vocab_log_probs into result structs per reviewer feedback

- Add vocab_log_probs and vocab_size fields to both
  SherpaOnnxOnlineRecognizerResult and SherpaOnnxOfflineRecognizerResult,
  following the same pattern as timestamps
- Remove the separate SherpaOnnxVocabLogProbs struct and its getter/destroy
  functions from the C API
- Update Dart bindings to read vocab_log_probs from the result struct via
  recognizer.getVocabLogProbs(stream) instead of stream.getVocabLogProbs()

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: Dokotela

flutter/sherpa_onnx/lib/src/offline_recognizer.dart

@@ -1313,6 +1313,29 @@ class OfflineRecognizer {
     SherpaOnnxBindings.decodeOfflineStream?.call(ptr, stream.ptr);
   }
 
+  /// Fetch the full vocabulary log-probability distributions for [stream].
+  ///
+  /// Returns a list of lists, where each inner list is the log-probability
+  /// distribution over the vocabulary for one emitted token.  Returns `null`
+  /// if no vocab_log_probs are available.
+  List<List<double>>? getVocabLogProbs(OfflineStream stream) {
+    final getFunc = SherpaOnnxBindings.getOfflineStreamResult;
+    final destroyFunc = SherpaOnnxBindings.destroyOfflineRecognizerResult;
+    if (getFunc == null || destroyFunc == null) return null;
+
+    if (ptr == nullptr || stream.ptr == nullptr) return null;
+
+    final resultPtr = getFunc(stream.ptr);
+    if (resultPtr == nullptr) return null;
+
+    final ref = resultPtr.ref;
+    final probs = readVocabLogProbsFromResult(
+        ref.vocabLogProbs, ref.count, ref.vocabSize);
+
+    destroyFunc(resultPtr);
+    return probs;
+  }
+
   /// Fetch the current recognition result for [stream].
   OfflineRecognizerResult getResult(OfflineStream stream) {
     if (SherpaOnnxBindings.getOfflineStreamResultAsJson == null) {

flutter/sherpa_onnx/lib/src/offline_stream.dart

@@ -56,14 +56,6 @@ class OfflineStream {
     calloc.free(p);
   }
 
-  List<List<double>>? getVocabLogProbs() {
-    final getFunc = SherpaOnnxBindings.getOfflineStreamVocabLogProbs;
-    final destroyFunc = SherpaOnnxBindings.destroyVocabLogProbs;
-    if (getFunc == null || destroyFunc == null) return null;
-
-    return readAndFreeVocabLogProbs(getFunc(ptr), destroyFunc);
-  }
-
   /// Set a string option on the underlying stream.
   void setOption({required String key, required String value}) {
     if (SherpaOnnxBindings.offlineStreamSetOption == null) {

flutter/sherpa_onnx/lib/src/online_recognizer.dart

@@ -607,6 +607,29 @@ class OnlineRecognizer {
     );
   }
 
+  /// Fetch the full vocabulary log-probability distributions for [stream].
+  ///
+  /// Returns a list of lists, where each inner list is the log-probability
+  /// distribution over the vocabulary for one emitted token.  Returns `null`
+  /// if no vocab_log_probs are available.
+  List<List<double>>? getVocabLogProbs(OnlineStream stream) {
+    final getFunc = SherpaOnnxBindings.getOnlineStreamResult;
+    final destroyFunc = SherpaOnnxBindings.destroyOnlineRecognizerResult;
+    if (getFunc == null || destroyFunc == null) return null;
+
+    if (ptr == nullptr || stream.ptr == nullptr) return null;
+
+    final resultPtr = getFunc(ptr, stream.ptr);
+    if (resultPtr == nullptr) return null;
+
+    final ref = resultPtr.ref;
+    final probs = readVocabLogProbsFromResult(
+        ref.vocabLogProbs, ref.count, ref.vocabSize);
+
+    destroyFunc(resultPtr);
+    return probs;
+  }
+
   /// Reset stream state after an endpoint or utterance boundary.
   void reset(OnlineStream stream) {
     if (SherpaOnnxBindings.reset == null) {

flutter/sherpa_onnx/lib/src/online_stream.dart

@@ -67,13 +67,5 @@ class OnlineStream {
     SherpaOnnxBindings.onlineStreamInputFinished?.call(ptr);
   }
 
-  List<List<double>>? getVocabLogProbs() {
-    final getFunc = SherpaOnnxBindings.getOnlineStreamVocabLogProbs;
-    final destroyFunc = SherpaOnnxBindings.destroyVocabLogProbs;
-    if (getFunc == null || destroyFunc == null) return null;
-
-    return readAndFreeVocabLogProbs(getFunc(ptr), destroyFunc);
-  }
-
   Pointer<SherpaOnnxOnlineStream> ptr;
 }

flutter/sherpa_onnx/lib/src/sherpa_onnx_bindings.dart

@@ -824,44 +824,59 @@ final class SherpaOnnxSpokenLanguageIdentificationResult extends Struct {
 
 final class SherpaOnnxSpokenLanguageIdentification extends Opaque {}
 
-final class SherpaOnnxVocabLogProbs extends Struct {
-  // Flattened 2D array
-  external Pointer<Float> logProbs;
-
+/// FFI struct for the online recognizer result (mirrors C API struct layout).
+final class SherpaOnnxOnlineRecognizerResultNative extends Struct {
+  external Pointer<Utf8> text;
+  external Pointer<Utf8> tokens;
+  external Pointer<Pointer<Utf8>> tokensArr;
+  external Pointer<Float> timestamps;
+  @Int32()
+  external int count;
+  external Pointer<Utf8> json;
+  external Pointer<Float> vocabLogProbs;
   @Int32()
-  external int numTokens;
+  external int vocabSize;
+}
 
+/// FFI struct for the offline recognizer result (mirrors C API struct layout).
+final class SherpaOnnxOfflineRecognizerResultNative extends Struct {
+  external Pointer<Utf8> text;
+  external Pointer<Float> timestamps;
+  @Int32()
+  external int count;
+  external Pointer<Utf8> tokens;
+  external Pointer<Pointer<Utf8>> tokensArr;
+  external Pointer<Utf8> json;
+  external Pointer<Utf8> lang;
+  external Pointer<Utf8> emotion;
+  external Pointer<Utf8> event;
+  external Pointer<Float> durations;
+  external Pointer<Float> ysLogProbs;
+  external Pointer<Float> segmentTimestamps;
+  external Pointer<Float> segmentDurations;
+  external Pointer<Utf8> segmentTexts;
+  external Pointer<Pointer<Utf8>> segmentTextsArr;
+  @Int32()
+  external int segmentCount;
+  external Pointer<Float> vocabLogProbs;
   @Int32()
   external int vocabSize;
 }
 
-/// Read a native [SherpaOnnxVocabLogProbs] pointer into a Dart list-of-lists
-/// and free the native memory via [destroyFunc].  Returns `null` when
-/// [vocabPtr] is null or the sizes look invalid.
-List<List<double>>? readAndFreeVocabLogProbs(
-  Pointer<SherpaOnnxVocabLogProbs> vocabPtr,
-  void Function(Pointer<SherpaOnnxVocabLogProbs>) destroyFunc,
+/// Read vocab_log_probs from a native result struct into a Dart list-of-lists.
+/// Returns `null` when vocab_log_probs is null or sizes are invalid.
+List<List<double>>? readVocabLogProbsFromResult(
+  Pointer<Float> vocabLogProbs,
+  int count,
+  int vocabSize,
 ) {
-  if (vocabPtr == nullptr) {
-    return null;
-  }
-
-  final ref = vocabPtr.ref;
-  final numTokens = ref.numTokens;
-  final vocabSize = ref.vocabSize;
-
-  if (numTokens <= 0 || vocabSize <= 0 ||
-      numTokens > 10000 || vocabSize > 100000) {
-    destroyFunc(vocabPtr);
+  if (vocabLogProbs == nullptr || count <= 0 || vocabSize <= 0) {
     return null;
   }
 
-  final flat = ref.logProbs.asTypedList(numTokens * vocabSize);
-  final result = List.generate(numTokens, (i) =>
+  final flat = vocabLogProbs.asTypedList(count * vocabSize);
+  return List.generate(count, (i) =>
       List<double>.generate(vocabSize, (j) => flat[i * vocabSize + j]));
-
-  destroyFunc(vocabPtr);
-  return result;
 }
 
 final class SherpaOnnxOfflineSpeechDenoiser extends Opaque {}
@@ -1886,19 +1901,24 @@ typedef SherpaOnnxGetGitSha1 = SherpaOnnxGetGitSha1Native;
 typedef SherpaOnnxGetGitDateNative = Pointer<Utf8> Function();
 typedef SherpaOnnxGetGitDate = SherpaOnnxGetGitDateNative;
 
-typedef SherpaOnnxOnlineStreamGetVocabLogProbsNative
-    = Pointer<SherpaOnnxVocabLogProbs> Function(
+typedef SherpaOnnxGetOnlineStreamResultNative
+    = Pointer<SherpaOnnxOnlineRecognizerResultNative> Function(
+        Pointer<SherpaOnnxOnlineRecognizer> recognizer,
         Pointer<SherpaOnnxOnlineStream> stream);
 
-typedef SherpaOnnxOfflineStreamGetVocabLogProbsNative
-    = Pointer<SherpaOnnxVocabLogProbs> Function(
-        Pointer<SherpaOnnxOfflineStream> stream);
+typedef SherpaOnnxDestroyOnlineRecognizerResultNative = Void Function(
+    Pointer<SherpaOnnxOnlineRecognizerResultNative> r);
+typedef SherpaOnnxDestroyOnlineRecognizerResultDart = void Function(
+    Pointer<SherpaOnnxOnlineRecognizerResultNative> r);
 
-typedef SherpaOnnxDestroyVocabLogProbsNative = Void Function(
-    Pointer<SherpaOnnxVocabLogProbs> logProbs);
+typedef SherpaOnnxGetOfflineStreamResultNative
+    = Pointer<SherpaOnnxOfflineRecognizerResultNative> Function(
+        Pointer<SherpaOnnxOfflineStream> stream);
 
-typedef SherpaOnnxDestroyVocabLogProbsDart = void Function(
-    Pointer<SherpaOnnxVocabLogProbs>);
+typedef SherpaOnnxDestroyOfflineRecognizerResultNative = Void Function(
+    Pointer<SherpaOnnxOfflineRecognizerResultNative> r);
+typedef SherpaOnnxDestroyOfflineRecognizerResultDart = void Function(
+    Pointer<SherpaOnnxOfflineRecognizerResultNative> r);
 
 class SherpaOnnxBindings {
   static SherpaOnnxCreateOfflineSpeechDenoiser?
@@ -2141,11 +2161,12 @@ class SherpaOnnxBindings {
   static SherpaOnnxGetGitSha1? getGitSha1;
   static SherpaOnnxGetGitDate? getGitDate;
 
-  static SherpaOnnxOnlineStreamGetVocabLogProbsNative?
-      getOnlineStreamVocabLogProbs;
-  static SherpaOnnxOfflineStreamGetVocabLogProbsNative?
-      getOfflineStreamVocabLogProbs;
-  static SherpaOnnxDestroyVocabLogProbsDart? destroyVocabLogProbs;
+  static SherpaOnnxGetOnlineStreamResultNative? getOnlineStreamResult;
+  static SherpaOnnxDestroyOnlineRecognizerResultDart?
+      destroyOnlineRecognizerResult;
+  static SherpaOnnxGetOfflineStreamResultNative? getOfflineStreamResult;
+  static SherpaOnnxDestroyOfflineRecognizerResultDart?
+      destroyOfflineRecognizerResult;
 
   static void init(DynamicLibrary dynamicLibrary) {
     sherpaOnnxCreateOfflineSpeechDenoiser ??= dynamicLibrary
@@ -2921,21 +2942,27 @@ class SherpaOnnxBindings {
         )
         .asFunction();
 
-    getOnlineStreamVocabLogProbs ??= dynamicLibrary
-        .lookup<NativeFunction<SherpaOnnxOnlineStreamGetVocabLogProbsNative>>(
-          'SherpaOnnxOnlineStreamGetVocabLogProbs',
+    getOnlineStreamResult ??= dynamicLibrary
+        .lookup<NativeFunction<SherpaOnnxGetOnlineStreamResultNative>>(
+          'SherpaOnnxGetOnlineStreamResult',
+        )
+        .asFunction();
+
+    destroyOnlineRecognizerResult ??= dynamicLibrary
+        .lookup<NativeFunction<SherpaOnnxDestroyOnlineRecognizerResultNative>>(
+          'SherpaOnnxDestroyOnlineRecognizerResult',
         )
         .asFunction();
 
-    getOfflineStreamVocabLogProbs ??= dynamicLibrary
-        .lookup<NativeFunction<SherpaOnnxOfflineStreamGetVocabLogProbsNative>>(
-          'SherpaOnnxOfflineStreamGetVocabLogProbs',
+    getOfflineStreamResult ??= dynamicLibrary
+        .lookup<NativeFunction<SherpaOnnxGetOfflineStreamResultNative>>(
+          'SherpaOnnxGetOfflineStreamResult',
         )
         .asFunction();
 
-    destroyVocabLogProbs ??= dynamicLibrary
-        .lookup<NativeFunction<SherpaOnnxDestroyVocabLogProbsNative>>(
-          'SherpaOnnxDestroyVocabLogProbs',
+    destroyOfflineRecognizerResult ??= dynamicLibrary
+        .lookup<NativeFunction<SherpaOnnxDestroyOfflineRecognizerResultNative>>(
+          'SherpaOnnxDestroyOfflineRecognizerResult',
         )
         .asFunction();
   }

sherpa-onnx/c-api/c-api.cc

@@ -317,6 +317,22 @@ const SherpaOnnxOnlineRecognizerResult *SherpaOnnxGetOnlineStreamResult(
     r->tokens_arr = nullptr;
   }
 
+  // Copy vocab_log_probs (flattened 2D: count * vocab_size)
+  if (!result.vocab_log_probs.empty() &&
+      static_cast<int32_t>(result.vocab_log_probs.size()) == r->count) {
+    int32_t vocab_size = result.vocab_log_probs[0].size();
+    r->vocab_size = vocab_size;
+    float *flat = new float[r->count * vocab_size];
+    for (int32_t i = 0; i < r->count; ++i) {
+      std::copy(result.vocab_log_probs[i].begin(),
+                result.vocab_log_probs[i].end(), flat + i * vocab_size);
+    }
+    r->vocab_log_probs = flat;
+  } else {
+    r->vocab_log_probs = nullptr;
+    r->vocab_size = 0;
+  }
+
   return r;
 }
 
@@ -328,6 +344,7 @@ void SherpaOnnxDestroyOnlineRecognizerResult(
     delete[] r->tokens;
     delete[] r->tokens_arr;
     delete[] r->timestamps;
+    delete[] r->vocab_log_probs;
     delete r;
   }
 }
@@ -848,6 +865,22 @@ const SherpaOnnxOfflineRecognizerResult *SherpaOnnxGetOfflineStreamResult(
     r->ys_log_probs = nullptr;
   }
 
+  // Copy vocab_log_probs (flattened 2D: count * vocab_size)
+  if (!result.vocab_log_probs.empty() &&
+      static_cast<int32_t>(result.vocab_log_probs.size()) == r->count) {
+    int32_t vocab_size = result.vocab_log_probs[0].size();
+    r->vocab_size = vocab_size;
+    float *flat = new float[r->count * vocab_size];
+    for (int32_t i = 0; i < r->count; ++i) {
+      std::copy(result.vocab_log_probs[i].begin(),
+                result.vocab_log_probs[i].end(), flat + i * vocab_size);
+    }
+    r->vocab_log_probs = flat;
+  } else {
+    r->vocab_log_probs = nullptr;
+    r->vocab_size = 0;
+  }
+
   // Copy segment-level timestamps (from Whisper with segment timestamps)
   auto segment_count = result.segment_texts.size();
   if (segment_count > 0 && result.segment_timestamps.size() == segment_count &&
@@ -911,6 +944,7 @@ void SherpaOnnxDestroyOfflineRecognizerResult(
     delete[] r->segment_durations;
     delete[] r->segment_texts;
     delete[] r->segment_texts_arr;
+    delete[] r->vocab_log_probs;
     delete r;
   }
 }
@@ -931,54 +965,6 @@ void SherpaOnnxDestroyOfflineStreamResultJson(const char *s) {
   delete[] s;
 }
 
-static const SherpaOnnxVocabLogProbs *FlattenVocabLogProbs(
-    const std::vector<std::vector<float>> &vocab_log_probs) {
-  if (vocab_log_probs.empty()) {
-    return nullptr;
-  }
-
-  int32_t num_tokens = vocab_log_probs.size();
-  int32_t vocab_size = vocab_log_probs[0].size();
-
-  auto vocab_probs = new SherpaOnnxVocabLogProbs;
-  vocab_probs->num_tokens = num_tokens;
-  vocab_probs->vocab_size = vocab_size;
-
-  float *flat_probs = new float[num_tokens * vocab_size];
-  for (int32_t i = 0; i < num_tokens; ++i) {
-    if (static_cast<int32_t>(vocab_log_probs[i].size()) != vocab_size) {
-      SHERPA_ONNX_LOGE("vocab_log_probs[%d] size %d != expected %d", i,
-                        static_cast<int32_t>(vocab_log_probs[i].size()),
-                        vocab_size);
-      delete[] flat_probs;
-      delete vocab_probs;
-      return nullptr;
-    }
-    std::copy(vocab_log_probs[i].begin(), vocab_log_probs[i].end(),
-              flat_probs + i * vocab_size);
-  }
-  vocab_probs->log_probs = flat_probs;
-
-  return vocab_probs;
-}
-
-const struct SherpaOnnxVocabLogProbs *SherpaOnnxOnlineStreamGetVocabLogProbs(
-    const SherpaOnnxOnlineStream *stream) {
-  return FlattenVocabLogProbs(stream->impl->GetResult().vocab_log_probs);
-}
-
-const struct SherpaOnnxVocabLogProbs *SherpaOnnxOfflineStreamGetVocabLogProbs(
-    const SherpaOnnxOfflineStream *stream) {
-  return FlattenVocabLogProbs(stream->impl->GetResult().vocab_log_probs);
-}
-
-void SherpaOnnxDestroyVocabLogProbs(
-    const struct SherpaOnnxVocabLogProbs *log_probs) {
-  if (log_probs) {
-    delete[] log_probs->log_probs;
-    delete log_probs;
-  }
-}
 
 // ============================================================
 // For Keyword Spot