Address PR review feedback on nemotron samples

- C++: Use explicit little-endian PCM encoding for portability
- C++: Continue on TryGetNext timeout with max-retry guard
- Rust: Safe-access r.content via .first() to avoid panic on empty
- Rust: Add sleep pacing in --synth mode for realistic ingestion
- Rust: Update README run instructions (crate not in workspace)
- Rust: Add SDK availability note in README
- Python: Add exception handling in capture_mic thread
- Python: Add SDK availability note in header comment

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: ruiren_microsoft

samples/cpp/live-audio-transcription-example/main.cpp

@@ -19,15 +19,15 @@
 namespace {
 std::vector<uint8_t> GenerateSineWavePcm(int sampleRate, int durationSeconds, double frequencyHz) {
     const auto totalSamples = static_cast<size_t>(sampleRate * durationSeconds);
-    std::vector<uint8_t> pcm(totalSamples * 2, 0); // 16-bit mono
+    std::vector<uint8_t> pcm(totalSamples * 2, 0); // 16-bit mono, little-endian
 
     for (size_t i = 0; i < totalSamples; ++i) {
         const double t = static_cast<double>(i) / static_cast<double>(sampleRate);
         const auto sample = static_cast<int16_t>(
             static_cast<double>(INT16_MAX) * 0.5 * std::sin(2.0 * 3.14159265358979323846 * frequencyHz * t));
-        const auto b = reinterpret_cast<const uint8_t*>(&sample);
-        pcm[i * 2] = b[0];
-        pcm[i * 2 + 1] = b[1];
+        const auto encodedSample = static_cast<uint16_t>(sample);
+        pcm[i * 2] = static_cast<uint8_t>(encodedSample & 0xFF);
+        pcm[i * 2 + 1] = static_cast<uint8_t>((encodedSample >> 8) & 0xFF);
     }
     return pcm;
 }
@@ -68,16 +68,22 @@ int main() {
         }
 
         foundry_local::LiveAudioTranscriptionResponse result;
+        int consecutiveTimeouts = 0;
+        const int maxConsecutiveTimeouts = 10; // 5 seconds of silence
         while (true) {
             const auto status = session->TryGetNext(result, std::chrono::milliseconds(500));
             if (status == foundry_local::TranscriptionStatus::Result) {
+                consecutiveTimeouts = 0;
                 if (result.is_final) {
                     std::cout << "\n[FINAL] " << result.text << std::endl;
                 } else {
                     std::cout << result.text << std::flush;
                 }
             } else if (status == foundry_local::TranscriptionStatus::Timeout) {
-                break;
+                if (++consecutiveTimeouts >= maxConsecutiveTimeouts) {
+                    break; // No more results after extended wait
+                }
+                continue; // Engine may still be processing buffered audio
             } else if (status == foundry_local::TranscriptionStatus::Closed) {
                 break;
             } else {

samples/python/live-audio-transcription/src/app.py

@@ -1,5 +1,9 @@
 # Live Audio Transcription — Foundry Local SDK Example (Python)
 #
+# NOTE: The live-transcription session API (create_live_transcription_session)
+# is not yet available in the Python SDK. This sample is a forward-looking
+# reference and will not run until the API is added to the SDK.
+#
 # Demonstrates real-time microphone-to-text using:
 #   SDK (FoundryLocalManager) → Core (NativeAOT DLL) → onnxruntime-genai (StreamingProcessor)
 #
@@ -84,9 +88,14 @@ def read_results():
 
 def capture_mic():
     while not stop_recording.is_set():
-        pcm_data = stream.read(chunk, exception_on_overflow=False)
-        if pcm_data:
-            session.append(pcm_data)
+        try:
+            pcm_data = stream.read(chunk, exception_on_overflow=False)
+            if pcm_data:
+                session.append(pcm_data)
+        except Exception as e:
+            print(f"\n[ERROR] Microphone capture failed: {e}")
+            stop_recording.set()
+            break
 
 
 capture_thread = threading.Thread(target=capture_mic, daemon=True)

samples/rust/live-audio-transcription-example/README.md

@@ -3,15 +3,20 @@
 This sample demonstrates real-time microphone transcription using the Foundry Local Rust SDK and the `nemotron` model.
 
 > This example requires a Rust SDK version that includes `create_live_transcription_session`.
+> The live-transcription session API is not yet available in the Rust SDK (`sdk/rust`).
+> This sample is included as a forward-looking reference and will not compile until
+> the API is added. It is intentionally excluded from the workspace `Cargo.toml`.
 
 ## Run
 
 ```bash
-cargo run -p live-audio-transcription-example
+cd samples/rust/live-audio-transcription-example
+cargo run
 ```
 
 Use synthetic audio instead of a microphone:
 
 ```bash
-cargo run -p live-audio-transcription-example -- --synth
+cd samples/rust/live-audio-transcription-example
+cargo run -- --synth
 ```

samples/rust/live-audio-transcription-example/src/main.rs

@@ -52,13 +52,15 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         while let Some(result) = stream.next().await {
             match result {
                 Ok(r) => {
-                    let text = &r.content[0].text;
-                    if r.is_final {
-                        println!();
-                        println!("  [FINAL] {text}");
-                    } else if !text.is_empty() {
-                        print!("{text}");
-                        io::stdout().flush().ok();
+                    if let Some(content) = r.content.first() {
+                        let text = &content.text;
+                        if r.is_final {
+                            println!();
+                            println!("  [FINAL] {text}");
+                        } else if !text.is_empty() {
+                            print!("{text}");
+                            io::stdout().flush().ok();
+                        }
                     }
                 }
                 Err(e) => {
@@ -72,9 +74,11 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     if use_synth {
         let pcm_data = generate_sine_wave_pcm(16000, 3, 440.0);
         let chunk_size = 16000 / 10 * 2;
+        let chunk_interval = std::time::Duration::from_millis(100);
         for offset in (0..pcm_data.len()).step_by(chunk_size) {
             let end = std::cmp::min(offset + chunk_size, pcm_data.len());
             session.append(&pcm_data[offset..end], None).await?;
+            tokio::time::sleep(chunk_interval).await;
         }
     } else {
         let host = cpal::default_host();