update nemo==2.8.0.rc0

nemo/README.md

@@ -0,0 +1,26 @@
+NeMo (**Ne**ural **Mo**dules) is a toolkit for creating AI applications built around **neural modules**, conceptual blocks of neural networks that take *typed* inputs and produce *typed* outputs.
+
+## **collections/**
+* **ASR** - Collection of modules and models for building speech recognition networks.
+* **TTS** - Collection of modules and models for building speech synthesis networks.
+* **Audio** - Collection of modules and models for building audio processing networks.
+* **SpeechLM2** - Collection of modules and models for building multimodal LLM.
+
+## **core/**
+Provides fundamental APIs and utilities for NeMo modules, including:
+- **Classes** - Base classes for datasets, models, and losses.
+- **Config** - Configuration management utilities.
+- **Neural Types** - Typed inputs/outputs for module interaction.
+- **Optim** - Optimizers and learning rate schedulers.
+
+## **lightning/**
+Integration with PyTorch Lightning for training and distributed execution:
+- **Strategies & Plugins** - Custom Lightning strategies.
+- **Fabric** - Lightweight wrapper for model training.
+- **Checkpointing & Logging** - Utilities for managing model states.
+
+## **utils/**
+General utilities for debugging, distributed training, logging, and model management:
+- **callbacks/** - Hooks for training processes.
+- **loggers/** - Logging utilities for different backends.
+- **debugging & profiling** - Performance monitoring tools.

nemo/{collections/diffusion/models → agents}/__init__.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2024, NVIDIA CORPORATION.  All rights reserved.
+# Copyright (c) 2025, NVIDIA CORPORATION.  All rights reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.

nemo/{collections/diffusion/data → agents/voice_agent}/__init__.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2024, NVIDIA CORPORATION.  All rights reserved.
+# Copyright (c) 2025, NVIDIA CORPORATION.  All rights reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.

nemo/{export → agents/voice_agent/pipecat}/__init__.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2024, NVIDIA CORPORATION.  All rights reserved.
+# Copyright (c) 2025, NVIDIA CORPORATION.  All rights reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -12,9 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-
-use_tensorrt = True
 try:
-    from nemo.export.tensorrt_lazy_compiler import trt_compile
-except Exception as e:
-    use_tensorrt = False
+    import pipecat
+except ImportError:
+    raise ImportError("pipecat is not installed. Please install it with `pip install pipecat-ai`.")

nemo/{collections/diffusion/encoders → agents/voice_agent/pipecat/frames}/__init__.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2024, NVIDIA CORPORATION.  All rights reserved.
+# Copyright (c) 2025, NVIDIA CORPORATION.  All rights reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.

nemo/{collections/nlp/data/entity_linking/__init__.py → agents/voice_agent/pipecat/frames/frames.py}

@@ -1,4 +1,4 @@
-# Copyright (c) 2021, NVIDIA CORPORATION.  All rights reserved.
+# Copyright (c) 2025, NVIDIA CORPORATION.  All rights reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -12,4 +12,15 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from nemo.collections.nlp.data.entity_linking.entity_linking_dataset import EntityLinkingDataset
+
+from dataclasses import dataclass
+import numpy as np
+from pipecat.frames.frames import DataFrame
+
+
+@dataclass
+class DiarResultFrame(DataFrame):
+    """Diarization frame."""
+
+    diar_result: np.ndarray | int
+    stream_id: str = "default"

nemo/{collections/diffusion → agents/voice_agent/pipecat/processors}/__init__.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2024, NVIDIA CORPORATION.  All rights reserved.
+# Copyright (c) 2025, NVIDIA CORPORATION.  All rights reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.

nemo/agents/voice_agent/pipecat/processors/frameworks/__init__.py

@@ -0,0 +1,13 @@
+# Copyright (c) 2025, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.

nemo/agents/voice_agent/pipecat/processors/frameworks/rtvi.py

@@ -0,0 +1,72 @@
+# Copyright (c) 2025, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+from loguru import logger
+from pipecat.frames.frames import Frame, LLMFullResponseEndFrame, LLMFullResponseStartFrame, TTSTextFrame
+from pipecat.observers.base_observer import FramePushed
+from pipecat.processors.frameworks.rtvi import (
+    RTVIBotLLMStartedMessage,
+    RTVIBotLLMStoppedMessage,
+    RTVIBotTranscriptionMessage,
+    RTVIBotTTSTextMessage,
+)
+from pipecat.processors.frameworks.rtvi import RTVIObserver as _RTVIObserver
+from pipecat.processors.frameworks.rtvi import RTVIProcessor, RTVITextMessageData
+from pipecat.transports.base_output import BaseOutputTransport
+
+
+class RTVIObserver(_RTVIObserver):
+    """
+    An observer that processes RTVI frames and pushes them to the transport.
+    """
+
+    def __init__(self, rtvi: RTVIProcessor, *args, **kwargs):
+        super().__init__(rtvi, *args, **kwargs)
+
+    async def on_push_frame(self, data: FramePushed):
+        """Process a frame being pushed through the pipeline.
+
+        Args:
+            data: Frame push event data containing source, frame, direction, and timestamp.
+        """
+        src = data.source
+        frame: Frame = data.frame
+
+        if frame.id in self._frames_seen:
+            return
+
+        if not self._params.bot_llm_enabled:
+            if isinstance(frame, LLMFullResponseStartFrame):
+                await self.send_rtvi_message(RTVIBotLLMStartedMessage())
+                self._frames_seen.add(frame.id)
+            elif isinstance(frame, LLMFullResponseEndFrame):
+                await self.send_rtvi_message(RTVIBotLLMStoppedMessage())
+                self._frames_seen.add(frame.id)
+            elif isinstance(frame, TTSTextFrame) and isinstance(src, BaseOutputTransport):
+                message = RTVIBotTTSTextMessage(data=RTVITextMessageData(text=frame.text))
+                await self.send_rtvi_message(message)
+                await self._push_bot_transcription(frame.text)
+                self._frames_seen.add(frame.id)
+            else:
+                await super().on_push_frame(data)
+        else:
+            await super().on_push_frame(data)
+
+    async def _push_bot_transcription(self, text: str):
+        """Push accumulated bot transcription as a message."""
+        if len(text.strip()) > 0:
+            message = RTVIBotTranscriptionMessage(data=RTVITextMessageData(text=text))
+            logger.debug(f"Pushing bot transcription: `{text}`")
+            await self.send_rtvi_message(message)

nemo/agents/voice_agent/pipecat/services/__init__.py

@@ -0,0 +1,13 @@
+# Copyright (c) 2025, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.

nemo/{collections/multimodal/speech_llm → agents/voice_agent/pipecat/services/nemo}/__init__.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2024, NVIDIA CORPORATION.  All rights reserved.
+# Copyright (c) 2025, NVIDIA CORPORATION.  All rights reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -12,4 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from nemo.collections.multimodal.speech_llm import models, modules
+from .diar import NemoDiarService
+from .llm import HuggingFaceLLMService
+from .stt import NemoSTTService
+from .tts import NeMoFastPitchHiFiGANTTSService
+from .turn_taking import NeMoTurnTakingService

nemo/agents/voice_agent/pipecat/services/nemo/audio_logger.py

@@ -0,0 +1,844 @@
+# Copyright (c) 2025, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import json
+import threading
+import wave
+from datetime import datetime
+from pathlib import Path
+from typing import Optional, Union
+
+import librosa
+import numpy as np
+from loguru import logger
+from pipecat.frames.frames import TranscriptionFrame
+from pipecat.observers.base_observer import BaseObserver, FramePushed
+
+
+class AudioLogger:
+    """
+    Utility class for logging audio data and transcriptions during voice agent interactions.
+
+    This logger saves:
+    - Audio files in WAV format
+    - Transcriptions with metadata in JSON format
+    - Session information and metadata
+
+    File structure:
+        log_dir/
+        ├── session_YYYYMMDD_HHMMSS/
+        │   ├── user/
+        │   │   ├── 00001_HHMMSS.wav
+        │   │   ├── 00001_HHMMSS.json
+        │   │   ├── 00002_HHMMSS.wav
+        │   │   └── 00002_HHMMSS.json
+        │   ├── agent/
+        │   │   ├── 00001_HHMMSS.wav
+        │   │   ├── 00001_HHMMSS.json
+        │   └── session_metadata.json
+
+    Args:
+        log_dir: Base directory for storing logs (default: "./audio_logs")
+        session_id: Optional custom session ID. If None, auto-generated from timestamp
+        enabled: Whether logging is enabled (default: True)
+
+    # 12/19/2025 Note: Stereo conversation recording is implemented,
+    # but -0.8 seconds offset needs to be applied to make the session sound synced.
+    """
+
+    def __init__(
+        self,
+        log_dir: Union[str, Path] = "./audio_logs",
+        session_id: Optional[str] = None,
+        enabled: bool = True,
+        user_audio_sample_rate: int = 16000,
+        pre_roll_time_sec: float = 0.8,
+        round_precision: int = 2,
+    ):
+        self.enabled = enabled
+        if not self.enabled:
+            logger.info("[AudioLogger] AudioLogger is disabled")
+            return
+
+        self.log_dir = Path(log_dir)
+
+        # Generate session ID if not provided
+        self.session_start_time = datetime.now()
+        if session_id is None:
+            session_id = f"session_{self.session_start_time.strftime('%Y%m%d_%H%M%S')}"
+        self.first_audio_timestamp = None
+        self.session_id = session_id
+        self.session_dir = self.log_dir / session_id
+
+        # Create directories
+        self.user_dir = self.session_dir / "user"
+        self.agent_dir = self.session_dir / "agent"
+
+        self.user_dir.mkdir(parents=True, exist_ok=True)
+        self.agent_dir.mkdir(parents=True, exist_ok=True)
+
+        # Counters for file naming (thread-safe)
+        self._user_counter = 0
+        self._agent_counter = 0
+        self._turn_index = 0  # Turn index for conversation turns
+        self._current_speaker = None  # Track current speaker for turn transitions
+        self._agent_turn_start_time = None  # Captured when BotStartedSpeakingFrame is received
+        self._lock = threading.Lock()
+        self.staged_metadata = None
+        self._staged_audio_data = None
+        self._pre_roll_time_sec = pre_roll_time_sec
+        self._round_precision = round_precision
+
+        self.turn_audio_buffer = []
+        self.continuous_user_audio_buffer = []
+        self.turn_transcription_buffer = []
+
+        # Stereo conversation recording (left=agent, right=user)
+        self._stereo_conversation_filename = "conversation_stereo.wav"
+        self._stereo_conversation_file = self.session_dir / self._stereo_conversation_filename
+        self._stereo_sample_rate = user_audio_sample_rate  # Use user audio sample rate (downsample agent audio)
+        self._stereo_audio_buffer_left: list = []  # Agent audio (left channel)
+        self._stereo_audio_buffer_right: list = []  # User audio (right channel)
+
+        # Session metadata
+        # agent_entries is a list of lists: each sublist contains segments for one turn
+        # e.g., [[seg1, seg2, seg3], [seg4, seg5], ...]  where each [] is a turn
+        self.session_metadata = {
+            "session_id": session_id,
+            "start_time": self.session_start_time.isoformat(),
+            "user_entries": [],
+            "agent_entries": [],  # List of turns, each turn is a list of segments
+        }
+
+        logger.info(f"[AudioLogger] AudioLogger initialized: {self.session_dir}")
+
+    def append_continuous_user_audio(self, audio_data: bytes):
+        """
+        Append audio data to the continuous user audio buffer for stereo conversation.
+
+        This method should be called for EVERY audio frame received from the user,
+        regardless of VAD state, to record the complete conversation audio.
+
+        Args:
+            audio_data: Raw audio data as bytes
+        """
+        if not self.enabled:
+            return
+
+        self.continuous_user_audio_buffer.append(audio_data)
+
+    def _resample_audio(
+        self,
+        audio_data: Union[bytes, np.ndarray],
+        orig_sr: int,
+        target_sr: int,
+    ) -> np.ndarray:
+        """
+        Resample audio data to a target sample rate using librosa.
+
+        Args:
+            audio_data: Audio data as bytes (int16) or numpy array
+            orig_sr: Original sample rate
+            target_sr: Target sample rate
+
+        Returns:
+            Resampled audio as numpy array (float32)
+        """
+        # Convert bytes to numpy array if needed
+        if isinstance(audio_data, bytes):
+            audio_array = np.frombuffer(audio_data, dtype=np.int16).astype(np.float32) / 32768.0
+        elif audio_data.dtype == np.int16:
+            audio_array = audio_data.astype(np.float32) / 32768.0
+        else:
+            audio_array = audio_data.astype(np.float32)
+
+        # Resample if needed
+        if orig_sr != target_sr:
+            audio_array = librosa.resample(audio_array, orig_sr=orig_sr, target_sr=target_sr)
+
+        return audio_array
+
+    def _append_to_stereo_conversation(
+        self,
+        audio_data: Union[bytes, np.ndarray],
+        channel: str,
+        start_time: float,
+        sample_rate: int,
+    ):
+        """
+        Append audio to the stereo conversation buffer at the correct time position.
+
+        Args:
+            audio_data: Audio data as bytes or numpy array
+            channel: "left" for agent, "right" for user
+            start_time: Start time in seconds from session start
+            sample_rate: Sample rate of the input audio
+        """
+        if not self.enabled:
+            return
+
+        try:
+            # Resample to stereo sample rate if needed
+            audio_float = self._resample_audio(audio_data, sample_rate, self._stereo_sample_rate)
+
+            # Calculate the sample position for this audio
+            start_sample = int(start_time * self._stereo_sample_rate)
+
+            # Get the appropriate buffer
+            if channel == "left":
+                buffer = self._stereo_audio_buffer_left
+            else:
+                buffer = self._stereo_audio_buffer_right
+
+            # Extend buffer with zeros if needed to reach start position
+            current_length = len(buffer)
+            if start_sample > current_length:
+                buffer.extend([0.0] * (start_sample - current_length))
+
+            # Append or overwrite audio samples
+            for i, sample in enumerate(audio_float):
+                pos = start_sample + i
+                if pos < len(buffer):
+                    # Mix with existing audio (in case of overlap)
+                    buffer[pos] = np.clip(buffer[pos] + sample, -1.0, 1.0)
+                else:
+                    buffer.append(sample)
+
+            logger.debug(
+                f"[AudioLogger] Appended {len(audio_float)} samples to {channel} channel "
+                f"at position {start_sample} (buffer now {len(buffer)} samples)"
+            )
+
+        except Exception as e:
+            logger.error(f"[AudioLogger] Error appending to stereo conversation: {e}")
+
+    def save_stereo_conversation(self):
+        """
+        Save the stereo conversation buffer to a WAV file.
+        Left channel = Agent, Right channel = User.
+
+        User audio comes from continuous_user_audio_buffer (not affected by VAD).
+        """
+        if not self.enabled:
+            return
+
+        if not self._stereo_audio_buffer_left and not self.continuous_user_audio_buffer:
+            logger.warning("[AudioLogger] No stereo conversation audio to save")
+            return
+
+        try:
+            # Build right channel (user) from continuous buffer
+            # This is raw bytes at user sample rate, no resampling needed since stereo uses user sample rate
+            if self.continuous_user_audio_buffer:
+                continuous_audio_bytes = b"".join(self.continuous_user_audio_buffer)
+                right_array = np.frombuffer(continuous_audio_bytes, dtype=np.int16).astype(np.float32) / 32768.0
+            else:
+                right_array = np.array([], dtype=np.float32)
+
+            left_array = np.array(self._stereo_audio_buffer_left, dtype=np.float32)
+
+            # Pad the shorter buffer with zeros
+            max_length = max(len(left_array), len(right_array))
+
+            # Pad to same length
+            if len(left_array) < max_length:
+                left_array = np.pad(left_array, (0, max_length - len(left_array)))
+            if len(right_array) < max_length:
+                right_array = np.pad(right_array, (0, max_length - len(right_array)))
+
+            # Create stereo array (interleaved: L, R, L, R, ...)
+            stereo_array = np.column_stack((left_array, right_array))
+
+            # Convert to int16
+            stereo_int16 = (stereo_array * 32767).astype(np.int16)
+
+            # Save as WAV
+            with wave.open(str(self._stereo_conversation_file), 'wb') as wav_file:  # type: ignore[union-attr]
+                wav_file.setnchannels(2)  # Stereo
+                wav_file.setsampwidth(2)  # 16-bit
+                wav_file.setframerate(self._stereo_sample_rate)
+                wav_file.writeframes(stereo_int16.tobytes())
+
+            duration_sec = max_length / self._stereo_sample_rate
+            logger.info(
+                f"[AudioLogger] Saved stereo conversation: {self._stereo_conversation_file} "
+                f"({duration_sec:.2f} seconds, {max_length} samples)"
+            )
+
+        except Exception as e:
+            logger.error(f"[AudioLogger] Error saving stereo conversation: {e}")
+
+    def get_time_from_start_of_session(self, timestamp: datetime = None) -> float:
+        """Get the time from the start of the session to the given datetime string."""
+        # get the time difference in seconds.
+        if self.first_audio_timestamp is None:
+            raise ValueError("First audio timestamp is not set. Aborting time calculation.")
+        time_diff = (timestamp if timestamp else datetime.now()) - self.first_audio_timestamp
+        return time_diff.total_seconds()
+
+    def _get_next_counter(self, speaker: str) -> int:
+        """Get the next counter value for a speaker in a thread-safe manner."""
+        with self._lock:
+            if speaker == "user":
+                self._user_counter += 1
+                return self._user_counter
+            else:
+                self._agent_counter += 1
+                return self._agent_counter
+
+    def increment_turn_index(self, speaker: str = None) -> int:
+        """
+        Increment the turn index if the speaker has changed.
+
+        Args:
+            speaker: "user" or "agent". If provided, only increments
+                    if this is different from the current speaker.
+                    If None, always increments.
+
+        Returns:
+            The current turn index after any increment.
+        """
+        with self._lock:
+            if speaker is None:
+                # Always increment if no speaker specified
+                self._turn_index += 1
+                logger.debug(f"[AudioLogger] Turn index incremented to {self._turn_index}")
+            elif speaker != self._current_speaker:
+                # Only increment if speaker changed
+                self._current_speaker = speaker
+                self._turn_index += 1
+                # Reset agent turn start time when speaker changes
+                if speaker == "agent":
+                    self._agent_turn_start_time = None
+                logger.debug(
+                    f"[AudioLogger] Speaker changed to {speaker}, turn index incremented to {self._turn_index}"
+                )
+            # else: same speaker, no increment
+            return self._turn_index
+
+    def set_agent_turn_start_time(self):
+        """
+        Set the start time for the current agent turn.
+
+        This should be called when BotStartedSpeakingFrame is received,
+        which indicates the audio is actually starting to play (not just generated).
+        This provides more accurate timing than capturing time during TTS generation.
+        """
+        if not self.enabled:
+            return
+
+        # Only set if not already set for this turn
+        if self._agent_turn_start_time is None:
+            self._agent_turn_start_time = self.get_time_from_start_of_session()
+            logger.debug(f"[AudioLogger] Agent turn start time set to {self._agent_turn_start_time:.3f}s")
+
+    def _save_audio_wav(
+        self,
+        audio_data: Union[bytes, np.ndarray],
+        file_path: Path,
+        sample_rate: int,
+        num_channels: int = 1,
+    ):
+        """
+        Save audio data to a WAV file.
+
+        Args:
+            audio_data: Audio data as bytes or numpy array
+            file_path: Path to save the WAV file
+            sample_rate: Audio sample rate in Hz
+            num_channels: Number of audio channels (default: 1)
+        """
+        try:
+            # Convert audio data to bytes if it's a numpy array
+            if isinstance(audio_data, np.ndarray):
+                if audio_data.dtype in [np.float32, np.float64]:
+                    # Convert float [-1, 1] to int16 [-32768, 32767]
+                    audio_data = np.clip(audio_data, -1.0, 1.0)
+                    audio_data = (audio_data * 32767).astype(np.int16)
+                elif audio_data.dtype != np.int16:
+                    audio_data = audio_data.astype(np.int16)
+                audio_bytes = audio_data.tobytes()
+            else:
+                audio_bytes = audio_data
+
+            # Write WAV file
+            with wave.open(str(file_path), 'wb') as wav_file:  # type: ignore[union-attr]
+                wav_file.setnchannels(num_channels)
+                wav_file.setsampwidth(2)  # 16-bit audio
+                wav_file.setframerate(sample_rate)
+                wav_file.writeframes(audio_bytes)
+
+            logger.debug(f"[AudioLogger] Saved audio to {file_path}")
+        except Exception as e:
+            logger.error(f"[AudioLogger] Error saving audio to {file_path}: {e}")
+            raise
+
+    def _save_metadata_json(self, metadata: dict, file_path: Path):
+        """Save metadata to a JSON file."""
+        try:
+            with open(file_path, 'w', encoding='utf-8') as f:
+                json.dump(metadata, f, indent=2, ensure_ascii=False)
+            logger.debug(f"[AudioLogger] Saved metadata to {file_path}")
+        except Exception as e:
+            logger.error(f"[AudioLogger] Error saving metadata to {file_path}: {e}")
+            raise
+
+    def clear_user_audio_buffer(self):
+        """
+        Clear the user audio buffer if the user stopped speaking detected by VAD.
+        """
+        # Clear turn buffers if logging wasn't completed (e.g., no final transcription)
+        if len(self.turn_audio_buffer) > 0 or len(self.turn_transcription_buffer) > 0:
+            logger.debug(
+                "[AudioLogger] Clearing turn audio and transcription buffers due to VAD user stopped speaking"
+            )
+            self.turn_audio_buffer = []
+            self.turn_transcription_buffer = []
+
+    def stage_user_audio(
+        self,
+        timestamp_now: datetime,
+        transcription: str,
+        sample_rate: int = 16000,
+        num_channels: int = 1,
+        is_first_frame: bool = False,
+        is_backchannel: bool = False,
+        additional_metadata: Optional[dict] = None,
+    ) -> Optional[dict]:
+        """
+        Stage user audio metadata and transcription (from STT).
+        This data will be saved when the turn is complete by `save_user_audio` method.
+        Audio data is retrieved from continuous_user_audio_buffer based on timestamps.
+
+        Args:
+            timestamp_now: Timestamp when the audio was received
+            transcription: Transcribed text
+            sample_rate: Audio sample rate in Hz (default: 16000)
+            num_channels: Number of audio channels (default: 1)
+            is_first_frame: Whether this is the first frame of a turn (default: False)
+            is_backchannel: Whether this is a backchannel utterance (default: False)
+            additional_metadata: Additional metadata to include
+
+        Returns:
+            Dictionary with logged file paths, or None if logging is disabled
+        """
+        if not self.enabled:
+            return None
+
+        try:
+            # Get counter and generate filenames
+            counter = self._get_next_counter("user")
+            # timestamp_now = datetime.now()
+            base_name = f"{counter:05d}_{timestamp_now.strftime('%H%M%S')}"
+
+            audio_file = self.user_dir / f"{base_name}.wav"
+            metadata_file = self.user_dir / f"{base_name}.json"
+
+            if is_first_frame or self.staged_metadata is None or "start_time" not in self.staged_metadata:
+                raw_start_time = self.get_time_from_start_of_session(timestamp=timestamp_now)
+                # Apply pre-roll: go back pre_roll_time_sec, but don't go before the last entry's end time
+                pre_roll_start = raw_start_time - self._pre_roll_time_sec
+                if self.session_metadata["user_entries"]:
+                    last_entry_end_time = self.session_metadata["user_entries"][-1]["end_time"]
+                    _start_time = max(pre_roll_start, last_entry_end_time)
+                else:
+                    # No previous entries, just ensure we don't go negative
+                    _start_time = max(pre_roll_start, 0.0)
+            else:
+                # start_time is stored as float (seconds from session start), not ISO string
+                _start_time = self.staged_metadata["start_time"]
+
+            # Make end time into float (seconds from session start)
+            _end_time = self.get_time_from_start_of_session(timestamp=datetime.now())
+            audio_duration_sec = round(_end_time - _start_time, self._round_precision)
+
+            # Prepare metadata (initialize if None to allow update)
+            if self.staged_metadata is None:
+                self.staged_metadata = {}
+            self.staged_metadata.update(
+                {
+                    "base_name": base_name,
+                    "counter": counter,
+                    "turn_index": self._turn_index,
+                    "speaker": "user",
+                    "timestamp": timestamp_now.isoformat(),
+                    "start_time": _start_time,
+                    "end_time": _end_time,
+                    "transcription": transcription,
+                    "audio_file": audio_file.name,
+                    "sample_rate": sample_rate,
+                    "num_channels": num_channels,
+                    "audio_duration_sec": audio_duration_sec,
+                    "is_backchannel": is_backchannel,
+                }
+            )
+
+            if additional_metadata:
+                self.staged_metadata.update(additional_metadata)
+
+            return {
+                "audio_file": str(audio_file),
+                "metadata_file": str(metadata_file),
+                "counter": counter,
+            }
+
+        except Exception as e:
+            logger.error(f"Error logging user audio: {e}")
+            return None
+
+    def stage_turn_audio_and_transcription(
+        self,
+        timestamp_now: datetime,
+        is_first_frame: bool = False,
+        additional_metadata: Optional[dict] = None,
+    ):
+        """
+        Stage the complete turn audio and accumulated transcriptions.
+
+        This method is called when a final transcription is received.
+        It joins all accumulated audio and transcription chunks and stages them together.
+
+        Args:
+            timestamp_now: Timestamp when the audio was received
+            is_first_frame: Whether this is the first frame of a turn (default: False)
+            additional_metadata: Additional metadata to include (e.g., model, backend info)
+        """
+        if not self.turn_audio_buffer or not self.turn_transcription_buffer:
+            logger.debug("[AudioLogger] No audio or transcription to stage")
+            return
+
+        try:
+            complete_transcription = "".join(self.turn_transcription_buffer)
+
+            logger.debug(
+                f"[AudioLogger] Staging a turn with: {len(self.turn_audio_buffer)} audio chunks, "
+                f"{len(self.turn_transcription_buffer)} transcription chunks"
+            )
+
+            metadata = {
+                "num_transcription_chunks": len(self.turn_transcription_buffer),
+                "num_audio_chunks": len(self.turn_audio_buffer),
+            }
+            if additional_metadata:
+                metadata.update(additional_metadata)
+
+            self.stage_user_audio(
+                timestamp_now=timestamp_now,
+                transcription=complete_transcription,
+                sample_rate=self._stereo_sample_rate,
+                num_channels=1,
+                is_first_frame=is_first_frame,
+                additional_metadata=metadata,
+            )
+
+            logger.info(
+                f"[AudioLogger] Staged the audio and transcription for turn: '{complete_transcription[:50]}...'"
+            )
+
+        except Exception as e:
+            logger.warning(f"[AudioLogger] Failed to stage user audio: {e}")
+
+    def save_user_audio(self, is_backchannel: bool = False, float_divisor: float = 32768.0):
+        """Save the user audio to the disk.
+
+        Args:
+            is_backchannel: Whether this audio is a backchannel utterance (default: False)
+        """
+        # Safety check: ensure staged metadata exists and has required fields
+        if self.staged_metadata is None or "base_name" not in self.staged_metadata:
+            # This is expected - multiple TranscriptionFrames may be pushed but only one has audio staged
+            logger.debug("[AudioLogger] No staged metadata to save (this is normal for multiple frame pushes)")
+            return
+
+        try:
+            # Add backchannel metadata (only set if not already True to preserve turn-taking detection)
+            if is_backchannel or not self.staged_metadata.get("is_backchannel", False):
+                self.staged_metadata["is_backchannel"] = is_backchannel
+
+            audio_file = self.user_dir / f"{self.staged_metadata['base_name']}.wav"
+            metadata_file = self.user_dir / f"{self.staged_metadata['base_name']}.json"
+
+            # Get the audio data from continuous user audio buffer
+            stt, end = self.staged_metadata["start_time"], self.staged_metadata["end_time"]
+            continuous_audio_bytes = b"".join(self.continuous_user_audio_buffer)
+            full_audio_array = np.frombuffer(continuous_audio_bytes, dtype=np.int16).astype(np.float32) / float_divisor
+            start_idx = int(stt * self._stereo_sample_rate)
+            end_idx = int(end * self._stereo_sample_rate)
+            staged_audio_data = full_audio_array[start_idx:end_idx]
+
+            self._save_audio_wav(
+                audio_data=staged_audio_data,
+                file_path=audio_file,
+                sample_rate=self.staged_metadata["sample_rate"],
+            )
+
+            self._save_metadata_json(metadata=self.staged_metadata, file_path=metadata_file)
+            backchannel_label = " [BACKCHANNEL]" if is_backchannel else ""
+            transcription_preview = self.staged_metadata['transcription'][:50]
+            ellipsis = '...' if len(self.staged_metadata['transcription']) > 50 else ''
+            logger.info(
+                f"[AudioLogger] Saved user audio #{self.staged_metadata['counter']}"
+                f"{backchannel_label}: '{transcription_preview}{ellipsis}'"
+            )
+
+            # Note: User audio for stereo conversation is handled via continuous_user_audio_buffer
+            # which is populated in append_continuous_user_audio() (not affected by VAD)
+
+            # Update session metadata
+            with self._lock:
+                self.session_metadata["user_entries"].append(self.staged_metadata)
+                self._save_session_metadata()
+
+            self.clear_user_audio_buffer()
+
+            # Clear staged data after successful save
+            self.staged_metadata = None
+            self._staged_audio_data = None
+        except Exception as e:
+            logger.error(f"[AudioLogger] Error saving user audio: {e}")
+            raise
+
+    def log_agent_audio(
+        self,
+        audio_data: Union[bytes, np.ndarray],
+        text: str,
+        sample_rate: int = 22050,
+        num_channels: int = 1,
+        additional_metadata: Optional[dict] = None,
+        tts_generation_time: Optional[float] = None,
+    ) -> Optional[dict]:
+        """
+        Log agent audio and text (from TTS).
+
+        Args:
+            audio_data: Generated audio data as bytes or numpy array
+            text: Input text that was synthesized
+            sample_rate: Audio sample rate in Hz (default: 22050)
+            num_channels: Number of audio channels (default: 1)
+            additional_metadata: Additional metadata to include
+            tts_generation_time: Time when TTS generation started (seconds from session start).
+                                Used to calculate actual start_time for first segment of a turn.
+
+        Returns:
+            Dictionary with logged file paths, or None if logging is disabled
+        """
+        if not self.enabled:
+            return None
+
+        try:
+            # Get counter and generate filenames
+            counter = self._get_next_counter("agent")
+            timestamp_now = datetime.now()
+            base_name = f"{counter:05d}_{timestamp_now.strftime('%H%M%S')}"
+
+            audio_file = self.agent_dir / f"{base_name}.wav"
+            metadata_file = self.agent_dir / f"{base_name}.json"
+
+            # Save audio
+            self._save_audio_wav(audio_data, audio_file, sample_rate, num_channels)
+
+            # Calculate audio duration
+            audio_duration_sec = (
+                len(audio_data) / (sample_rate * num_channels * 2)
+                if isinstance(audio_data, bytes)
+                else len(audio_data) / sample_rate
+            )
+
+            # Determine start_time based on previous segment in the same turn
+            # If this is the first segment of the turn, use tts_generation_time
+            # Otherwise, use the previous segment's end_time for sequential playback
+            start_time = None
+            with self._lock:
+                agent_entries = self.session_metadata["agent_entries"]
+                # agent_entries is a list of turns, each turn is a list of segments
+                if agent_entries and agent_entries[-1]:  # If there's a current turn with segments
+                    last_segment = agent_entries[-1][-1]  # Last segment of last turn
+                    if last_segment["turn_index"] == self._turn_index:
+                        # Same turn - start after previous segment ends
+                        start_time = last_segment["end_time"]
+
+            if start_time is None:
+                # First segment of the turn - use agent_turn_start_time (from BotStartedSpeakingFrame)
+                # This is more accurate than tts_generation_time as it reflects actual playback start
+                if self._agent_turn_start_time is not None:
+                    start_time = self._agent_turn_start_time
+                elif tts_generation_time is not None:
+                    # Fallback to tts_generation_time if agent_turn_start_time not set
+                    start_time = tts_generation_time
+                else:
+                    start_time = self.get_time_from_start_of_session(timestamp=timestamp_now)
+
+            end_time = start_time + audio_duration_sec
+
+            # Prepare metadata
+            # cutoff_time is None by default (no interruption)
+            # It will be set by set_agent_cutoff_time() if TTS is interrupted
+            metadata = {
+                "base_name": base_name,
+                "counter": counter,
+                "turn_index": self._turn_index,
+                "speaker": "agent",
+                "timestamp": timestamp_now.isoformat(),
+                "start_time": round(start_time, self._round_precision),
+                "end_time": round(end_time, self._round_precision),
+                "cutoff_time": None,  # None means not interrupted; float if interrupted
+                "text": text,
+                "audio_file": audio_file.name,
+                "sample_rate": sample_rate,
+                "num_channels": num_channels,
+                "audio_duration_sec": round(audio_duration_sec, self._round_precision),
+            }
+
+            if additional_metadata:
+                metadata.update(additional_metadata)
+
+            # Save metadata
+            self._save_metadata_json(metadata, metadata_file)
+
+            # Append to stereo conversation (left channel = agent)
+            self._append_to_stereo_conversation(
+                audio_data=audio_data,
+                channel="left",
+                start_time=start_time,
+                sample_rate=sample_rate,
+            )
+
+            # Update session metadata
+            # agent_entries is a list of turns, each turn is a list of segments
+            with self._lock:
+                agent_entries = self.session_metadata["agent_entries"]
+                # Check if we need to start a new turn or append to existing turn
+                if not agent_entries or agent_entries[-1][-1]["turn_index"] != self._turn_index:
+                    # Start a new turn (new sublist)
+                    agent_entries.append([metadata])
+                else:
+                    # Append to current turn
+                    agent_entries[-1].append(metadata)
+                self._save_session_metadata()
+
+            logger.info(f"[AudioLogger] Logged agent audio #{counter}: '{text[:50]}{'...' if len(text) > 50 else ''}'")
+
+            return {
+                "audio_file": str(audio_file),
+                "metadata_file": str(metadata_file),
+                "counter": counter,
+            }
+
+        except Exception as e:
+            logger.error(f"[AudioLogger] Error logging agent audio: {e}")
+            return None
+
+    def set_agent_cutoff_time(self, cutoff_time: Optional[float] = None):
+        """
+        Set the cutoff time for the most recent agent audio entry.
+
+        This method should be called when TTS is interrupted by user speech.
+        The cutoff_time represents when the agent audio was actually cut off,
+        which may be earlier than the natural end_time.
+
+        Args:
+            cutoff_time: The cutoff time in seconds from session start.
+                        If None, uses current time from session start.
+        """
+        if not self.enabled:
+            return
+
+        if cutoff_time is None:
+            cutoff_time = self.get_time_from_start_of_session()
+
+        with self._lock:
+            agent_entries = self.session_metadata["agent_entries"]
+            if not agent_entries or not agent_entries[-1]:
+                logger.warning("[AudioLogger] No agent entries to set cutoff time")
+                return
+
+            # Get the current turn (last sublist) and update ALL segments in it
+            current_turn = agent_entries[-1]
+            turn_index = current_turn[0]["turn_index"]
+
+            # Update cutoff_time for ALL segments in the current turn
+            for segment in current_turn:
+                segment["cutoff_time"] = cutoff_time
+                # Also update individual JSON files
+                try:
+                    metadata_file = self.agent_dir / f"{segment['base_name']}.json"
+                    self._save_metadata_json(segment, metadata_file)
+                except Exception as e:
+                    logger.error(f"[AudioLogger] Error updating agent cutoff time for segment: {e}")
+
+            # Truncate the stereo buffer (left channel = agent) at the cutoff point
+            cutoff_sample = int(cutoff_time * self._stereo_sample_rate)
+            if cutoff_sample < len(self._stereo_audio_buffer_left):
+                # Zero out agent audio after cutoff point
+                for i in range(cutoff_sample, len(self._stereo_audio_buffer_left)):
+                    self._stereo_audio_buffer_left[i] = 0.0
+                logger.debug(
+                    f"[AudioLogger] Truncated agent stereo buffer at sample {cutoff_sample} "
+                    f"(cutoff_time={cutoff_time:.3f}s)"
+                )
+
+            logger.info(
+                f"[AudioLogger] Set cutoff_time={cutoff_time:.3f}s for turn {turn_index} "
+                f"({len(current_turn)} segments)"
+            )
+
+            # Save updated session metadata
+            self._save_session_metadata()
+
+    def _save_session_metadata(self):
+        """Save the session metadata to disk."""
+        if not self.enabled:
+            return
+
+        try:
+            metadata_file = self.session_dir / "session_metadata.json"
+            self.session_metadata["last_updated"] = datetime.now().isoformat()
+            self._save_metadata_json(self.session_metadata, metadata_file)
+        except Exception as e:
+            logger.error(f"[AudioLogger] Error saving session metadata: {e}")
+
+    def finalize_session(self):
+        """Finalize the session and save final metadata."""
+        if not self.enabled:
+            return
+
+        # Save stereo conversation before finalizing
+        self.save_stereo_conversation()
+
+        self.session_metadata["end_time"] = datetime.now().isoformat()
+        self.session_metadata["total_user_entries"] = self._user_counter
+        self.session_metadata["total_agent_segments"] = self._agent_counter
+        self.session_metadata["total_agent_turns"] = len(self.session_metadata["agent_entries"])
+        self._save_session_metadata()
+        logger.info(
+            f"[AudioLogger] Session finalized: {self.session_id} "
+            f"(User: {self._user_counter}, Agent: {self._agent_counter} segments in "
+            f"{len(self.session_metadata['agent_entries'])} turns)"
+        )
+
+
+class RTVIAudioLoggerObserver(BaseObserver):
+    """Observer that triggers audio logging when TranscriptionFrame is pushed."""
+
+    def __init__(self, audio_logger: AudioLogger):
+        super().__init__()
+        self._audio_logger = audio_logger
+
+    async def on_push_frame(self, data: FramePushed):
+        """Handle frame push events and save user audio on TranscriptionFrame."""
+        frame = data.frame
+        if isinstance(frame, TranscriptionFrame) and self._audio_logger:
+            self._audio_logger.save_user_audio()
+        # Call parent class's on_push_frame method
+        await super().on_push_frame(data)

nemo/agents/voice_agent/pipecat/services/nemo/diar.py

@@ -0,0 +1,360 @@
+# Copyright (c) 2025, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+import asyncio
+from typing import AsyncGenerator, Optional
+
+import numpy as np
+from loguru import logger
+from pipecat.frames.frames import (
+    CancelFrame,
+    EndFrame,
+    ErrorFrame,
+    Frame,
+    StartFrame,
+    VADUserStartedSpeakingFrame,
+    VADUserStoppedSpeakingFrame,
+)
+from pipecat.processors.frame_processor import FrameDirection
+from pipecat.services.stt_service import STTService
+from pipecat.transcriptions.language import Language
+from pipecat.utils.time import time_now_iso8601
+from pipecat.utils.tracing.service_decorators import traced_stt
+from pydantic import BaseModel
+
+from nemo.agents.voice_agent.pipecat.frames.frames import DiarResultFrame
+from nemo.agents.voice_agent.pipecat.services.nemo.streaming_diar import DiarizationConfig, NeMoStreamingDiarService
+
+
+class NeMoDiarInputParams(BaseModel):
+    threshold: Optional[float] = (
+        0.4  # threshold value used to determine if a speaker exists or not, setting it to a lower value will increase the sensitivity of the diarization model
+    )
+    language: Optional[Language] = Language.EN_US
+    frame_len_in_secs: Optional[float] = 0.08  # 80ms for FastConformer model
+    config_path: Optional[str] = None  # path to the Niva ASR config file
+    raw_audio_frame_len_in_secs: Optional[float] = 0.016  # 16ms for websocket transport
+    buffer_size: Optional[int] = (
+        30  # number of audio frames to buffer, 1 frame is 16ms, streaming Sortformer was trained with 6*0.08=0.48s chunks
+    )
+
+
+class NemoDiarService(STTService):
+    def __init__(
+        self,
+        *,
+        model: Optional[str] = "",
+        device: Optional[str] = "cuda:0",
+        sample_rate: Optional[int] = 16000,
+        params: Optional[NeMoDiarInputParams] = None,
+        use_vad: bool = True,
+        audio_passthrough: bool = True,
+        backend: Optional[str] = "legacy",
+        enabled: bool = True,
+        **kwargs,
+    ):
+        super().__init__(audio_passthrough=audio_passthrough, **kwargs)
+
+        self._enabled = enabled
+        self._queue = asyncio.Queue()
+        self._response_queue = asyncio.Queue()  # Add response queue
+        self._processing_task = None  # Add processing task
+        self._response_task = None  # Add response task
+        self._device = device
+        self._sample_rate = sample_rate
+        self._audio_passthrough = audio_passthrough
+        params.buffer_size = params.frame_len_in_secs // params.raw_audio_frame_len_in_secs
+        self._params = params
+        self._model_name = model
+        self._use_vad = use_vad
+        self._backend = backend
+        if not params:
+            raise ValueError("params is required")
+
+        self._load_model()
+
+        self._vad_user_speaking = False
+        self._audio_buffer = []
+        self._current_speaker_id = None
+        self._processing_running = False
+
+        if not self._use_vad:
+            self._vad_user_speaking = True
+
+    def _load_model(self):
+        if not self._enabled or not self._model_name:
+            self._model = None
+            self._enabled = False
+            return
+
+        if self._backend == "legacy":
+            cfg = DiarizationConfig()
+            cfg.device = self._device
+            self._model = NeMoStreamingDiarService(
+                cfg, self._model_name, frame_len_in_secs=self._params.frame_len_in_secs, sample_rate=self.sample_rate
+            )
+        else:
+            raise ValueError(f"Invalid backend: {self._backend}")
+        logger.info(f"Diarization service initialized on device: {self._device}")
+
+    def can_generate_metrics(self) -> bool:
+        """Indicates whether this service can generate metrics.
+
+        Returns:
+            bool: True, as this service supports metric generation.
+        """
+        return True
+
+    async def start(self, frame: StartFrame):
+        """Handle service start."""
+        await super().start(frame)
+
+        # Initialize the model if not already done
+        if not hasattr(self, "_model"):
+            self._load_model()
+
+        # Start background processing task
+        if not self._processing_task:
+            self._processing_task = self.create_task(self._processing_task_handler())
+
+        # Start response handling task
+        if not self._response_task:
+            self._response_task = self.create_task(self._response_task_handler())
+
+    async def stop(self, frame: EndFrame):
+        """Handle service stop."""
+        await super().stop(frame)
+        await self._stop_tasks()
+
+    async def cancel(self, frame: CancelFrame):
+        """Handle service cancellation."""
+        await super().cancel(frame)
+        await self._stop_tasks()
+
+    async def _stop_tasks(self):
+        """Stop background processing tasks."""
+        await self._queue.put(None)  # Signal to stop processing
+        if self._processing_task:
+            await self.cancel_task(self._processing_task)
+            self._processing_task = None
+
+        if self._response_task:
+            await self.cancel_task(self._response_task)
+            self._response_task = None
+
+    def _diarization_processor(self):
+        """Background processor that handles diarization calls."""
+        try:
+            while self._processing_running:
+                try:
+                    # Get audio from queue - blocking call that will be interrupted by cancellation
+                    future = asyncio.run_coroutine_threadsafe(self._queue.get(), self.get_event_loop())
+                    audio = future.result()
+
+                    if audio is None:  # Stop signal
+                        logger.debug("Received stop signal in background processor")
+                        break
+
+                    # Process diarization
+                    diar_result = self._model.diarize(audio)
+
+                    # Send result back to async loop
+                    asyncio.run_coroutine_threadsafe(self._response_queue.put(diar_result), self.get_event_loop())
+
+                except Exception as e:
+                    logger.error(f"Error in background diarization processor: {e}")
+                    # Send error back to async loop
+                    asyncio.run_coroutine_threadsafe(self._response_queue.put(('error', e)), self.get_event_loop())
+
+        except Exception as e:
+            logger.error(f"Background diarization processor fatal error: {e}")
+        finally:
+            logger.debug("Background diarization processor stopped")
+
+    async def _processing_task_handler(self):
+        """Handler for background processing task."""
+        try:
+            self._processing_running = True
+            logger.debug("Starting background processing task")
+            await asyncio.to_thread(self._diarization_processor)
+        except asyncio.CancelledError:
+            logger.debug("Background processing task cancelled")
+            self._processing_running = False
+            raise
+        finally:
+            self._processing_running = False
+
+    async def _handle_diarization_result(self, diar_result):
+        """Handle diarization result from background processing."""
+        try:
+            if diar_result is None:
+                return
+            dominant_speaker_id = self._get_dominant_speaker_id(diar_result)
+            # logger.debug(f"Dominant speaker ID: {dominant_speaker_id}")
+            if dominant_speaker_id is not None and dominant_speaker_id != self._current_speaker_id:
+                self._current_speaker_id = dominant_speaker_id
+                logger.debug(f"Pushing DiarResultFrame with speaker {dominant_speaker_id}")
+                await self.push_frame(DiarResultFrame(dominant_speaker_id, stream_id="default"))
+        except Exception as e:
+            logger.error(f"Error handling diarization result: {e}")
+            await self.push_frame(
+                ErrorFrame(
+                    str(e),
+                    time_now_iso8601(),
+                )
+            )
+
+    async def _response_task_handler(self):
+        """Handler for processing diarization results."""
+        logger.debug("Response task handler started")
+        try:
+            while True:
+                try:
+                    result = await self._response_queue.get()
+
+                    if isinstance(result, tuple) and result[0] == 'error':
+                        # Handle error from background processing
+                        error = result[1]
+                        logger.error(f"Error in NeMo Diarization processing: {error}")
+                        await self.push_frame(
+                            ErrorFrame(
+                                str(error),
+                                time_now_iso8601(),
+                            )
+                        )
+                    else:
+                        # Handle successful diarization result
+                        await self._handle_diarization_result(result)
+
+                except Exception as e:
+                    logger.error(f"Error in response task handler: {e}")
+        except asyncio.CancelledError:
+            logger.debug("Response task handler cancelled")
+            raise
+
+    async def run_stt(self, audio: bytes) -> AsyncGenerator[Frame, None]:
+        """Process audio data and generate transcription frames.
+
+        Args:
+            audio: Raw audio bytes to transcribe
+
+        Yields:
+            Frame: Transcription frames containing the results
+        """
+        if self._vad_user_speaking and self._enabled:
+            self._audio_buffer.append(audio)
+            if len(self._audio_buffer) >= self._params.buffer_size:
+                await self.start_ttfb_metrics()
+                await self.start_processing_metrics()
+                audio = b"".join(self._audio_buffer)
+                self._audio_buffer = []
+                # Queue audio for background processing
+                await self._queue.put(audio)
+        yield None
+
+    @traced_stt
+    async def _handle_transcription(self, transcript: str, is_final: bool, language: Optional[str] = None):
+        """Handle a transcription result.
+
+        Args:
+            transcript: The transcribed text
+            is_final: Whether this is a final transcription
+            language: The language of the transcription
+        """
+        pass  # Base implementation - can be extended for specific handling needs
+
+    async def set_language(self, language: Language):
+        """Update the service's recognition language.
+
+        Args:
+            language: New language for recognition
+        """
+        if self._params:
+            self._params.language = language
+        else:
+            self._params = NeMoDiarInputParams(language=language)
+
+        logger.info(f"Switching STT language to: {language}")
+
+    async def set_model(self, model: str):
+        """Update the service's model.
+
+        Args:
+            model: New model name/path to use
+        """
+        await super().set_model(model)
+        self._model_name = model
+        self._load_model()
+
+    async def process_frame(self, frame: Frame, direction: FrameDirection):
+        """Process audio data and generate transcription frames.
+
+        Args:
+            audio: Raw audio bytes to transcribe
+
+        Yields:
+            Frame: Transcription frames containing the results
+        """
+        if not self._enabled:
+            # if diarization is disabled, just pass the frame through
+            await self.push_frame(frame, direction)
+            return
+
+        await super().process_frame(frame, direction)
+        if isinstance(frame, VADUserStartedSpeakingFrame):
+            self._vad_user_speaking = True
+            self._audio_buffer = []
+            logger.debug("VADUserStartedSpeakingFrame received")
+        elif isinstance(frame, VADUserStoppedSpeakingFrame):
+            self._vad_user_speaking = False
+            logger.debug("VADUserStoppedSpeakingFrame received")
+            self._current_speaker_id = None
+            self._audio_buffer = []
+
+    def reset(self):
+        """Reset the diarization service."""
+        self._current_speaker_id = None
+        self._audio_buffer = []
+        self._vad_user_speaking = False
+        self._model.reset_state()
+
+    def _get_dominant_speaker_id(self, spk_pred: np.ndarray):
+        spk_pred = (spk_pred > self._params.threshold).astype(int)
+        dominant_speaker_id = None
+        if spk_pred.sum() > 0:
+            # get the dominant speaker id
+            # Filter to only keep frames that have any speaker probability > 0.0
+            valid_frame_mask = spk_pred.sum(axis=1) > 0
+
+            # Filter diar_result to only keep valid frames
+            filtered_diar_result = spk_pred[valid_frame_mask]  # ndarray of shape [num_valid_frames, num_speakers]
+
+            # Get the primary speaker for each valid frame
+            primary_spk = np.argmax(filtered_diar_result, axis=1)  # ndarray of shape [num_valid_frames]
+            # logger.debug(f"Primary speaker for valid frames: {primary_spk}")
+
+            # count the number of different speakers in the primary speaker sequence
+            num_speakers = len(np.unique(primary_spk))
+            # logger.debug(f"Number of different speakers: {num_speakers}")
+
+            # If there are multiple speakers, get the dominant one
+            if num_speakers > 1:
+                # Count occurrences of each speaker
+                speaker_counts = np.bincount(primary_spk)
+                dominant_speaker_id = np.argmax(speaker_counts)
+            else:
+                # Only one speaker, return that speaker ID
+                dominant_speaker_id = primary_spk[0]
+        return dominant_speaker_id

nemo/agents/voice_agent/pipecat/services/nemo/llm.py

@@ -0,0 +1,760 @@
+# Copyright (c) 2025, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import asyncio
+import os
+import socket
+import subprocess
+import time
+import uuid
+from threading import Thread
+from typing import AsyncGenerator, List, Mapping, Optional
+
+import psutil
+import requests
+from jinja2.exceptions import TemplateError
+from loguru import logger
+from omegaconf import DictConfig, OmegaConf
+from openai import APITimeoutError, AsyncStream, BadRequestError
+from openai.types.chat import ChatCompletionChunk, ChatCompletionMessageParam
+from pipecat.adapters.services.open_ai_adapter import OpenAILLMInvocationParams
+from pipecat.frames.frames import (
+    CancelFrame,
+    EndFrame,
+    LLMFullResponseEndFrame,
+    LLMFullResponseStartFrame,
+    LLMTextFrame,
+)
+from pipecat.processors.aggregators.openai_llm_context import OpenAILLMContext
+from pipecat.services.openai.llm import OpenAILLMService
+from transformers import AsyncTextIteratorStreamer, AutoModelForCausalLM, AutoTokenizer
+from vllm.config import ModelConfig as vllmModelConfig
+
+DEFAULT_GENERATION_KWARGS = {
+    "max_new_tokens": 256,
+    "temperature": 0.7,
+    "top_p": 0.9,
+    "do_sample": True,
+}
+
+
+class LLMUtilsMixin:
+    """Utils for local LLM services."""
+
+    def _maybe_add_user_message(self, messages: List[ChatCompletionMessageParam]) -> List[ChatCompletionMessageParam]:
+        """
+        Some LLMs like "nvidia/Llama-3.1-Nemotron-Nano-8B-v1" requires a user turn after the system prompt,
+        this function is used to add a dummy user turn if the system prompt is followed by an assistant turn.
+        """
+        if len(messages) > 1 and messages[0]["role"] == "system" and messages[1]["role"] == "assistant":
+            message = {"role": "user", "content": "Hi"}
+            messages.insert(1, message)
+        elif len(messages) == 1 and messages[0]["role"] == "system":
+            messages.append({"role": "user", "content": "Hi"})
+        return messages
+
+    def _maybe_merge_consecutive_user_turns(
+        self, messages: List[ChatCompletionMessageParam]
+    ) -> List[ChatCompletionMessageParam]:
+        """
+        Merge consecutive user turns into a single turn,
+        since some LLMs like "nvidia/Llama-3.1-Nemotron-Nano-8B-v1" do not support consecutive user turns.
+        """
+        if not messages:
+            return messages
+
+        merged_messages = []
+
+        user_content = ""
+        for message in messages:
+            role = message["role"]
+            if role != "user":
+                # check if there's any preceeding user content, add them first
+                if user_content:
+                    merged_messages.append({"role": "user", "content": user_content})
+                    user_content = ""
+                merged_messages.append(message)
+            else:
+                if user_content:
+                    user_content += "; " + message["content"]
+                else:
+                    user_content = message["content"]
+
+        # add the last user content
+        if user_content:
+            merged_messages.append({"role": "user", "content": user_content})
+
+        return merged_messages
+
+
+class HuggingFaceLLMLocalService(LLMUtilsMixin):
+    """
+    HuggingFace LLM local service.
+    """
+
+    def __init__(
+        self,
+        model: str = "meta-llama/Meta-Llama-3-8B-Instruct",
+        device: str = "cuda:0",
+        dtype: str = "bfloat16",
+        thinking_budget: int = 0,
+        generation_kwargs: dict = None,
+        apply_chat_template_kwargs: dict = None,
+    ):
+        self.device = device
+        self.dtype = dtype
+        self.thinking_budget = thinking_budget
+        self.tokenizer = AutoTokenizer.from_pretrained(model)
+        self.model = AutoModelForCausalLM.from_pretrained(
+            model, device_map=device, dtype=dtype, trust_remote_code=True
+        )  # type: AutoModelForCausalLM
+
+        self.generation_kwargs = generation_kwargs if generation_kwargs else DEFAULT_GENERATION_KWARGS
+        logger.debug(f"LLM generation kwargs: {self.generation_kwargs}")
+
+        self.apply_chat_template_kwargs = apply_chat_template_kwargs if apply_chat_template_kwargs else {}
+        if "tokenize" in self.apply_chat_template_kwargs:
+            if self.apply_chat_template_kwargs["tokenize"] is not False:
+                logger.warning(
+                    f"Found `tokenize=True` in apply_chat_template_kwargs={self.apply_chat_template_kwargs},"
+                    "it will be ignored and forced to `False`"
+                )
+            self.apply_chat_template_kwargs.pop("tokenize")
+
+        logger.debug(f"LLM apply_chat_template kwargs: {self.apply_chat_template_kwargs}")
+
+    def _apply_chat_template(self, messages: List[ChatCompletionMessageParam]) -> str:
+        """
+        Apply the chat template to the messages.
+        """
+        return self.tokenizer.apply_chat_template(messages, tokenize=False, **self.apply_chat_template_kwargs)
+
+    def _get_prompt_from_messages(self, messages: List[ChatCompletionMessageParam]) -> str:
+        """
+        Get the formatted prompt from the conversation history messages.
+        This function also tries to fix the messages if the LLM cannot handle consecutive turns of the same role,
+        or requires a user turn after the system prompt.
+        """
+        try:
+            prompt = self._apply_chat_template(messages)
+            return prompt
+        except TemplateError as e:
+            logger.warning(f"Got TemplateError: {e}.")
+
+        logger.debug(f"Input LLM messages: {messages}")
+        if len(messages) > 1 and messages[0]["role"] == "system" and messages[1]["role"] == "assistant":
+            logger.warning("Trying to fix by adding dummy user message after system prompt...")
+            try:
+                messages = self._maybe_add_user_message(messages)
+                logger.debug(f"LLM messages after adding dummy user message: {messages}")
+                prompt = self._apply_chat_template(messages)
+                return prompt
+            except TemplateError as e:
+                logger.warning(f"Got TemplateError: {e}. Trying to fix by merging consecutive turns if possible.")
+
+        try:
+            new_messages = self._maybe_merge_consecutive_user_turns(messages)
+            logger.debug(f"LLM messages after merging consecutive user turns: {new_messages}")
+            prompt = self._apply_chat_template(new_messages)
+            # Update the messages in place if successful
+            messages.clear()
+            messages.extend(new_messages)
+            return prompt
+        except Exception as e:
+            logger.warning(f"Got Exception: {e}, messages: {messages}")
+            raise e
+
+    async def generate_stream(
+        self, messages: List[ChatCompletionMessageParam], **kwargs
+    ) -> AsyncGenerator[ChatCompletionChunk, None]:
+        """
+        Generate a stream of chat completion chunks from the messages.
+        """
+        # Convert messages to prompt format
+        prompt = self._get_prompt_from_messages(messages)
+
+        logger.debug(f"LLM prompt: {prompt}")
+
+        inputs = self.tokenizer(prompt, add_special_tokens=False, return_tensors="pt").to(self.device)
+
+        # Generate with streaming
+        streamer = AsyncTextIteratorStreamer(self.tokenizer, skip_prompt=True, skip_special_tokens=True)
+        generation_kwargs = {
+            **inputs,
+            "streamer": streamer,
+            **self.generation_kwargs,
+        }
+
+        # Start generation in background
+        thread = Thread(
+            target=self.model.generate,
+            kwargs=generation_kwargs,
+        )
+        thread.start()
+
+        # Stream the output
+        async for text in streamer:
+            # logger.debug(f"Streamer yielded text: {text}")
+            chunk = ChatCompletionChunk(
+                id="hf-" + str(uuid.uuid4()),
+                choices=[{"delta": {"content": text}, "finish_reason": None, "index": 0}],
+                created=int(time.time()),
+                model=self.model.config._name_or_path,
+                object="chat.completion.chunk",
+            )
+            yield chunk
+
+
+class HuggingFaceLLMService(OpenAILLMService):
+    """
+    LLM service that hosts a HuggingFace model.
+    """
+
+    def __init__(
+        self,
+        *,
+        model: str = "google/gemma-7b-it",
+        device: str = "cuda",
+        dtype: str = "bfloat16",
+        thinking_budget: int = 0,
+        generation_kwargs: dict = None,
+        apply_chat_template_kwargs: dict = None,
+        **kwargs,
+    ):
+        self._model_name = model
+        self._device = device
+        self._dtype = dtype
+        self._thinking_budget = thinking_budget
+        self._generation_kwargs = generation_kwargs if generation_kwargs is not None else DEFAULT_GENERATION_KWARGS
+        self._apply_chat_template_kwargs = apply_chat_template_kwargs if apply_chat_template_kwargs is not None else {}
+        super().__init__(model=model, **kwargs)
+
+    def create_client(self, api_key=None, base_url=None, **kwargs):
+        """
+        Create a HuggingFaceLLMLocalService client.
+        """
+        return HuggingFaceLLMLocalService(
+            model=self._model_name,
+            device=self._device,
+            dtype=self._dtype,
+            thinking_budget=self._thinking_budget,
+            generation_kwargs=self._generation_kwargs,
+            apply_chat_template_kwargs=self._apply_chat_template_kwargs,
+        )
+
+    async def _process_context(self, context: OpenAILLMContext):
+        """Process a context through the LLM and push text frames.
+
+        Args:
+            context (OpenAILLMContext): The context to process, containing messages
+                and other information needed for the LLM interaction.
+        """
+        await self.push_frame(LLMFullResponseStartFrame())
+        cumulative_text = ""
+        try:
+            await self.start_ttfb_metrics()
+            messages = context.get_messages()
+            async for chunk in self._client.generate_stream(messages):
+                if chunk.choices[0].delta.content:
+                    await self.stop_ttfb_metrics()
+                    text = chunk.choices[0].delta.content
+                    cumulative_text += text
+                    frame = LLMTextFrame(text)
+                    await self.push_frame(frame)
+        except Exception as e:
+            logger.error(f"Error in _process_context: {e}", exc_info=True)
+            raise
+        finally:
+            cumulative_text = " ".join(cumulative_text.split()).strip()
+            if not cumulative_text:
+                logger.warning(f"LLM response is empty for context: {context}")
+            await self.push_frame(LLMFullResponseEndFrame())
+
+    async def get_chat_completions(
+        self, params_from_context: OpenAILLMInvocationParams
+    ) -> AsyncGenerator[ChatCompletionChunk, None]:
+        """Create a streaming chat completion using HuggingFace model.
+
+        Args:
+            context (OpenAILLMContext): The context object containing tools configuration
+                and other settings for the chat completion.
+            messages (List[ChatCompletionMessageParam]): The list of messages comprising
+                the conversation history and current request.
+
+        Returns:
+            AsyncGenerator[ChatCompletionChunk]: A streaming response of chat completion
+                chunks that can be processed asynchronously.
+        """
+        messages = params_from_context["messages"]
+
+        return self._client.generate_stream(messages)
+
+
+class VLLMService(OpenAILLMService, LLMUtilsMixin):
+    """
+    LLM service that hosts a vLLM server.
+    """
+
+    def __init__(
+        self,
+        *,
+        model: str,
+        device: str = "cuda",
+        api_key="None",
+        base_url="http://localhost:8000/v1",
+        organization="None",
+        project="None",
+        default_headers: Optional[Mapping[str, str]] = None,
+        params: Optional[OpenAILLMService.InputParams] = None,
+        thinking_budget: int = 0,
+        start_vllm_on_init: bool = False,
+        vllm_server_params: Optional[str] = None,
+        vllm_server_max_wait_time: int = 3600,  # 1 hour max wait time
+        vllm_server_check_interval: int = 5,  # check server every 5 seconds
+        **kwargs,
+    ):
+        self._device = device
+        self._vllm_server_max_wait_time = vllm_server_max_wait_time
+        self._vllm_server_check_interval = vllm_server_check_interval
+        if start_vllm_on_init:
+            base_url = self._start_vllm_server(model, vllm_server_params, base_url)
+
+        super().__init__(
+            model=model,
+            api_key=api_key,
+            base_url=base_url,
+            organization=organization,
+            project=project,
+            default_headers=default_headers,
+            params=params,
+            **kwargs,
+        )
+        self._thinking_budget = thinking_budget
+        self._vllm_server_params = vllm_server_params
+        self._start_vllm_on_init = start_vllm_on_init
+
+        # TODO: handle thinking budget
+        logger.info(
+            f"VLLMService initialized with model: {model}, api_key: {api_key}, base_url: {base_url},"
+            f"params: {params}, thinking_budget: {thinking_budget}"
+        )
+
+    def _start_vllm_server(
+        self, model: str, vllm_server_params: Optional[str] = None, base_url: Optional[str] = None
+    ) -> str:
+        """
+        Start a vllm server and return the base url.
+        """
+
+        requested_port = None
+        # If base_url is provided, extract port from it
+        if base_url:
+            try:
+                # Extract port from base_url like "http://localhost:8003/v1"
+                from urllib.parse import urlparse
+
+                parsed_url = urlparse(base_url)
+                if parsed_url.port:
+                    requested_port = parsed_url.port
+            except Exception as e:
+                logger.warning(
+                    f"Could not parse port from base_url {base_url}: {e}, using port from vllm_server_params"
+                )
+
+        # Parse port from vllm_server_params, default to 8000
+        if vllm_server_params:
+            params_list = vllm_server_params.split()
+            for i, param in enumerate(params_list):
+                if param == "--port" and i + 1 < len(params_list):
+                    try:
+                        param_port = int(params_list[i + 1])
+                        if requested_port is None:
+                            requested_port = param_port
+                        else:
+                            if param_port != requested_port:
+                                logger.warning(
+                                    f"Port {param_port} from vllm_server_params is different from base_url port"
+                                    f"{requested_port}, using new port {param_port}"
+                                )
+                                requested_port = param_port
+                        break
+                    except ValueError:
+                        logger.warning(f"Invalid port number: {params_list[i + 1]}, using default 8000")
+
+        if requested_port is None:
+            # try to use default port
+            requested_port = 8000
+
+        def find_available_port(start_port: int) -> int:
+            """Find an available port starting from start_port"""
+            for port in range(start_port, start_port + 100):  # Try up to 100 ports
+                try:
+                    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+                        s.bind(('localhost', port))
+                        return port
+                except OSError:
+                    continue
+            raise RuntimeError(f"Could not find an available port starting from {start_port}")
+
+        def get_pid_on_port(port: int) -> Optional[int]:
+            for conn in psutil.net_connections(kind="inet"):
+                if conn.laddr.port == port and conn.status == psutil.CONN_LISTEN:
+                    return conn.pid
+            return None
+
+        def check_server_model(port: int, verbose: bool = False) -> tuple[bool, str]:
+            """Check if server is running on port and return (is_running, model_name)"""
+            try:
+                response = requests.get(f"http://localhost:{port}/v1/models", timeout=5)
+                if response.status_code == 200:
+                    # get the PID for the server process
+                    pid = get_pid_on_port(port)
+                    if pid is not None and verbose:
+                        logger.warning(
+                            f"Found vLLM server process (PID: {pid}) on port {port}, you can use `lsof -i :{port}`"
+                            "to find the process and kill it if you want to start a new server."
+                        )
+                    models_data = response.json()
+                    if "data" in models_data and models_data["data"]:
+                        served_model = models_data["data"][0].get("id", "")
+                        return True, served_model
+                    return True, ""
+                return False, ""
+            except (requests.exceptions.RequestException, requests.exceptions.Timeout):
+                return False, ""
+
+        # First, check if vLLM server is already running on the requested port
+        is_running, served_model = check_server_model(requested_port, verbose=True)
+        if is_running:
+            if served_model == model:
+                final_base_url = f"http://localhost:{requested_port}/v1"
+                logger.info(f"vLLM server is already running at {final_base_url} with the correct model: {model}")
+                return final_base_url
+            else:
+                logger.warning(
+                    f"vLLM server on port {requested_port} is serving model '{served_model}' but we need '{model}'."
+                    "Finding new port..."
+                )
+
+        # Find an available port for our model
+        port = find_available_port(requested_port)
+        if port != requested_port:
+            logger.info(f"Using port {port} instead of requested port {requested_port}")
+
+        final_base_url = f"http://localhost:{port}/v1"
+
+        # Check if there's already a vLLM process running on the same port and model
+        for proc in psutil.process_iter(['pid', 'name', 'cmdline']):
+            try:
+                if proc.info['cmdline'] and any('vllm' in arg and 'serve' in arg for arg in proc.info['cmdline']):
+                    # Check if this process is using the same port and model
+                    cmdline_str = ' '.join(proc.info['cmdline'])
+                    if f"--port {port}" in cmdline_str:
+                        # Extract the model from the command line
+                        cmdline_parts = proc.info['cmdline']
+                        model_index = -1
+                        for i, arg in enumerate(cmdline_parts):
+                            if arg == "serve" and i + 1 < len(cmdline_parts):
+                                model_index = i + 1
+                                break
+
+                        if model_index != -1 and model_index < len(cmdline_parts):
+                            running_model = cmdline_parts[model_index]
+                            if running_model == model:
+                                logger.info(
+                                    f"Found existing vLLM server process (PID: {proc.info['pid']}) on port {port}"
+                                    f"serving model {model}"
+                                )
+                                # Wait a bit and check if it's responding
+                                time.sleep(2)
+                                is_running, served_model = check_server_model(port)
+                                if is_running and served_model == model:
+                                    logger.info(
+                                        f"Existing vLLM server is responding at {final_base_url} with correct model"
+                                    )
+                                    return final_base_url
+                                else:
+                                    logger.warning(
+                                        f"Existing vLLM process found on port {port} but not responding correctly,"
+                                        "will start new server"
+                                    )
+                            else:
+                                logger.info(
+                                    f"Found vLLM process on port {port} but serving different model '{running_model}'"
+                                    f"(need '{model}'). Will start new server."
+                                )
+            except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
+                continue
+
+        # Build the command with the determined port
+        cmd_parts = ["vllm", "serve", model]
+
+        # Parse and modify vllm_server_params to use the correct port
+        if vllm_server_params:
+            # parse the vllm_server_params and add the port to the command
+            params_list = vllm_server_params.split()
+            modified_params = []
+            i = 0
+            while i < len(params_list):
+                if params_list[i] == "--port" and i + 1 < len(params_list):
+                    # Replace the port with our determined port
+                    modified_params.extend(["--port", str(port)])
+                    i += 2  # Skip the original port value
+                else:
+                    modified_params.append(params_list[i])
+                    i += 1
+            cmd_parts.extend(modified_params)
+        else:
+            # Add port if vllm_server_params is not provided
+            cmd_parts.extend(["--port", str(port)])
+
+        logger.info(f"Starting vLLM server with command: {' '.join(cmd_parts)}")
+        logger.warning("It will take a while to download the model if it's not already downloaded.")
+        # Set up environment variables for device configuration
+        env = os.environ.copy()
+        if self._device and self._device != "cpu":
+            # Extract CUDA device number if it's in format "cuda:0", "cuda:1", etc.
+            if self._device.startswith("cuda:"):
+                device_id = self._device.split(":")[1]
+                env["CUDA_VISIBLE_DEVICES"] = device_id
+                logger.info(f"Setting CUDA_VISIBLE_DEVICES={device_id}")
+            elif self._device == "cuda":
+                # Use default CUDA device (don't set CUDA_VISIBLE_DEVICES)
+                logger.info("Using default CUDA device")
+            else:
+                # For other device strings, try to extract device number
+                logger.warning(f"Unknown device format: {self._device}, using as-is")
+                env["CUDA_VISIBLE_DEVICES"] = self._device
+        elif self._device == "cpu":
+            env["CUDA_VISIBLE_DEVICES"] = ""
+            logger.info("Setting CUDA_VISIBLE_DEVICES='' to use CPU")
+
+        try:
+            # Start the vLLM server process with environment variables
+            process = subprocess.Popen(
+                cmd_parts,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+                env=env,
+                preexec_fn=os.setsid if os.name != 'nt' else None,  # Create new process group
+            )
+
+            # Store the process for potential cleanup later
+            self._vllm_process = process
+
+            # Wait for server to start up
+            max_wait_time = self._vllm_server_max_wait_time
+            check_interval = self._vllm_server_check_interval
+            waited_time = 0
+
+            logger.info(f"Waiting for vLLM server to start on port {port}...")
+            while waited_time < max_wait_time:
+                is_running, served_model = check_server_model(port)
+                if is_running and served_model == model:
+                    logger.info(f"vLLM server started successfully at {final_base_url} serving model: {model}")
+                    return final_base_url
+                elif is_running and served_model != model:
+                    logger.warning(
+                        f"vLLM server started but serving wrong model '{served_model}' instead of '{model}'."
+                        "Continuing to wait..."
+                    )
+
+                # Check if process is still running
+                if process.poll() is not None:
+                    # Process has terminated
+                    stdout, stderr = process.communicate()
+                    logger.error(f"vLLM server process terminated unexpectedly. stdout: {stdout}, stderr: {stderr}")
+                    raise RuntimeError(f"Failed to start vLLM server: {stderr}")
+
+                time.sleep(check_interval)
+                waited_time += check_interval
+                logger.debug(f"Still waiting for vLLM server on port {port}... ({waited_time}s)")
+
+            # If we get here, server didn't start in time
+            logger.error(f"vLLM server failed to start within {max_wait_time} seconds on port {port}")
+            process.terminate()
+            raise RuntimeError(f"vLLM server failed to start within {max_wait_time} seconds on port {port}")
+
+        except FileNotFoundError:
+            logger.error("vLLM not found. Please install vLLM: pip install vllm")
+            raise RuntimeError("vLLM not found. Please install vLLM: pip install vllm")
+        except Exception as e:
+            logger.error(f"Failed to start vLLM server: {e}")
+            self._stop_vllm_server()
+            raise e
+
+    def _stop_vllm_server(self):
+        """Stop the vLLM server process if it's running."""
+        if hasattr(self, '_vllm_process') and self._vllm_process:
+            logger.info(f"Stopping vLLM server process {self._vllm_process.pid}")
+            self._vllm_process.terminate()
+
+    async def stop(self, frame: EndFrame):
+        """Stop the LLM service.
+
+        Args:
+            frame: The end frame.
+        """
+        await super().stop(frame)
+        self._stop_vllm_server()
+
+    async def cancel(self, frame: CancelFrame):
+        """Cancel the LLM service.
+
+        Args:
+            frame: The cancel frame.
+        """
+        await super().cancel(frame)
+        self._stop_vllm_server()
+
+    async def get_chat_completions(
+        self, params_from_context: OpenAILLMInvocationParams
+    ) -> AsyncStream[ChatCompletionChunk]:
+        """Get streaming chat completions from OpenAI API.
+
+        Args:
+            context: The LLM context containing tools and configuration.
+            messages: List of chat completion messages to send.
+
+        Returns:
+            Async stream of chat completion chunks.
+        """
+
+        params = self.build_chat_completion_params(params_from_context)
+        messages = params_from_context["messages"]
+        if self._retry_on_timeout:
+            try:
+                chunks = await asyncio.wait_for(
+                    self._get_response_from_client(messages, params), timeout=self._retry_timeout_secs
+                )
+                return chunks
+            except (APITimeoutError, asyncio.TimeoutError):
+                # Retry, this time without a timeout so we get a response
+                logger.debug(f"{self}: Retrying chat completion due to timeout")
+                chunks = await self._get_response_from_client(messages, params)
+                return chunks
+        else:
+            chunks = await self._get_response_from_client(messages, params)
+            return chunks
+
+    async def _get_response_from_client(
+        self, messages: List[ChatCompletionMessageParam], params: dict
+    ) -> AsyncStream[ChatCompletionChunk]:
+        """Get a response from the client."""
+
+        try:
+            chunks = await self._client.chat.completions.create(**params)
+        except BadRequestError as e:
+            logger.error(f"Error in _get_response_from_client: {e}, trying to fix...")
+            logger.debug(f"LLM messages before fixing: {messages}")
+            messages = self._maybe_add_user_message(messages)
+            messages = self._maybe_merge_consecutive_user_turns(messages)
+            logger.debug(f"LLM messages after fixing: {messages}")
+            params["messages"] = messages
+            chunks = await self._client.chat.completions.create(**params)
+
+        return chunks
+
+
+def get_llm_service_from_config(config: DictConfig) -> OpenAILLMService:
+    """Get an LLM service from the configuration."""
+    backend = config.type
+
+    logger.info(f"Initializing LLM service from config: {config}")
+
+    # If backend is "auto", try to detect the best backend
+    if backend == "auto":
+        model_name = config.get("model")
+        if not model_name:
+            raise ValueError("Model name is required for LLM")
+
+        try:
+            _ = vllmModelConfig(model_name, trust_remote_code=True)
+            backend = "vllm"
+            logger.info(f"Auto-detected vLLM as the best backend for model {model_name}")
+        except Exception as e:
+            logger.info(
+                f"The LLM doesn't seem to be supported by vLLM yet (error: {e}), using HuggingFace as the backend"
+                f"for model: {model_name}. If you are sure that the LLM is supported by vLLM, you can set `type: vllm`"
+                "in the config file to force using vLLM."
+            )
+            backend = "hf"
+
+    assert backend in [
+        "hf",
+        "vllm",
+        "auto",
+    ], f"Invalid backend: {backend}, only `hf`, `vllm`, and `auto` are supported."
+
+    if backend == "hf":
+        llm_model = config.model
+        llm_device = config.device
+        llm_dtype = config.dtype
+        llm_generation_kwargs = config.get("generation_kwargs", {})
+        if llm_generation_kwargs is not None:
+            llm_generation_kwargs = OmegaConf.to_container(llm_generation_kwargs, resolve=True)
+        llm_apply_chat_template_kwargs = config.get("apply_chat_template_kwargs", None)
+        if llm_apply_chat_template_kwargs is not None:
+            llm_apply_chat_template_kwargs = OmegaConf.to_container(llm_apply_chat_template_kwargs, resolve=True)
+        llm_thinking_budget = config.get("thinking_budget", 0)
+        return HuggingFaceLLMService(
+            model=llm_model,
+            device=llm_device,
+            dtype=llm_dtype,
+            generation_kwargs=llm_generation_kwargs,
+            apply_chat_template_kwargs=llm_apply_chat_template_kwargs,
+            thinking_budget=llm_thinking_budget,
+        )
+    elif backend == "vllm":
+        llm_model = config.get("model", "vllm_server")
+        llm_api_key = config.get("api_key", "None")
+        llm_base_url = config.get("base_url", "http://localhost:8000/v1")
+        llm_organization = config.get("organization", "None")
+        llm_project = config.get("project", "None")
+        llm_default_headers = config.get("default_headers", None)
+        llm_params = config.get("vllm_generation_params", None)
+        llm_dtype = config.dtype
+        vllm_server_params = config.get("vllm_server_params", None)
+        if vllm_server_params is not None:
+            if "dtype" not in vllm_server_params:
+                vllm_server_params = f"--dtype {llm_dtype} {vllm_server_params}"
+                logger.info(f"Adding dtype {llm_dtype} to vllm_server_params: {vllm_server_params}")
+        if llm_params is not None:
+            # cast into OpenAILLMService.InputParams object
+            llm_params = OmegaConf.to_container(llm_params, resolve=True)
+            extra = llm_params.get("extra", None)
+            # ensure extra is a dictionary
+            if extra is None:
+                llm_params["extra"] = {}
+            elif not isinstance(extra, dict):
+                raise ValueError(f"extra must be a dictionary, got {type(extra)}")
+            llm_params = OpenAILLMService.InputParams(**llm_params)
+        else:
+            llm_params = OpenAILLMService.InputParams()
+        llm_thinking_budget = config.get("thinking_budget", 0)
+        return VLLMService(
+            model=llm_model,
+            api_key=llm_api_key,
+            base_url=llm_base_url,
+            organization=llm_organization,
+            project=llm_project,
+            default_headers=llm_default_headers,
+            params=llm_params,
+            thinking_budget=llm_thinking_budget,
+            start_vllm_on_init=config.get("start_vllm_on_init", False),
+            vllm_server_params=vllm_server_params,
+        )
+    else:
+        raise ValueError(f"Invalid LLM backend: {backend}")

nemo/agents/voice_agent/pipecat/services/nemo/streaming_asr.py

@@ -0,0 +1,319 @@
+# Copyright (c) 2025, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# NOTE: This file will be deprecated in the future, as the new inference pipeline will replace it.
+
+import math
+import time
+from dataclasses import dataclass
+from typing import List, Optional
+
+import numpy as np
+import torch
+from omegaconf import open_dict
+
+import nemo.collections.asr as nemo_asr
+from nemo.agents.voice_agent.pipecat.services.nemo.utils import CacheFeatureBufferer
+from nemo.collections.asr.parts.utils.rnnt_utils import Hypothesis
+from nemo.collections.common.tokenizers.sentencepiece_tokenizer import SentencePieceTokenizer
+
+
+@dataclass
+class ASRResult:
+    text: str
+    is_final: bool
+    eou_prob: Optional[float] = None
+    eob_prob: Optional[float] = None
+    eou_latency: Optional[float] = None
+    eob_latency: Optional[float] = None
+    processing_time: Optional[float] = None
+
+
+class NemoStreamingASRService:
+    def __init__(
+        self,
+        model: str = "nvidia/parakeet_realtime_eou_120m-v1",
+        att_context_size: List[int] = [70, 1],
+        device: str = "cuda",
+        eou_string: str = "<EOU>",
+        eob_string: str = "<EOB>",
+        decoder_type: str = None,
+        chunk_size: int = -1,
+        shift_size: int = -1,
+        left_chunks: int = 2,
+        sample_rate: int = 16000,
+        frame_len_in_secs: float = 0.08,
+        use_amp: bool = False,
+        chunk_size_in_secs: float = 0.08,
+    ):
+        self.model = model
+        self.eou_string = eou_string
+        self.eob_string = eob_string
+        self.device = device
+        self.att_context_size = att_context_size
+        self.decoder_type = decoder_type
+        self.chunk_size = chunk_size
+        self.shift_size = shift_size
+        self.left_chunks = left_chunks
+        self.asr_model = self._load_model(model)
+        self.tokenizer: SentencePieceTokenizer = self.asr_model.tokenizer
+        self.use_amp = use_amp
+        self.pad_and_drop_preencoded = False
+        self.blank_id = self.get_blank_id()
+        self.chunk_size_in_secs = chunk_size_in_secs
+
+        assert len(self.att_context_size) == 2, "Att context size must be a list of two integers"
+        assert (
+            self.att_context_size[0] >= 0
+        ), f"Left att context size must be greater than 0: {self.att_context_size[0]}"
+        assert (
+            self.att_context_size[1] >= 0
+        ), f"Right att context size must be greater than 0: {self.att_context_size[1]}"
+
+        window_stride_in_secs = self.asr_model.cfg.preprocessor.window_stride
+        model_stride = self.asr_model.cfg.encoder.subsampling_factor
+        self.model_chunk_size = self.asr_model.encoder.streaming_cfg.chunk_size
+        if isinstance(self.model_chunk_size, list):
+            self.model_chunk_size = self.model_chunk_size[1]
+        self.pre_encode_cache_size = self.asr_model.encoder.streaming_cfg.pre_encode_cache_size
+        if isinstance(self.pre_encode_cache_size, list):
+            self.pre_encode_cache_size = self.pre_encode_cache_size[1]
+        self.pre_encode_cache_size_in_secs = self.pre_encode_cache_size * window_stride_in_secs
+
+        self.tokens_per_frame = math.ceil(np.trunc(self.chunk_size_in_secs / window_stride_in_secs) / model_stride)
+        # overwrite the encoder streaming params with proper shift size for cache aware streaming
+        self.asr_model.encoder.setup_streaming_params(
+            chunk_size=self.model_chunk_size // model_stride, shift_size=self.tokens_per_frame
+        )
+
+        model_chunk_size_in_secs = self.model_chunk_size * window_stride_in_secs
+
+        self.buffer_size_in_secs = self.pre_encode_cache_size_in_secs + model_chunk_size_in_secs
+
+        self._audio_buffer = CacheFeatureBufferer(
+            sample_rate=sample_rate,
+            buffer_size_in_secs=self.buffer_size_in_secs,
+            chunk_size_in_secs=self.chunk_size_in_secs,
+            preprocessor_cfg=self.asr_model.cfg.preprocessor,
+            device=self.device,
+        )
+        self._reset_cache()
+        self._previous_hypotheses = self._get_blank_hypothesis()
+        self._last_transcript_timestamp = time.time()
+        print(f"NemoStreamingASRService initialized with model `{model}` on device `{self.device}`")
+
+    def _reset_cache(self):
+        (
+            self._cache_last_channel,  # [17, B, 70, 512]
+            self._cache_last_time,  # [17, B, 512, 8]
+            self._cache_last_channel_len,  # B
+        ) = self.asr_model.encoder.get_initial_cache_state(
+            1
+        )  # batch size is 1
+
+    def _get_blank_hypothesis(self) -> List[Hypothesis]:
+        blank_hypothesis = Hypothesis(score=0.0, y_sequence=[], dec_state=None, timestamp=[], last_token=None)
+        return [blank_hypothesis]
+
+    @property
+    def drop_extra_pre_encoded(self):
+        return self.asr_model.encoder.streaming_cfg.drop_extra_pre_encoded
+
+    def get_blank_id(self):
+        return len(self.tokenizer.vocab)
+
+    def get_text_from_tokens(self, tokens: List[int]) -> str:
+        sep = "\u2581"  # '▁'
+        tokens = [int(t) for t in tokens if t != self.blank_id]
+        if tokens:
+            pieces = self.tokenizer.ids_to_tokens(tokens)
+            text = "".join([p.replace(sep, ' ') if p.startswith(sep) else p for p in pieces])
+        else:
+            text = ""
+        return text
+
+    def _load_model(self, model: str):
+        if model.endswith(".nemo"):
+            asr_model = nemo_asr.models.ASRModel.restore_from(model, map_location=torch.device(self.device))
+        else:
+            asr_model = nemo_asr.models.ASRModel.from_pretrained(model, map_location=torch.device(self.device))
+
+        if self.decoder_type is not None and hasattr(asr_model, "cur_decoder"):
+            asr_model.change_decoding_strategy(decoder_type=self.decoder_type)
+        elif isinstance(asr_model, nemo_asr.models.EncDecCTCModel):
+            self.decoder_type = "ctc"
+        elif isinstance(asr_model, nemo_asr.models.EncDecRNNTModel):
+            self.decoder_type = "rnnt"
+        else:
+            raise ValueError("Decoder type not supported for this model.")
+
+        if self.att_context_size is not None:
+            if hasattr(asr_model.encoder, "set_default_att_context_size"):
+                asr_model.encoder.set_default_att_context_size(att_context_size=self.att_context_size)
+            else:
+                raise ValueError("Model does not support multiple lookaheads.")
+        else:
+            self.att_context_size = asr_model.cfg.encoder.att_context_size
+
+        decoding_cfg = asr_model.cfg.decoding
+        with open_dict(decoding_cfg):
+            decoding_cfg.strategy = "greedy"
+            decoding_cfg.compute_timestamps = False
+            decoding_cfg.preserve_alignments = True
+            if hasattr(asr_model, 'joint'):  # if an RNNT model
+                decoding_cfg.greedy.max_symbols = 10
+                decoding_cfg.fused_batch_size = -1
+            asr_model.change_decoding_strategy(decoding_cfg)
+
+        if hasattr(asr_model.encoder, "set_default_att_context_size"):
+            asr_model.encoder.set_default_att_context_size(att_context_size=self.att_context_size)
+
+        # chunk_size is set automatically for models trained for streaming.
+        # For models trained for offline mode with full context, we need to pass the chunk_size explicitly.
+        if self.chunk_size > 0:
+            if self.shift_size < 0:
+                shift_size = self.chunk_size
+            else:
+                shift_size = self.shift_size
+            asr_model.encoder.setup_streaming_params(
+                chunk_size=self.chunk_size, left_chunks=self.left_chunks, shift_size=shift_size
+            )
+
+        asr_model.eval()
+        return asr_model
+
+    def _get_best_hypothesis(self, encoded, encoded_len, partial_hypotheses=None):
+        if self.decoder_type == "ctc":
+            best_hyp = self.asr_model.decoding.ctc_decoder_predictions_tensor(
+                encoded,
+                encoded_len,
+                return_hypotheses=True,
+            )
+        elif self.decoder_type == "rnnt":
+            best_hyp = self.asr_model.decoding.rnnt_decoder_predictions_tensor(
+                encoded, encoded_len, return_hypotheses=True, partial_hypotheses=partial_hypotheses
+            )
+        else:
+            raise ValueError("Decoder type not supported for this model.")
+        return best_hyp
+
+    def _get_tokens_and_probs_from_alignments(self, alignments):
+        tokens = []
+        probs = []
+        if self.decoder_type == "ctc":
+            all_logits = alignments[0]
+            all_tokens = alignments[1]
+            for i in range(len(all_tokens)):
+                token_id = int(all_tokens[i])
+                if token_id != self.blank_id:
+                    tokens.append(token_id)
+                    logits = all_logits[i]  # shape (vocab_size,)
+                    probs_i = torch.softmax(logits, dim=-1)[token_id].item()
+                    probs.append(probs_i)
+        elif self.decoder_type == "rnnt":
+            for t in range(len(alignments)):
+                for u in range(len(alignments[t])):
+                    logits, token_id = alignments[t][u]  # (logits, token_id)
+                    token_id = int(token_id)
+                    if token_id != self.blank_id:
+                        tokens.append(token_id)
+                        probs_i = torch.softmax(logits, dim=-1)[token_id].item()
+                        probs.append(probs_i)
+        else:
+            raise ValueError("Decoder type not supported for this model.")
+
+        return tokens, probs
+
+    def transcribe(self, audio: bytes, stream_id: str = "default") -> ASRResult:
+        start_time = time.time()
+
+        # Convert bytes to numpy array
+        audio_array = np.frombuffer(audio, dtype=np.int16).astype(np.float32) / 32768.0
+
+        self._audio_buffer.update(audio_array)
+
+        features = self._audio_buffer.get_feature_buffer()
+        feature_lengths = torch.tensor([features.shape[1]], device=self.device)
+        features = features.unsqueeze(0)  # Add batch dimension
+
+        with torch.no_grad():
+            (
+                encoded,
+                encoded_len,
+                cache_last_channel,
+                cache_last_time,
+                cache_last_channel_len,
+            ) = self.asr_model.encoder.cache_aware_stream_step(
+                processed_signal=features,
+                processed_signal_length=feature_lengths,
+                cache_last_channel=self._cache_last_channel,
+                cache_last_time=self._cache_last_time,
+                cache_last_channel_len=self._cache_last_channel_len,
+                keep_all_outputs=False,
+                drop_extra_pre_encoded=self.drop_extra_pre_encoded,
+            )
+
+        best_hyp = self._get_best_hypothesis(encoded, encoded_len, partial_hypotheses=self._previous_hypotheses)
+
+        self._previous_hypotheses = best_hyp
+        self._cache_last_channel = cache_last_channel
+        self._cache_last_time = cache_last_time
+        self._cache_last_channel_len = cache_last_channel_len
+
+        tokens, probs = self._get_tokens_and_probs_from_alignments(best_hyp[0].alignments)
+
+        text = self.get_text_from_tokens(tokens)
+
+        is_final = False
+        eou_latency = None
+        eob_latency = None
+        eou_prob = None
+        eob_prob = None
+        current_timestamp = time.time()
+        if self.eou_string in text or self.eob_string in text:
+            is_final = True
+            if self.eou_string in text:
+                eou_latency = (
+                    current_timestamp - self._last_transcript_timestamp if text.strip() == self.eou_string else 0.0
+                )
+                eou_prob = self.get_eou_probability(tokens, probs, self.eou_string)
+            if self.eob_string in text:
+                eob_latency = (
+                    current_timestamp - self._last_transcript_timestamp if text.strip() == self.eob_string else 0.0
+                )
+                eob_prob = self.get_eou_probability(tokens, probs, self.eob_string)
+            self.reset_state(stream_id=stream_id)
+        if text.strip():
+            self._last_transcript_timestamp = current_timestamp
+
+        processing_time = time.time() - start_time
+        return ASRResult(
+            text=text,
+            is_final=is_final,
+            eou_latency=eou_latency,
+            eob_latency=eob_latency,
+            eou_prob=eou_prob,
+            eob_prob=eob_prob,
+            processing_time=processing_time,
+        )
+
+    def reset_state(self, stream_id: str = "default"):
+        self._audio_buffer.reset()
+        self._reset_cache()
+        self._previous_hypotheses = self._get_blank_hypothesis()
+        self._last_transcript_timestamp = time.time()
+
+    def get_eou_probability(self, tokens: List[int], probs: List[float], eou_string: str = "<EOU>") -> float:
+        text_tokens = self.tokenizer.ids_to_tokens(tokens)
+        eou_index = text_tokens.index(eou_string)
+        return probs[eou_index]

nemo/agents/voice_agent/pipecat/services/nemo/streaming_diar.py

@@ -0,0 +1,212 @@
+# Copyright (c) 2025, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# NOTE: This file will be deprecated in the future, as the new inference pipeline will replace it.
+
+from dataclasses import dataclass
+from typing import Tuple
+
+import numpy as np
+import torch
+from torch import Tensor
+
+from nemo.agents.voice_agent.pipecat.services.nemo.utils import CacheFeatureBufferer
+from nemo.collections.asr.models import SortformerEncLabelModel
+
+from nemo.collections.asr.modules.sortformer_modules import StreamingSortformerState
+
+
+@dataclass
+class DiarizationConfig:
+    """Diarization configuration parameters for inference."""
+
+    model_path: str = "nvidia/diar_streaming_sortformer_4spk-v2"
+    device: str = "cuda"
+
+    log: bool = False  # If True, log will be printed
+    max_num_speakers: int = 4
+    spkcache_len: int = 188
+    spkcache_refresh_rate: int = 144
+    fifo_len: int = 188
+    chunk_len: int = 6
+    chunk_left_context: int = 1
+    chunk_right_context: int = 7
+
+
+class NeMoStreamingDiarService:
+    def __init__(
+        self,
+        cfg: DiarizationConfig,
+        model: str,
+        frame_len_in_secs: float = 0.08,
+        sample_rate: int = 16000,
+        left_offset: int = 8,
+        right_offset: int = 8,
+        use_amp: bool = False,
+        compute_dtype: torch.dtype = torch.float32,
+    ):
+        self.model = model
+        self.cfg = cfg
+        self.cfg.model_path = model
+        self.diarizer = self.build_diarizer()
+        self.device = cfg.device
+        self.use_amp = use_amp
+        self.compute_dtype = compute_dtype
+        self.frame_len_in_secs = frame_len_in_secs
+        self.left_offset = left_offset
+        self.right_offset = right_offset
+        self.chunk_size = self.cfg.chunk_len
+        self.buffer_size_in_secs = (
+            self.cfg.chunk_len * self.frame_len_in_secs + (self.left_offset + self.right_offset) * 0.01
+        )
+        self.max_num_speakers = self.cfg.max_num_speakers
+
+        self.feature_bufferer = CacheFeatureBufferer(
+            sample_rate=sample_rate,
+            buffer_size_in_secs=self.buffer_size_in_secs,
+            chunk_size_in_secs=self.cfg.chunk_len * self.frame_len_in_secs,
+            preprocessor_cfg=self.diarizer.cfg.preprocessor,
+            device=self.device,
+        )
+        self.streaming_state = self.init_streaming_state(batch_size=1)
+        self.total_preds = torch.zeros((1, 0, self.max_num_speakers), device=self.diarizer.device)
+
+        print(f"NeMoStreamingDiarService initialized with model `{model}` on device `{self.device}`")
+
+    def build_diarizer(self):
+        if self.cfg.model_path.endswith(".nemo"):
+            diar_model = SortformerEncLabelModel.restore_from(self.cfg.model_path, map_location=self.cfg.device)
+        else:
+            diar_model = SortformerEncLabelModel.from_pretrained(self.cfg.model_path, map_location=self.cfg.device)
+
+        # Steaming mode setup
+        diar_model.sortformer_modules.chunk_len = self.cfg.chunk_len
+        diar_model.sortformer_modules.spkcache_len = self.cfg.spkcache_len
+        diar_model.sortformer_modules.chunk_left_context = self.cfg.chunk_left_context
+        diar_model.sortformer_modules.chunk_right_context = self.cfg.chunk_right_context
+        diar_model.sortformer_modules.fifo_len = self.cfg.fifo_len
+        diar_model.sortformer_modules.log = self.cfg.log
+        diar_model.sortformer_modules.spkcache_refresh_rate = self.cfg.spkcache_refresh_rate
+        diar_model.eval()
+
+        return diar_model
+
+    def print_diar_result(self, diar_result: np.ndarray):
+        for t in range(diar_result.shape[0]):
+            spk_probs = ""
+            for s in range(diar_result.shape[1]):
+                spk_probs += f"{diar_result[t, s]:.2f} "
+            print(f"Time {t}: {spk_probs}")
+
+    def diarize(self, audio: bytes, stream_id: str = "default") -> str:
+
+        audio_array = np.frombuffer(audio, dtype=np.int16).astype(np.float32) / 32768.0
+
+        self.feature_bufferer.update(audio_array)
+
+        features = self.feature_bufferer.get_feature_buffer()
+        feature_buffers = features.unsqueeze(0)  # add batch dimension
+        feature_buffers = feature_buffers.transpose(1, 2)  # [batch, feature, time] -> [batch, time, feature]
+        feature_buffer_lens = torch.tensor([feature_buffers.shape[1]], device=self.device)
+        self.streaming_state, chunk_preds = self.stream_step(
+            processed_signal=feature_buffers,
+            processed_signal_length=feature_buffer_lens,
+            streaming_state=self.streaming_state,
+            total_preds=self.total_preds,
+            left_offset=self.left_offset,
+            right_offset=self.right_offset,
+        )
+        self.total_preds = chunk_preds
+        diar_result = chunk_preds[:, -self.chunk_size :, :].clone().cpu().numpy()
+        return diar_result[0]  # tensor of shape [6, 4]
+
+    def reset_state(self, stream_id: str = "default"):
+        self.feature_bufferer.reset()
+        self.streaming_state = self.init_streaming_state(batch_size=1)
+        self.total_preds = torch.zeros((1, 0, self.max_num_speakers), device=self.diarizer.device)
+
+    def init_streaming_state(self, batch_size: int = 1) -> StreamingSortformerState:
+        """
+        Initialize the streaming state for the diarization model.
+
+        Args:
+            batch_size: The batch size to use.
+
+        Returns:
+            SortformerStreamingState: The initialized streaming state.
+        """
+        # Use the model's init_streaming_state method but convert to SortformerStreamingState format
+        nemo_state = self.diarizer.sortformer_modules.init_streaming_state(
+            batch_size=batch_size, async_streaming=self.diarizer.async_streaming, device=self.device
+        )
+
+        return nemo_state
+
+    def stream_step(
+        self,
+        processed_signal: Tensor,
+        processed_signal_length: Tensor,
+        streaming_state: StreamingSortformerState,
+        total_preds: Tensor,
+        left_offset: int = 0,
+        right_offset: int = 0,
+    ) -> Tuple[StreamingSortformerState, Tensor]:
+        """
+        Execute a single streaming step for diarization.
+
+        Args:
+            processed_signal: The processed audio signal.
+            processed_signal_length: The length of the processed signal.
+            streaming_state: The current streaming state.
+            total_preds: The total predictions so far.
+            left_offset: The left offset for the current chunk.
+            right_offset: The right offset for the current chunk.
+
+        Returns:
+            Tuple[SortformerStreamingState, Tensor]: The updated streaming state and predictions.
+        """
+        # Move tensors to correct device
+        if processed_signal.device != self.device:
+            processed_signal = processed_signal.to(self.device)
+
+        if processed_signal_length.device != self.device:
+            processed_signal_length = processed_signal_length.to(self.device)
+
+        if total_preds is not None and total_preds.device != self.device:
+            total_preds = total_preds.to(self.device)
+
+        with (
+            torch.amp.autocast(device_type=self.device, dtype=self.compute_dtype, enabled=self.use_amp),
+            torch.inference_mode(),
+            torch.no_grad(),
+        ):
+            try:
+                # Call the model's forward_streaming_step method
+                streaming_state, diar_pred_out_stream = self.diarizer.forward_streaming_step(
+                    processed_signal=processed_signal,
+                    processed_signal_length=processed_signal_length,
+                    streaming_state=streaming_state,
+                    total_preds=total_preds,
+                    left_offset=left_offset,
+                    right_offset=right_offset,
+                )
+            except Exception as e:
+                print(f"Error in diarizer streaming step: {e}")
+                # print the stack trace
+                import traceback
+
+                traceback.print_exc()
+                # Return the existing state and preds if there's an error
+                return streaming_state, total_preds
+
+        return streaming_state, diar_pred_out_stream

nemo/agents/voice_agent/pipecat/services/nemo/stt.py

@@ -0,0 +1,316 @@
+# Copyright (c) 2025, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import asyncio
+from datetime import datetime
+from typing import AsyncGenerator, List, Optional
+
+from loguru import logger
+from pipecat.frames.frames import (
+    CancelFrame,
+    EndFrame,
+    ErrorFrame,
+    Frame,
+    InterimTranscriptionFrame,
+    StartFrame,
+    TranscriptionFrame,
+    VADUserStartedSpeakingFrame,
+    VADUserStoppedSpeakingFrame,
+)
+from pipecat.processors.frame_processor import FrameDirection
+from pipecat.services.stt_service import STTService
+from pipecat.transcriptions.language import Language
+from pipecat.utils.time import time_now_iso8601
+from pipecat.utils.tracing.service_decorators import traced_stt
+from pydantic import BaseModel
+
+from nemo.agents.voice_agent.pipecat.services.nemo.audio_logger import AudioLogger
+from nemo.agents.voice_agent.pipecat.services.nemo.streaming_asr import NemoStreamingASRService
+
+ASR_EOU_MODELS = ["nvidia/parakeet_realtime_eou_120m-v1"]
+
+try:
+    # disable nemo logging
+    from nemo.utils import logging
+
+    level = logging.getEffectiveLevel()
+    logging.setLevel(logging.CRITICAL)
+
+
+except ModuleNotFoundError as e:
+    logger.error(f"Exception: {e}")
+    logger.error('In order to use NVIDIA NeMo STT, you need to `pip install "nemo_toolkit[all]"`.')
+    raise Exception(f"Missing module: {e}")
+
+
+class NeMoSTTInputParams(BaseModel):
+    """Input parameters for NeMo STT service."""
+
+    language: Optional[Language] = Language.EN_US
+    att_context_size: Optional[List] = [70, 1]
+    frame_len_in_secs: Optional[float] = 0.08  # 80ms for FastConformer model
+    config_path: Optional[str] = None  # path to the Niva ASR config file
+    raw_audio_frame_len_in_secs: Optional[float] = 0.016  # 16ms for websocket transport
+    buffer_size: Optional[int] = 5  # number of audio frames to buffer, 1 frame is 16ms
+
+
+class NemoSTTService(STTService):
+    """NeMo Speech-to-Text service for Pipecat integration."""
+
+    def __init__(
+        self,
+        *,
+        model: Optional[str] = "nnvidia/parakeet_realtime_eou_120m-v1",
+        device: Optional[str] = "cuda:0",
+        sample_rate: Optional[int] = 16000,
+        params: Optional[NeMoSTTInputParams] = None,
+        has_turn_taking: Optional[bool] = None,  # if None, it will be set by the model name
+        backend: Optional[str] = "legacy",
+        decoder_type: Optional[str] = "rnnt",
+        audio_logger: Optional[AudioLogger] = None,
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+        self._queue = asyncio.Queue()
+        self._sample_rate = sample_rate
+        self._params = params or NeMoSTTInputParams()
+        self._model_name = model
+        if has_turn_taking is None:
+            has_turn_taking = True if model in ASR_EOU_MODELS else False
+            logger.info(f"Setting has_turn_taking to `{has_turn_taking}` based on model name: `{model}`")
+        self._has_turn_taking = has_turn_taking
+        self._backend = backend
+        self._decoder_type = decoder_type
+        self._audio_logger = audio_logger
+        self._is_vad_active = False
+        logger.info(f"NeMoSTTInputParams: {self._params}")
+
+        self._device = device
+
+        self._load_model()
+
+        self.audio_buffer = []
+        self.user_is_speaking = False
+
+    def _load_model(self):
+        if self._backend == "legacy":
+            self._model = NemoStreamingASRService(
+                self._model_name,
+                self._params.att_context_size,
+                device=self._device,
+                decoder_type=self._decoder_type,
+                frame_len_in_secs=self._params.frame_len_in_secs,
+            )
+        else:
+            raise ValueError(f"Invalid ASR backend: {self._backend}")
+
+    def can_generate_metrics(self) -> bool:
+        """Indicates whether this service can generate metrics.
+
+        Returns:
+            bool: True, as this service supports metric generation.
+        """
+        return True
+
+    async def start(self, frame: StartFrame):
+        """Handle service start.
+
+        Args:
+            frame: StartFrame containing initial configuration
+        """
+        await super().start(frame)
+
+        # Initialize the model if not already done
+        if not hasattr(self, "_model"):
+            self._load_model()
+
+    async def stop(self, frame: EndFrame):
+        """Handle service stop.
+
+        Args:
+            frame: EndFrame that triggered this method
+        """
+        await super().stop(frame)
+        # Clear any internal state if needed
+        await self._queue.put(None)  # Signal to stop processing
+
+    async def cancel(self, frame: CancelFrame):
+        """Handle service cancellation.
+
+        Args:
+            frame: CancelFrame that triggered this method
+        """
+        await super().cancel(frame)
+        # Clear any internal state
+        await self._queue.put(None)  # Signal to stop processing
+        self._queue = asyncio.Queue()  # Reset the queue
+
+    async def run_stt(self, audio: bytes) -> AsyncGenerator[Frame, None]:
+        """Process audio data and generate transcription frames.
+
+        Args:
+            audio: Raw audio bytes to transcribe
+
+        Yields:
+            Frame: Transcription frames containing the results
+        """
+        timestamp_now = datetime.now()
+        await self.start_ttfb_metrics()
+        await self.start_processing_metrics()
+        if self._audio_logger is not None and self._audio_logger.first_audio_timestamp is None:
+            self._audio_logger.first_audio_timestamp = timestamp_now
+
+        try:
+            is_final = False
+            user_has_finished = False
+            transcription = None
+            self.audio_buffer.append(audio)
+            if len(self.audio_buffer) >= self._params.buffer_size:
+                audio = b"".join(self.audio_buffer)
+                self.audio_buffer = []
+
+                # Append to continuous user audio buffer for stereo conversation recording
+                if self._audio_logger is not None:
+                    self._audio_logger.append_continuous_user_audio(audio)
+
+                asr_result = self._model.transcribe(audio)
+                transcription = asr_result.text
+                is_final = asr_result.is_final
+                if self._audio_logger is not None:
+                    if self._is_vad_active:
+                        is_first_frame = False
+                        self._audio_logger.turn_audio_buffer.append(audio)
+                        # Accumulate transcriptions for turn-based logging
+                        if transcription:
+                            self._audio_logger.turn_transcription_buffer.append(transcription)
+                            self._audio_logger.stage_turn_audio_and_transcription(
+                                timestamp_now=timestamp_now,
+                                is_first_frame=is_first_frame,
+                                additional_metadata={
+                                    "model": self._model_name,
+                                    "backend": self._backend,
+                                },
+                            )
+                eou_latency = asr_result.eou_latency
+                eob_latency = asr_result.eob_latency
+                eou_prob = asr_result.eou_prob
+                eob_prob = asr_result.eob_prob
+                if eou_latency is not None:
+                    logger.debug(
+                        f"EOU latency: {eou_latency: .4f} seconds. EOU probability: {eou_prob: .2f}."
+                        f"Processing time: {asr_result.processing_time: .4f} seconds."
+                    )
+                    user_has_finished = True
+                if eob_latency is not None:
+                    logger.debug(
+                        f"EOB latency: {eob_latency: .4f} seconds. EOB probability: {eob_prob: .2f}."
+                        f"Processing time: {asr_result.processing_time: .4f} seconds."
+                    )
+                    user_has_finished = True
+                await self.stop_ttfb_metrics()
+                await self.stop_processing_metrics()
+
+            if transcription:
+                logger.debug(f"Transcription (is_final={is_final}): `{transcription}`")
+                self.user_is_speaking = True if not user_has_finished else False
+
+                # Get the language from params or default to EN_US
+                language = self._params.language if self._params else Language.EN_US
+
+                # Create and push the transcription frame
+                if self._has_turn_taking:
+                    # if turn taking is enabled, we push interim transcription frames
+                    # and let the turn taking service handle the final transcription
+                    frame_type = InterimTranscriptionFrame
+                else:
+                    # otherwise, we use the is_final flag to determine the frame type
+                    frame_type = TranscriptionFrame if is_final else InterimTranscriptionFrame
+                await self.push_frame(
+                    frame_type(
+                        transcription,
+                        "",  # No speaker ID in this implementation
+                        time_now_iso8601(),
+                        language,
+                        result={"text": transcription},
+                    )
+                )
+
+                # Handle the transcription
+                await self._handle_transcription(
+                    transcript=transcription,
+                    is_final=is_final,
+                    language=language,
+                )
+
+            yield None
+
+        except Exception as e:
+            logger.error(f"Error in NeMo STT processing: {e}")
+            await self.push_frame(
+                ErrorFrame(
+                    str(e),
+                    time_now_iso8601(),
+                )
+            )
+            yield None
+
+    @traced_stt
+    async def _handle_transcription(self, transcript: str, is_final: bool, language: Optional[str] = None):
+        """Handle a transcription result.
+
+        Args:
+            transcript: The transcribed text
+            is_final: Whether this is a final transcription
+            language: The language of the transcription
+        """
+        pass  # Base implementation - can be extended for specific handling needs
+
+    async def set_language(self, language: Language):
+        """Update the service's recognition language.
+
+        Args:
+            language: New language for recognition
+        """
+        if self._params:
+            self._params.language = language
+        else:
+            self._params = NeMoSTTInputParams(language=language)
+
+        logger.info(f"Switching STT language to: {language}")
+
+    async def set_model(self, model: str):
+        """Update the service's model.
+
+        Args:
+            model: New model name/path to use
+        """
+        await super().set_model(model)
+        self._model_name = model
+        self._load_model()
+
+    async def process_frame(self, frame: Frame, direction: FrameDirection):
+        """Process incoming frames and handle VAD events."""
+        if isinstance(frame, VADUserStoppedSpeakingFrame) and isinstance(self._model, NemoStreamingASRService):
+            # manualy reset the state of the model when end of utterance is detected by VAD
+            logger.debug("Resetting state of the model due to VADUserStoppedSpeakingFrame")
+            if self.user_is_speaking:
+                logger.debug(
+                    "[EOU missing] STT failed to detect end of utterance before VAD detected user stopped speaking"
+                )
+            self._model.reset_state()
+            self._is_vad_active = False
+        elif isinstance(frame, VADUserStartedSpeakingFrame):
+            self._is_vad_active = True
+
+        await super().process_frame(frame, direction)

nemo/agents/voice_agent/pipecat/services/nemo/tts.py

@@ -0,0 +1,892 @@
+# Copyright (c) 2025, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import asyncio
+import inspect
+import uuid
+from collections.abc import AsyncGenerator
+from datetime import datetime
+from typing import Iterator, List, Optional
+
+import numpy as np
+import torch
+from loguru import logger
+from omegaconf import DictConfig, OmegaConf
+from pipecat.frames.frames import (
+    CancelFrame,
+    EndFrame,
+    ErrorFrame,
+    Frame,
+    LLMTextFrame,
+    StartFrame,
+    TTSAudioRawFrame,
+    TTSStartedFrame,
+    TTSStoppedFrame,
+)
+from pipecat.services.llm_service import FunctionCallParams
+from pipecat.services.tts_service import TTSService
+
+from nemo.agents.voice_agent.pipecat.services.nemo.audio_logger import AudioLogger
+from nemo.agents.voice_agent.pipecat.utils.text.simple_text_aggregator import SimpleSegmentedTextAggregator
+from nemo.agents.voice_agent.utils.tool_calling.mixins import ToolCallingMixin
+from nemo.collections.tts.models import FastPitchModel, HifiGanModel
+
+
+class BaseNemoTTSService(TTSService, ToolCallingMixin):
+    """Text-to-Speech service using Nemo TTS models.
+
+    This service works with any TTS model that exposes a generate(text) method
+    that returns audio data. The TTS generation runs in a dedicated background thread to
+    avoid blocking the main asyncio event loop, following the same pattern as NemoDiarService.
+
+    Args:
+        model: TTS model instance with a generate(text) method
+        sample_rate: Audio sample rate in Hz (defaults to 22050)
+        **kwargs: Additional arguments passed to TTSService
+    """
+
+    def __init__(
+        self,
+        *,
+        model,
+        device: str = "cuda",
+        sample_rate: int = 22050,
+        think_tokens: Optional[List[str]] = None,
+        audio_logger: Optional[AudioLogger] = None,
+        ignore_strings: Optional[List[str]] = None,
+        **kwargs,
+    ):
+        super().__init__(sample_rate=sample_rate, **kwargs)
+        logger.info(f"Initializing TTS service with model: {model} and device: {device}")
+        self._model_name = model
+        self._device = device
+        self._model = self._setup_model()
+        self._think_tokens = think_tokens
+        self._audio_logger = audio_logger
+        if think_tokens is not None:
+            assert (
+                isinstance(think_tokens, list) and len(think_tokens) == 2
+            ), f"think_tokens must be a list of two strings, but got type {type(think_tokens)}: {think_tokens}"
+        self._ignore_strings = set(ignore_strings) if ignore_strings is not None else None
+        # Background processing infrastructure - no response handler needed
+        self._tts_queue = asyncio.Queue()
+        self._processing_task = None
+        self._processing_running = False
+
+        # Track pending requests with their response queues
+        self._pending_requests = {}
+        self._have_seen_think_tokens = False
+
+    def reset(self):
+        """Reset the TTS service."""
+        self._text_aggregator.reset()
+
+    def setup_tool_calling(self):
+        """
+        Setup the tool calling mixin by registering all available tools.
+        """
+        pass  # No tools by default
+
+    def _setup_model(self):
+        raise NotImplementedError("Subclass must implement _setup_model")
+
+    def _generate_audio(self, text: str) -> Iterator[np.ndarray]:
+        raise NotImplementedError("Subclass must implement _generate_audio")
+
+    def can_generate_metrics(self) -> bool:
+        """If the TTS service can generate metrics."""
+        return True
+
+    async def start(self, frame: StartFrame):
+        """Handle service start."""
+        await super().start(frame)
+
+        # Initialize the model if not already done
+        if not hasattr(self, "_model") or self._model is None:
+            self._model = self._setup_model()
+
+        # Only start background processing task - no response handler needed
+        if not self._processing_task:
+            self._processing_task = self.create_task(self._processing_task_handler())
+
+    async def stop(self, frame: EndFrame):
+        """Handle service stop."""
+        await super().stop(frame)
+        await self._stop_tasks()
+
+    async def cancel(self, frame: CancelFrame):
+        """Handle service cancellation."""
+        await super().cancel(frame)
+        await self._stop_tasks()
+
+    async def _stop_tasks(self):
+        """Stop background processing tasks."""
+        self._processing_running = False
+        await self._tts_queue.put(None)  # Signal to stop processing
+
+        if self._processing_task:
+            await self.cancel_task(self._processing_task)
+            self._processing_task = None
+
+    def _tts_processor(self):
+        """Background processor that handles TTS generation calls."""
+        try:
+            while self._processing_running:
+                try:
+                    future = asyncio.run_coroutine_threadsafe(self._tts_queue.get(), self.get_event_loop())
+                    request = future.result()
+
+                    if request is None:  # Stop signal
+                        logger.debug("Received stop signal in TTS background processor")
+                        break
+
+                    text, request_id = request
+                    logger.debug(f"Processing TTS request for text: [{text}]")
+
+                    # Get the response queue for this request
+                    response_queue = None
+                    future = asyncio.run_coroutine_threadsafe(
+                        self._get_response_queue(request_id), self.get_event_loop()
+                    )
+                    response_queue = future.result()
+
+                    if response_queue is None:
+                        logger.warning(f"No response queue found for request {request_id}")
+                        continue
+
+                    # Process TTS generation
+                    try:
+                        audio_result = self._generate_audio(text)
+
+                        # Send result directly to the waiting request
+                        asyncio.run_coroutine_threadsafe(
+                            response_queue.put(('success', audio_result)), self.get_event_loop()
+                        )
+                    except Exception as e:
+                        logger.error(f"Error in TTS generation: {e}")
+                        # Send error directly to the waiting request
+                        asyncio.run_coroutine_threadsafe(response_queue.put(('error', e)), self.get_event_loop())
+
+                except Exception as e:
+                    logger.error(f"Error in background TTS processor: {e}")
+
+        except Exception as e:
+            logger.error(f"Background TTS processor fatal error: {e}")
+        finally:
+            logger.debug("Background TTS processor stopped")
+
+    async def _get_response_queue(self, request_id: str):
+        """Get the response queue for a specific request."""
+        return self._pending_requests.get(request_id)
+
+    async def _processing_task_handler(self):
+        """Handler for background processing task."""
+        try:
+            self._processing_running = True
+            logger.debug("Starting background TTS processing task")
+            await asyncio.to_thread(self._tts_processor)
+        except asyncio.CancelledError:
+            logger.debug("Background TTS processing task cancelled")
+            self._processing_running = False
+            raise
+        finally:
+            self._processing_running = False
+
+    def _handle_think_tokens(self, text: str) -> Optional[str]:
+        """
+        Handle the thinking tokens for TTS.
+        If the thinking tokens are not provided, return the text as it is.
+        Otherwise:
+            If both thinking tokens appear in the text, return the text after the end of thinking tokens.
+            If the LLM is thinking, return None.
+            If the LLM is done thinking, return the text after the end of thinking tokens.
+            If the LLM starts thinking, return the text before the start of thinking tokens.
+            If the LLM is not thinking, return the text as is.
+        """
+        if not self._think_tokens or not text:
+            return text
+        elif self._think_tokens[0] in text and self._think_tokens[1] in text:
+            # LLM finishes thinking in one chunk or outputs dummy thinking tokens
+            logger.debug(f"LLM finishes thinking: {text}")
+            idx = text.index(self._think_tokens[1])
+            # only return the text after the end of thinking tokens
+            text = text[idx + len(self._think_tokens[1]) :]
+            self._have_seen_think_tokens = False
+            logger.debug(f"Returning text after thinking: {text}")
+            return text
+        elif self._have_seen_think_tokens:
+            # LLM is thinking
+            if self._think_tokens[1] not in text:
+                logger.debug(f"LLM is still thinking: {text}")
+                # LLM is still thinking
+                return None
+            else:
+                # LLM is done thinking
+                logger.debug(f"LLM is done thinking: {text}")
+                idx = text.index(self._think_tokens[1])
+                # only return the text after the end of thinking tokens
+                text = text[idx + len(self._think_tokens[1]) :]
+                self._have_seen_think_tokens = False
+                logger.debug(f"Returning text after thinking: {text}")
+                return text
+        elif self._think_tokens[0] in text:
+            # LLM now starts thinking
+            logger.debug(f"LLM starts thinking: {text}")
+            self._have_seen_think_tokens = True
+            # return text before the start of thinking tokens
+            idx = text.index(self._think_tokens[0])
+            text = text[:idx]
+            logger.debug(f"Returning text before thinking: {text}")
+            return text
+        else:
+            # LLM is not thinking
+            return text
+
+    def _drop_special_tokens(self, text: str) -> Optional[str]:
+        """
+        Drop the special tokens from the text.
+        """
+        if self._ignore_strings is None:
+            return text
+        for ignore_string in self._ignore_strings:
+            if ignore_string in text:
+                logger.debug(f"Dropping string `{ignore_string}` from text: `{text}`")
+                text = text.replace(ignore_string, "")
+        return text
+
+    async def run_tts(self, text: str) -> AsyncGenerator[Frame, None]:
+        """Generate speech from text using the Nemo TTS model."""
+
+        if self._think_tokens is not None:
+            text = self._handle_think_tokens(text)
+
+        if not text:
+            yield None
+            return
+
+        if self._ignore_strings is not None:
+            text = self._drop_special_tokens(text)
+
+        logger.debug(f"{self}: Generating TTS [{text}]")
+
+        try:
+            await self.start_ttfb_metrics()
+            yield TTSStartedFrame()
+
+            # Increment turn index at the start of agent speaking (only if speaker changed)
+            if self._audio_logger is not None:
+                self._audio_logger.increment_turn_index(speaker="agent")
+
+            # Generate unique request ID
+
+            request_id = str(uuid.uuid4())
+
+            # Create response queue for this specific request
+            request_queue = asyncio.Queue()
+            self._pending_requests[request_id] = request_queue
+
+            try:
+                # Queue the TTS request for background processing
+                await self._tts_queue.put((text, request_id))
+
+                # Wait for the result directly from our request queue
+                result = await request_queue.get()
+                status, data = result
+
+                if status == 'error':
+                    logger.error(f"{self} TTS generation error: {data}")
+                    yield ErrorFrame(error=f"TTS generation error: {str(data)}")
+                    return
+
+                audio_result = data
+                if audio_result is None:
+                    logger.error(f"{self} TTS model returned None for text: [{text}]")
+                    yield ErrorFrame(error="TTS generation failed - no audio returned")
+                    return
+
+                await self.start_tts_usage_metrics(text)
+
+                # Collect all audio for logging
+                all_audio_bytes = b""
+                # Capture the start time when TTS begins (not when it ends)
+                if self._audio_logger is not None and self._audio_logger.first_audio_timestamp is None:
+                    self._audio_logger.first_audio_timestamp = datetime.now()
+
+                # Process the audio result (same as before)
+                if (
+                    inspect.isgenerator(audio_result)
+                    or hasattr(audio_result, '__iter__')
+                    and hasattr(audio_result, '__next__')
+                ):
+                    # Handle generator case
+                    first_chunk = True
+                    for audio_chunk in audio_result:
+                        if first_chunk:
+                            await self.stop_ttfb_metrics()
+                            first_chunk = False
+                            # Capture start time on first chunk
+                            if self._audio_logger is not None:
+                                tts_start_time = self._audio_logger.get_time_from_start_of_session()
+
+                        if audio_chunk is None:
+                            break
+
+                        audio_bytes = self._convert_to_bytes(audio_chunk)
+                        all_audio_bytes += audio_bytes
+                        chunk_size = self.chunk_size
+                        for i in range(0, len(audio_bytes), chunk_size):
+                            audio_chunk_bytes = audio_bytes[i : i + chunk_size]
+                            if not audio_chunk_bytes:
+                                break
+
+                            frame = TTSAudioRawFrame(
+                                audio=audio_chunk_bytes, sample_rate=self.sample_rate, num_channels=1
+                            )
+                            yield frame
+                else:
+                    # Handle single result case
+                    await self.stop_ttfb_metrics()
+                    # Capture start time for single result
+                    if self._audio_logger is not None:
+                        tts_start_time = self._audio_logger.get_time_from_start_of_session()
+                    audio_bytes = self._convert_to_bytes(audio_result)
+                    all_audio_bytes = audio_bytes
+
+                    chunk_size = self.chunk_size
+                    for i in range(0, len(audio_bytes), chunk_size):
+                        chunk = audio_bytes[i : i + chunk_size]
+                        if not chunk:
+                            break
+
+                        frame = TTSAudioRawFrame(audio=chunk, sample_rate=self.sample_rate, num_channels=1)
+                        yield frame
+
+                # Log the complete audio if logger is available
+                if self._audio_logger is not None and all_audio_bytes:
+                    try:
+                        self._audio_logger.log_agent_audio(
+                            audio_data=all_audio_bytes,
+                            text=text,
+                            sample_rate=self.sample_rate,
+                            num_channels=1,
+                            additional_metadata={
+                                "model": self._model_name,
+                            },
+                            tts_generation_time=tts_start_time,
+                        )
+                    except Exception as e:
+                        logger.warning(f"Failed to log agent audio: {e}")
+
+                yield TTSStoppedFrame()
+
+            finally:
+                # Clean up the pending request
+                if request_id in self._pending_requests:
+                    del self._pending_requests[request_id]
+
+        except Exception as e:
+            logger.exception(f"{self} error generating TTS: {e}")
+            error_message = f"TTS generation error: {str(e)}"
+            yield ErrorFrame(error=error_message)
+
+    def _convert_to_bytes(self, audio_data) -> bytes:
+        """Convert various audio data formats to bytes."""
+        if isinstance(audio_data, (bytes, bytearray)):
+            return bytes(audio_data)
+
+        if isinstance(audio_data, np.ndarray):
+            # Ensure it's in the right format (16-bit PCM)
+            if audio_data.dtype in [np.float32, np.float64]:
+                # Convert float [-1, 1] to int16 [-32768, 32767]
+                audio_data = np.clip(audio_data, -1.0, 1.0)  # Ensure values are in range
+                audio_data = (audio_data * 32767).astype(np.int16)
+            elif audio_data.dtype != np.int16:
+                # Convert other integer types to int16
+                audio_data = audio_data.astype(np.int16)
+            return audio_data.tobytes()
+        elif hasattr(audio_data, 'tobytes'):
+            return audio_data.tobytes()
+        else:
+            return bytes(audio_data)
+
+
+class NeMoFastPitchHiFiGANTTSService(BaseNemoTTSService):
+    """Text-to-Speech service using NeMo FastPitch-Hifigan model.
+
+    More info: https://huggingface.co/nvidia/tts_en_fastpitch
+
+    Args:
+        fastpitch_model: FastPitch model name
+        hifigan_model: Hifigan model name
+        device: Device to run on (default: 'cuda')
+        **kwargs: Additional arguments passed to BaseNemoTTSService
+    """
+
+    def __init__(
+        self,
+        fastpitch_model: str = "nvidia/tts_en_fastpitch",
+        hifigan_model: str = "nvidia/tts_hifigan",
+        device: str = "cuda",
+        **kwargs,
+    ):
+        model_name = f"{fastpitch_model}+{hifigan_model}"
+        self._fastpitch_model_name = fastpitch_model
+        self._hifigan_model_name = hifigan_model
+        super().__init__(model=model_name, device=device, **kwargs)
+        self.setup_tool_calling()
+
+    def _setup_model(self):
+        logger.info(
+            f"Loading FastPitch model={self._fastpitch_model_name} and HiFiGAN model={self._hifigan_model_name}"
+        )
+        self._fastpitch_model = self._setup_fastpitch_model(self._fastpitch_model_name)
+        self._hifigan_model = self._setup_hifigan_model(self._hifigan_model_name)
+        return self._fastpitch_model, self._hifigan_model
+
+    def _setup_fastpitch_model(self, model_name: str):
+        if model_name.endswith(".nemo"):
+            fastpitch_model = FastPitchModel.restore_from(model_name, map_location=torch.device(self._device))
+        else:
+            fastpitch_model = FastPitchModel.from_pretrained(model_name, map_location=torch.device(self._device))
+        fastpitch_model.eval()
+        return fastpitch_model
+
+    def _setup_hifigan_model(self, model_name: str):
+        if model_name.endswith(".nemo"):
+            hifigan_model = HifiGanModel.restore_from(model_name, map_location=torch.device(self._device))
+        else:
+            hifigan_model = HifiGanModel.from_pretrained(model_name, map_location=torch.device(self._device))
+        hifigan_model.eval()
+        return hifigan_model
+
+    def _generate_audio(self, text: str) -> Iterator[np.ndarray]:
+        with torch.no_grad():
+            parsed = self._fastpitch_model.parse(text)
+            spectrogram = self._fastpitch_model.generate_spectrogram(tokens=parsed)
+            audio = self._hifigan_model.convert_spectrogram_to_audio(spec=spectrogram)
+            audio = audio.detach().view(-1).cpu().numpy()
+            yield audio
+
+
+class KokoroTTSService(BaseNemoTTSService):
+    """Text-to-Speech service using Kokoro-82M model.
+
+    Kokoro is an open-weight TTS model with 82 million parameters.
+    More info: https://huggingface.co/hexgrad/Kokoro-82M
+
+    Args:
+        lang_code: Language code for the model (default: 'a' for American English)
+        voice: Voice to use (default: 'af_heart')
+        device: Device to run on (default: 'cuda')
+        sample_rate: Audio sample rate in Hz (default: 24000 for Kokoro)
+        download_all: Download all models for different languages (default: True)
+        cache_models: Cache models on GPU for faster switching between languages (default: True)
+        **kwargs: Additional arguments passed to BaseNemoTTSService
+    """
+
+    def __init__(
+        self,
+        model: str = "hexgrad/Kokoro-82M",
+        lang_code: str = "a",
+        voice: str = "af_heart",
+        device: str = "cuda",
+        sample_rate: int = 24000,
+        speed: float = 1.0,
+        download_all: bool = True,
+        cache_models: bool = True,
+        **kwargs,
+    ):
+        self._lang_code = lang_code
+        self._voice = voice
+        self._speed = speed
+        assert speed > 0, "Speed must be greater than 0"
+        self._original_speed = speed
+        self._original_voice = voice
+        self._gender = 'female' if voice[1] == 'f' else 'male'
+        self._original_gender = self._gender
+        self._original_lang_code = self._lang_code
+        if download_all:
+            self._model_maps = self._download_all_models(
+                lang_code=["a", "b"], device=device, repo_id=model, cache_models=cache_models
+            )
+        else:
+            self._model_maps = {}
+        super().__init__(model=model, device=device, sample_rate=sample_rate, **kwargs)
+        self.setup_tool_calling()
+
+    def _setup_model(self, lang_code: Optional[str] = None, voice: Optional[str] = None):
+        """Initialize the Kokoro pipeline."""
+        try:
+            from kokoro import KPipeline
+        except ImportError:
+            raise ImportError(
+                "kokoro package is required for KokoroTTSService. Install it with: `pip install kokoro>=0.9.2`"
+            )
+        if lang_code is None:
+            lang_code = self._lang_code
+        if voice is None:
+            voice = self._voice
+        logger.info(f"Loading Kokoro TTS model with model={self._model_name}, lang_code={lang_code}, voice={voice}")
+        if lang_code in self._model_maps:
+            pipeline = self._model_maps[lang_code]
+        else:
+            pipeline = KPipeline(lang_code=lang_code, device=self._device, repo_id=self._model_name)
+            self._model_maps[lang_code] = pipeline
+        return pipeline
+
+    def _download_all_models(
+        self, lang_code: List[str] = ['a', 'b'], device="cuda", repo_id="hexgrad/Kokoro-82M", cache_models=True
+    ):
+        """Download all models for Kokoro TTS service."""
+        logger.info(f"Downloading all models for Kokoro TTS service with lang_code={lang_code}")
+        from kokoro import KPipeline
+
+        model_maps = {}
+
+        for lang in lang_code:
+            pipeline = KPipeline(lang_code=lang, device=device, repo_id=repo_id)
+            if cache_models:
+                model_maps[lang] = pipeline
+        torch.cuda.empty_cache()
+        return model_maps
+
+    def _generate_audio(self, text: str) -> Iterator[np.ndarray]:
+        """Generate audio using the Kokoro pipeline.
+
+        Args:
+            text: Text to convert to speech
+
+        Yields:
+            Audio data as numpy arrays
+        """
+        try:
+            # Generate audio using Kokoro pipeline
+            generator = self._model(text, voice=self._voice, speed=self._speed)
+
+            # The generator yields tuples of (gs, ps, audio)
+            # We only need the audio component
+            for i, (gs, ps, audio) in enumerate(generator):
+                logger.debug(
+                    f"Kokoro generated audio chunk {i}: gs={gs}, ps={ps},"
+                    f"audio_shape={audio.shape if hasattr(audio, 'shape') else len(audio)}"
+                )
+                if isinstance(audio, torch.Tensor):
+                    audio = audio.detach().cpu().numpy()
+                # Kokoro returns audio as numpy array in float32 format [-1, 1]
+                # The base class will handle conversion to int16 bytes
+                yield audio
+
+        except Exception as e:
+            logger.error(f"Error generating audio with Kokoro: {e}")
+            raise
+
+    async def tool_tts_set_speed(self, params: FunctionCallParams, speed_lambda: float):
+        """
+        Set a specific speaking speed of the assistant's voice.
+        This tool should be called only when the user specifies the speed explicitly,
+        such as "speak twice as fast" or "speak half as slow" or "speak 1.5 times as fast".
+
+        Inform user of the result of this tool call. After calling this tool, continue the previous
+        response if it was unfinished and was interrupted by the user, otherwise start a new response
+        and ask if the user needs help on anything else. Avoid repeating previous responses.
+
+        Args:
+            speed_lambda: positive float, the relative change of the speaking speed to the original speed.
+                        E.g., 1.0 for original speed, 1.25 for 25% faster than original speed,
+                        0.8 for 20% slower than original speed.
+
+        """
+        if speed_lambda <= 0:
+            result = {
+                "success": False,
+                "message": f"Speed remains unchanged since the change is not a positive number: {speed_lambda}",
+            }
+            logger.debug(f"Speed remains unchanged since the change is not a positive number: {speed_lambda}")
+        else:
+            self._speed = speed_lambda * self._speed
+            result = {
+                "success": True,
+                "message": f"Speed set to {speed_lambda} of the previous speed",
+            }
+            logger.debug(f"Speed set to {speed_lambda} of the previous speed {self._original_speed}")
+        await params.result_callback(result)
+
+    async def tool_tts_reset_speed(self, params: FunctionCallParams):
+        """
+        Reset the speaking speed to the original speed.
+
+        Inform user of the result of this tool call. After calling this tool, continue the previous
+        response if it was unfinished and was interrupted by the user, otherwise start a new response
+        and ask if the user needs help on anything else. Avoid repeating previous responses.
+        """
+        self._speed = self._original_speed
+        result = {"success": True, "message": "Speaking speed is reset to the original one"}
+        logger.debug(f"Speaking speed is reset to the original speed {self._original_speed}")
+        await params.result_callback(result)
+
+    async def tool_tts_speak_faster(self, params: FunctionCallParams):
+        """
+        Speak faster by increasing the speaking speed 15% faster each time this function is called.
+
+        Inform user of the result of this tool call. After calling this tool, continue the previous
+        response if it was unfinished and was interrupted by the user, otherwise start a new response
+        and ask if the user needs help on anything else. Avoid repeating previous responses.
+        """
+        speed_lambda = 1.15
+        self._speed = speed_lambda * self._speed
+        result = {
+            "success": True,
+            "message": f"Speaking speed is increased to {speed_lambda} of the previous speed",
+        }
+        logger.debug(f"Speed is set to {speed_lambda} of the previous speed, new speed is {self._speed}")
+        await params.result_callback(result)
+
+    async def tool_tts_speak_slower(self, params: FunctionCallParams):
+        """
+        Speak slower by decreasing the speaking speed 15% slower each time this function is called.
+
+        Inform user of the result of this tool call. After calling this tool, continue the previous
+        response if it was unfinished and was interrupted by the user, otherwise start a new response
+        and ask if the user needs help on anything else. Avoid repeating previous responses.
+        """
+        speed_lambda = 0.85
+        self._speed = speed_lambda * self._speed
+        result = {
+            "success": True,
+            "message": f"Speaking speed is decreased to {speed_lambda} of the previous speed",
+        }
+        logger.debug(f"Speed is set to {speed_lambda} of the previous speed, new speed is {self._speed}")
+        await params.result_callback(result)
+
+    async def tool_tts_set_voice(self, params: FunctionCallParams, accent: str, gender: str):
+        """
+        Set the accent and gender of the assistant's voice.
+        This tool should be called only when the user specifies the accent and/or gender explicitly.
+
+        Inform user of the result of this tool call. After calling this tool, continue the previous
+        response if it was unfinished and was interrupted by the user, otherwise start a new response
+        and ask if the user needs help on anything else. Avoid repeating previous responses.
+
+        Args:
+            accent: Accent for the TTS model. Must be one of 'American English', 'British English'
+                    or 'current' for keeping the current accent.
+            gender: gender of the assistant's voice. Must be one of 'male', 'female',
+                    or 'current' for keeping the current gender.
+        """
+        await params.llm.push_frame(LLMTextFrame("Just a moment."))
+
+        lang_code = "a" if accent == "American English" else "b" if accent == "British English" else "current"
+        new_lang_code = self._lang_code
+        new_gender = self._gender
+        if lang_code != 'current':
+            new_lang_code = lang_code
+        if gender != 'current':
+            new_gender = gender
+
+        if new_lang_code == 'a':
+            new_voice = 'af_heart' if new_gender == 'female' else 'am_michael'
+        elif new_lang_code == 'b':
+            new_voice = 'bf_emma' if new_gender == 'female' else 'bm_george'
+        else:
+            await params.result_callback(
+                {
+                    "success": False,
+                    "message": f"Invalid language code: {new_lang_code} or gender: {new_gender}",
+                }
+            )
+            return
+
+        new_model = await asyncio.to_thread(self._setup_model, new_lang_code, new_voice)
+        self._model = new_model
+        self._lang_code = new_lang_code
+        self._gender = new_gender
+        self._voice = new_voice
+        logger.debug(f"Language and voice are set to {new_lang_code} and {new_voice}")
+        await params.result_callback({"success": True, "message": "Voice has been updated."})
+
+    async def tool_tts_reset_voice(self, params: FunctionCallParams):
+        """
+        Reset the accent and voice to the original ones.
+
+        Inform user of the result of this tool call. After calling this tool, continue the previous
+        response if it was unfinished and was interrupted by the user, otherwise start a new response
+        and ask if the user needs help on anything else. Avoid repeating previous responses.
+
+        """
+        await params.llm.push_frame(LLMTextFrame("Of course."))
+
+        new_model = await asyncio.to_thread(self._setup_model, self._original_lang_code, self._original_voice)
+        self._model = new_model
+        self._lang_code = self._original_lang_code
+        self._gender = self._original_gender
+        self._voice = self._original_voice
+        logger.debug(
+            f"Language and voice are reset to the original ones {self._original_lang_code} and {self._original_voice}"
+        )
+        await params.result_callback({"success": True, "message": "Voice has been reset to the original one."})
+
+    def setup_tool_calling(self):
+        """
+        Setup the tool calling mixin by registering all available tools.
+        """
+        self.register_direct_function("tool_tts_reset_speed", self.tool_tts_reset_speed)
+        self.register_direct_function("tool_tts_speak_faster", self.tool_tts_speak_faster)
+        self.register_direct_function("tool_tts_speak_slower", self.tool_tts_speak_slower)
+        self.register_direct_function("tool_tts_set_speed", self.tool_tts_set_speed)
+        self.register_direct_function("tool_tts_set_voice", self.tool_tts_set_voice)
+        self.register_direct_function("tool_tts_reset_voice", self.tool_tts_reset_voice)
+
+    def reset(self):
+        """
+        Reset the voice and speed to the original ones.
+        """
+        self._text_aggregator.reset()
+        self._speed = self._original_speed
+        self._model = self._setup_model(self._original_lang_code, self._original_voice)
+        self._lang_code = self._original_lang_code
+        self._gender = self._original_gender
+        self._voice = self._original_voice
+
+
+class MagpieTTSService(BaseNemoTTSService):
+    """Text-to-Speech service using Magpie TTS model.
+
+    Magpie is a multilingual TTS model with 357 million parameters.
+    More info: https://huggingface.co/nvidia/magpie_tts_multilingual_357m
+
+    Args:
+        model: Model name or path to the Magpie TTS model.
+        language: Language code for the model (default: 'en' for English)
+        speaker: Speaker to use for the model (default: 'Sofia')
+        apply_TN: Whether to apply text normalization (default: False)
+        device: Device to run on (default: 'cuda')
+        **kwargs: Additional arguments passed to BaseNemoTTSService
+    """
+
+    SPEAKER_MAP = {"John": 0, "Sofia": 1, "Aria": 2, "Jason": 3, "Leo": 4}
+
+    def __init__(
+        self,
+        model: str = "nvidia/magpie_tts_multilingual_357m",
+        language: str = "en",
+        speaker: str = "Sofia",
+        apply_TN: bool = False,
+        device: str = "cuda",
+        **kwargs,
+    ):
+        if speaker not in self.SPEAKER_MAP:
+            raise ValueError(f"Invalid speaker: {speaker}, must be one of {list(self.SPEAKER_MAP.keys())}")
+        self._language = language
+        self._current_speaker = speaker
+        self._apply_TN = apply_TN
+        super().__init__(model=model, device=device, **kwargs)
+        self.setup_tool_calling()
+
+    def _setup_model(self):
+        from nemo.collections.tts.models import MagpieTTSModel
+
+        if self._model_name.endswith(".nemo"):
+            model = MagpieTTSModel.restore_from(self._model_name, map_location=torch.device(self._device))
+        else:
+            model = MagpieTTSModel.from_pretrained(self._model_name, map_location=torch.device(self._device))
+        model.eval()
+
+        text = "Warming up the Magpie TTS model, this will help the model to respond faster for later requests."
+        with torch.no_grad():
+            _, _ = model.do_tts(
+                text,
+                language=self._language,
+                apply_TN=self._apply_TN,
+                speaker_index=self.SPEAKER_MAP[self._current_speaker],
+            )
+        torch.cuda.empty_cache()
+        return model
+
+    def _generate_audio(self, text: str) -> Iterator[np.ndarray]:
+        audio, audio_len = self._model.do_tts(
+            text,
+            language=self._language,
+            apply_TN=self._apply_TN,
+            speaker_index=self.SPEAKER_MAP[self._current_speaker],
+        )
+        audio_len = audio_len.view(-1).item()
+        audio = audio.detach().view(-1).cpu().numpy()
+        yield audio[:audio_len]
+
+    def setup_tool_calling(self):
+        """No tools for now for Magpie TTS service."""
+        pass
+
+
+def get_tts_service_from_config(config: DictConfig, audio_logger: Optional[AudioLogger] = None) -> BaseNemoTTSService:
+    """Get the TTS service from the configuration.
+
+    Args:
+        config: The DictConfig object containing the TTS configuration.
+        audio_logger: The audio logger to use for audio logging.
+    Returns:
+        The TTS service.
+    """
+    if isinstance(config, DictConfig):
+        config = OmegaConf.to_container(config, resolve=True)
+    model = config.get("model", None)
+    device = config.get("device", "cuda")
+    if config.get("type", None) != "nemo":
+        raise ValueError(f"Invalid TTS type: {config.get('type', None)}, only 'nemo' is supported")
+    if model is None:
+        raise ValueError("Model is required for Nemo TTS service")
+
+    text_aggregator = SimpleSegmentedTextAggregator(
+        punctuation_marks=config.get("extra_separator", None),
+        ignore_marks=config.get("ignore_strings", None),
+        min_sentence_length=config.get("min_sentence_length", 5),
+        use_legacy_eos_detection=config.get("use_legacy_eos_detection", False),
+    )
+
+    if model == "fastpitch-hifigan":
+        return NeMoFastPitchHiFiGANTTSService(
+            fastpitch_model=config.get("main_model_id", None),
+            hifigan_model=config.get("sub_model_id", None),
+            device=device,
+            text_aggregator=text_aggregator,
+            think_tokens=config.get("think_tokens", None),
+            audio_logger=audio_logger,
+            ignore_strings=config.get("ignore_strings", None),
+        )
+    elif model == "magpie":
+        return MagpieTTSService(
+            model=config.get("main_model_id", None),
+            language=config.get("language", "en"),
+            speaker=config.get("speaker", "Sofia"),
+            apply_TN=config.get("apply_TN", False),
+            device=device,
+            text_aggregator=text_aggregator,
+            think_tokens=config.get("think_tokens", None),
+            audio_logger=audio_logger,
+            ignore_strings=config.get("ignore_strings", None),
+        )
+    elif model == "kokoro":
+        return KokoroTTSService(
+            model=config.get("main_model_id", "hexgrad/Kokoro-82M"),
+            voice=config.get("sub_model_id", "af_heart"),
+            device=device,
+            speed=config.get("speed", 1.0),
+            text_aggregator=text_aggregator,
+            think_tokens=config.get("think_tokens", None),
+            sample_rate=24000,
+            audio_logger=audio_logger,
+            ignore_strings=config.get("ignore_strings", None),
+        )
+    else:
+        raise ValueError(f"Invalid model: {model}, only 'fastpitch-hifigan', 'magpie' and 'kokoro' are supported")

nemo/agents/voice_agent/pipecat/services/nemo/turn_taking.py

@@ -0,0 +1,441 @@
+# Copyright (c) 2025, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import time
+from datetime import datetime
+from pathlib import Path
+from typing import List, Optional, Union
+
+import yaml
+from loguru import logger
+from pipecat.frames.frames import (
+    BotStartedSpeakingFrame,
+    BotStoppedSpeakingFrame,
+    Frame,
+    InterimTranscriptionFrame,
+    StartInterruptionFrame,
+    TranscriptionFrame,
+    UserStartedSpeakingFrame,
+    UserStoppedSpeakingFrame,
+    VADUserStartedSpeakingFrame,
+    VADUserStoppedSpeakingFrame,
+)
+from pipecat.processors.frame_processor import FrameDirection, FrameProcessor
+from pipecat.transcriptions.language import Language
+from pipecat.utils.time import time_now_iso8601
+
+from nemo.agents.voice_agent.pipecat.frames.frames import DiarResultFrame
+from nemo.agents.voice_agent.pipecat.services.nemo.audio_logger import AudioLogger
+
+
+class NeMoTurnTakingService(FrameProcessor):
+    """Service for handling turn-taking in voice conversations with backchannel detection."""
+
+    def __init__(
+        self,
+        backchannel_phrases: Union[str, List[str]] = None,
+        eou_string: str = "<EOU>",
+        eob_string: str = "<EOB>",
+        language: Language = Language.EN_US,
+        use_vad: bool = True,
+        use_diar: bool = False,
+        max_buffer_size: int = 2,
+        bot_stop_delay: float = 0.5,
+        audio_logger: Optional[AudioLogger] = None,
+        can_create_user_frames: bool = True,
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+        self.eou_string = eou_string
+        self.eob_string = eob_string
+        self.language = language
+        self.use_vad = use_vad
+        self.use_diar = use_diar
+        self.max_buffer_size = max_buffer_size
+
+        self.backchannel_phrases = self._load_backchannel_phrases(backchannel_phrases)
+        self.backchannel_phrases_nopc = set([self.clean_text(phrase) for phrase in self.backchannel_phrases])
+        self.bot_stop_delay = bot_stop_delay
+        self.can_create_user_frames = can_create_user_frames
+        # internal data
+        self._current_speaker_id = None
+        self._prev_speaker_id = None
+        self._bot_stop_time = None
+        self._bot_speaking = False
+        self._vad_user_speaking = False
+        self._have_sent_user_started_speaking = False
+        self._user_speaking_buffer = ""
+        self._audio_logger = audio_logger
+        if not self.use_vad:
+            # if vad is not used, we assume the user is always speaking
+            self._vad_user_speaking = True
+
+    def _load_backchannel_phrases(self, backchannel_phrases: Optional[Union[str, List[str]]] = None):
+        if not backchannel_phrases:
+            return []
+
+        if isinstance(backchannel_phrases, str) and Path(backchannel_phrases).is_file():
+            logger.info(f"Loading backchannel phrases from file: {backchannel_phrases}")
+            if not Path(backchannel_phrases).exists():
+                raise FileNotFoundError(f"Backchannel phrases file not found: {backchannel_phrases}")
+            with open(backchannel_phrases, "r") as f:
+                backchannel_phrases = yaml.safe_load(f)
+            if not isinstance(backchannel_phrases, list):
+                raise ValueError(f"Backchannel phrases must be a list, got {type(backchannel_phrases)}")
+            logger.info(f"Loaded {len(backchannel_phrases)} backchannel phrases from file: {backchannel_phrases}")
+        elif isinstance(backchannel_phrases, list):
+            logger.info(f"Using backchannel phrases from list: {backchannel_phrases}")
+        else:
+            raise ValueError(f"Invalid backchannel phrases: {backchannel_phrases}")
+        return backchannel_phrases
+
+    def reset(self):
+        """
+        Reset the turn-taking service.
+        """
+        self._current_speaker_id = None
+        self._prev_speaker_id = None
+        self._bot_stop_time = None
+        self._bot_speaking = False
+        self._vad_user_speaking = False
+        self._have_sent_user_started_speaking = False
+        self._user_speaking_buffer = ""
+        if not self.use_vad:
+            # if vad is not used, we assume the user is always speaking
+            self._vad_user_speaking = True
+        logger.debug("TurnTaking service reset complete")
+
+    def clean_text(self, text: str) -> str:
+        """
+        Clean the text so that it can be used for backchannel detection.
+        """
+        if self.language != Language.EN_US:
+            raise ValueError(f"Language {self.language} not supported, currently only English is supported.")
+        for eou_string in [self.eou_string, self.eob_string]:
+            if text.endswith(eou_string):
+                text = text[: -len(eou_string)].strip()
+        text = text.lower()
+        valid_chars = "abcdefghijklmnopqrstuvwxyz'"
+        text = ''.join([c for c in text if c in valid_chars or c.isspace() or c == "'"])
+        return " ".join(text.split()).strip()
+
+    def is_backchannel(self, text: str) -> bool:
+        """
+        Check if the text is a backchannel phrase.
+        """
+        if not self.backchannel_phrases:
+            return False
+        if text.startswith("<speaker_"):
+            # if the text starts with a speaker tag, we remove it
+            text = text[len("<speaker_0>") :]
+        text = self.clean_text(text)
+        return text in self.backchannel_phrases_nopc
+
+    async def process_frame(self, frame: Frame, direction: FrameDirection):
+        """Process incoming frames and handle turn-taking logic."""
+        await super().process_frame(frame, direction)
+
+        if self._bot_stop_time is not None:
+            # check if the bot has stopped speaking for more than the delay
+            if time.time() - self._bot_stop_time > self.bot_stop_delay:
+                # set the _bot_speaking flag to False to actually consider the bot as stopped speaking
+                logger.debug(
+                    f"Bot stopped speaking for more than {self.bot_stop_delay} seconds, setting _bot_speaking to False"
+                )
+                self._bot_stop_time = None
+                self._bot_speaking = False
+
+        if isinstance(frame, (TranscriptionFrame, InterimTranscriptionFrame)):
+            await self._handle_transcription(frame, direction)
+        elif isinstance(frame, VADUserStartedSpeakingFrame):
+            await self._handle_vad_user_started_speaking(frame, direction)
+        elif isinstance(frame, VADUserStoppedSpeakingFrame):
+            await self._handle_vad_user_stopped_speaking(frame, direction)
+        elif isinstance(frame, BotStartedSpeakingFrame):
+            logger.debug("BotStartedSpeakingFrame received")
+            self._bot_speaking = True
+            # Capture the actual start time when audio starts playing
+            # This is more accurate than capturing during TTS generation
+            if self._audio_logger:
+                self._audio_logger.set_agent_turn_start_time()
+        elif isinstance(frame, BotStoppedSpeakingFrame):
+            logger.debug("BotStoppedSpeakingFrame received")
+            self._bot_stop_time = time.time()
+            if self.bot_stop_delay is None or self.bot_stop_delay <= 0:
+                # only set the flag if the delay is not set or is 0
+                self._bot_speaking = False
+                logger.debug("Setting _bot_speaking to False")
+        elif isinstance(frame, DiarResultFrame):
+            logger.debug("DiarResultFrame received")
+            await self._handle_diar_result(frame, direction)
+        else:
+            await self.push_frame(frame, direction)
+
+    async def _handle_backchannel_text(self, text: str):
+        # ignore the backchannel string while bot is speaking
+        # push the backchannel string upstream, not downstream
+        await self.push_frame(
+            TranscriptionFrame(
+                text=f"({text})",
+                user_id="",
+                timestamp=time_now_iso8601(),
+                language=self.language if self.language else Language.EN_US,
+                result={"text": f"Backchannel detected: {text}"},
+            ),
+            direction=FrameDirection.UPSTREAM,
+        )
+
+    async def _handle_transcription(
+        self, frame: TranscriptionFrame | InterimTranscriptionFrame, direction: FrameDirection
+    ):
+        text_segment = frame.text
+        if self._vad_user_speaking:
+            self._user_speaking_buffer += text_segment
+            has_eou = self._user_speaking_buffer.endswith(self.eou_string)
+            has_eob = self._user_speaking_buffer.endswith(self.eob_string)
+            if has_eou:
+                # EOU detected, user is done speaking - push completed text and interrupt bot
+                logger.debug(f"<EOU> Detected: `{self._user_speaking_buffer}`")
+                completed_text = self._user_speaking_buffer[: -len(self.eou_string)].strip()
+                if self._bot_speaking and self.is_backchannel(completed_text):
+                    logger.debug(f"<EOU> detected for a backchannel phrase while bot is speaking: `{completed_text}`")
+                    await self._handle_backchannel_text(completed_text)
+                    if self._audio_logger:
+                        if self._audio_logger.staged_metadata is None:
+                            self._audio_logger.staged_metadata = {"is_backchannel": True, "start_time": datetime.now()}
+                        else:
+                            self._audio_logger.staged_metadata["is_backchannel"] = True
+
+                else:
+                    await self._handle_completed_text(completed_text, direction)
+                    await self._handle_user_interruption(UserStoppedSpeakingFrame())
+                self._user_speaking_buffer = ""
+                self._have_sent_user_started_speaking = False  # user is done speaking, so we reset the flag
+            elif has_eob and self._bot_speaking:
+                logger.debug(f"<EOB> detected while bot is speaking: `{self._user_speaking_buffer}`")
+                await self._handle_backchannel_text(str(self._user_speaking_buffer))
+                if self._audio_logger:
+                    if self._audio_logger.staged_metadata is None:
+                        self._audio_logger.staged_metadata = {"is_backchannel": True, "start_time": datetime.now()}
+                    else:
+                        self._audio_logger.staged_metadata["is_backchannel"] = True
+                self._user_speaking_buffer = ""
+                self._have_sent_user_started_speaking = False  # user is done speaking, so we reset the flag
+            else:
+                # if bot is not speaking, the backchannel string is not considered a backchannel phrase
+                # user is still speaking, so we append the text segment to the buffer
+                logger.debug(f"User is speaking: `{self._user_speaking_buffer}`")
+                if has_eob:
+                    logger.debug(
+                        f"{self.eob_string} detected but ignored (bot NOT speaking): "
+                        f"`{self._user_speaking_buffer}`"
+                    )
+                    self._user_speaking_buffer = self._user_speaking_buffer[: -len(self.eob_string)].strip()
+                # assume the last word is not completed
+                completed_words = self._user_speaking_buffer.strip().split()[:-1]
+                if len(completed_words) >= self.max_buffer_size:
+                    completed_text = " ".join(completed_words)
+                    await self._handle_completed_text(completed_text, direction, is_final=False)
+
+        else:
+            # if vad is not detecting user speaking
+            logger.debug(
+                f"VAD is not detecting user speaking, but still received text segment from STT: `{text_segment}`"
+            )
+            is_backchannel = self.is_backchannel(text_segment)
+            if text_segment.endswith(self.eob_string):
+                is_backchannel = True
+                logger.debug(f"Dropping EOB token: `{text_segment}`")
+                text_segment = text_segment[: -len(self.eob_string)].strip()
+            elif text_segment.endswith(self.eou_string):
+                logger.debug(f"Dropping EOU token: `{text_segment}`")
+                text_segment = text_segment[: -len(self.eou_string)].strip()
+
+            if not text_segment.strip():
+                return
+            if is_backchannel and self._bot_speaking:
+                logger.debug(f"Backchannel detected while bot is speaking: `{text_segment}`")
+                # push the backchannel string upstream, not downstream
+                curr_text = str(self._user_speaking_buffer + text_segment)
+                self._user_speaking_buffer = ""
+                if self._audio_logger:
+                    if self._audio_logger.staged_metadata is None:
+                        self._audio_logger.staged_metadata = {"is_backchannel": True, "start_time": datetime.now()}
+                    else:
+                        self._audio_logger.staged_metadata["is_backchannel"] = True
+                await self.push_frame(
+                    TranscriptionFrame(
+                        text=f"({curr_text})",
+                        user_id="",
+                        timestamp=time_now_iso8601(),
+                        language=self.language if self.language else Language.EN_US,
+                        result={"text": f"Backchannel detected: {self._user_speaking_buffer+text_segment}"},
+                    ),
+                    direction=FrameDirection.UPSTREAM,
+                )
+
+            else:
+                # if the text segment is not empty and have non-space characters, we append it to the buffer
+                self._user_speaking_buffer += text_segment
+                if self.is_backchannel(self._user_speaking_buffer):
+                    logger.debug(f"Backchannel detected: `{self._user_speaking_buffer}`")
+                    self._user_speaking_buffer = ""
+                    self._have_sent_user_started_speaking = False
+                    return
+                logger.debug(f"Appending text segment to user speaking buffer: `{self._user_speaking_buffer}`")
+
+    async def _handle_completed_text(self, completed_text: str, direction: FrameDirection, is_final: bool = True):
+        if not self._have_sent_user_started_speaking:
+            # if we haven't sent the user started speaking frame, we send it now
+            # so that the bot can be interrupted and be ready to respond to the new user turn
+            await self._handle_user_interruption(UserStartedSpeakingFrame())
+            self._have_sent_user_started_speaking = True
+
+        completed_text = completed_text.strip()
+        completed_text = completed_text.replace(self.eou_string, "").replace(self.eob_string, "")
+
+        if self.use_diar and not completed_text.startswith("<speaker_") and self._prev_speaker_id is not None:
+            # Add the previous speaker tag to the beginning of the text
+            completed_text = f"<speaker_{self._prev_speaker_id}> {completed_text}"
+
+        frame_type = TranscriptionFrame if is_final else InterimTranscriptionFrame
+        text_frame = frame_type(
+            text=completed_text,
+            user_id="",  # No speaker ID in this implementation
+            timestamp=time_now_iso8601(),
+            language=self.language if self.language else Language.EN_US,
+            result={"text": completed_text},
+        )
+        logger.debug(f"Pushing text frame: {text_frame}")
+        await self.push_frame(text_frame, direction)
+
+    def _contains_only_speaker_tags(self, text: str) -> bool:
+        """
+        Check if the text contains only speaker tags.
+        """
+        return text.strip().startswith("<speaker_") and text.strip().endswith(">")
+
+    async def _handle_vad_user_started_speaking(self, frame: VADUserStartedSpeakingFrame, direction: FrameDirection):
+        """
+        Handle the user started speaking frame.
+
+        If there are no backchannel phrases and we haven't sent the user started speaking frame, we send it now
+        so that the bot can be interrupted and be ready to respond to the new user turn
+        """
+        self._vad_user_speaking = True
+        logger.debug("NeMoTurnTakingService: VADUserStartedSpeakingFrame")
+        await self.push_frame(frame, direction)
+        if not self.backchannel_phrases and not self._have_sent_user_started_speaking:
+            await self._handle_user_interruption(UserStartedSpeakingFrame())
+            self._have_sent_user_started_speaking = True
+
+    async def _handle_vad_user_stopped_speaking(self, frame: VADUserStoppedSpeakingFrame, direction: FrameDirection):
+        """
+        Handle the user stopped speaking frame.
+
+        If the buffer is not empty:
+            - If bot is not speaking: push completed text regardless of backchannel
+            - If bot is speaking: ignore backchannel strings
+        If the buffer is empty, do nothing.
+        """
+        if self.use_vad:
+            self._vad_user_speaking = False
+        logger.debug("NeMoTurnTakingService: VADUserStoppedSpeakingFrame")
+        await self.push_frame(frame, direction)
+
+        # if user buffer only contains speaker tags, we don't push the completed text frame
+        if self._contains_only_speaker_tags(self._user_speaking_buffer):
+            logger.debug(f"User buffer only contains speaker tags: `{self._user_speaking_buffer}`, ignoring")
+            return
+
+        is_backchannel = self.is_backchannel(self._user_speaking_buffer)
+        if not self._user_speaking_buffer:
+            return
+        if not self._bot_speaking or not is_backchannel:
+            logger.debug(f"Bot talking: {self._bot_speaking}, backchannel: {is_backchannel}")
+            logger.debug(f"Pushing completed text frame for VAD user stopped speaking: {self._user_speaking_buffer}")
+            await self._handle_completed_text(self._user_speaking_buffer, direction)
+            self._user_speaking_buffer = ""
+            if self._have_sent_user_started_speaking:
+                await self._handle_user_interruption(UserStoppedSpeakingFrame())
+                self._have_sent_user_started_speaking = False
+        elif is_backchannel:
+            logger.debug(f"Backchannel detected: `{self._user_speaking_buffer}`")
+            if self._audio_logger:
+                self._audio_logger.save_user_audio(is_backchannel=True)
+                logger.debug(
+                    f"[TurnTakingService] Saved backchannel audio (VAD stopped): {self._user_speaking_buffer}"
+                )
+
+            await self.push_frame(
+                TranscriptionFrame(
+                    text=f"({self._user_speaking_buffer})",
+                    user_id="",
+                    timestamp=time_now_iso8601(),
+                    language=self.language if self.language else Language.EN_US,
+                    result={"text": f"Backchannel detected: {self._user_speaking_buffer}"},
+                ),
+                direction=FrameDirection.UPSTREAM,
+            )
+            self._user_speaking_buffer = ""
+            self._have_sent_user_started_speaking = False
+
+    async def _handle_user_interruption(self, frame: Frame):
+        # Adapted from BaseInputTransport._handle_user_interruption
+        if isinstance(frame, UserStartedSpeakingFrame):
+            logger.debug("User started speaking")
+            if self.can_create_user_frames:
+                logger.debug("Pushing UserStartedSpeakingFrame and StartInterruptionFrame")
+                await self.push_frame(frame)
+                await self.push_frame(StartInterruptionFrame(), direction=FrameDirection.DOWNSTREAM)
+            else:
+                logger.debug(
+                    "Skipping UserStartedSpeakingFrame and StartInterruptionFrame because can_create_user_frames is False"
+                )
+            # Record cutoff time for agent audio when TTS is interrupted
+            if self._audio_logger and self._bot_speaking:
+                self._audio_logger.set_agent_cutoff_time()
+            # Increment turn index when user starts speaking (only if speaker changed)
+            if self._audio_logger:
+                self._audio_logger.increment_turn_index(speaker="user")
+        elif isinstance(frame, UserStoppedSpeakingFrame):
+            logger.debug("User stopped speaking")
+            if self.can_create_user_frames:
+                logger.debug("Pushing UserStoppedSpeakingFrame")
+                await self.push_frame(frame)
+            else:
+                logger.debug("Skipping UserStoppedSpeakingFrame because can_create_user_frames is False")
+        else:
+            logger.debug(f"Unknown frame type for _handle_user_interruption: {type(frame)}")
+
+    async def _handle_diar_result(self, frame: DiarResultFrame, direction: FrameDirection):
+        if not self.use_diar:
+            logger.debug("Diarization is disabled, skipping")
+            return
+
+        new_speaker_id = frame.diar_result  # speaker id of the dominant speaker
+
+        # logger.debug(f"Dominant speaker ID: {dominant_speaker_id}")
+        self._prev_speaker_id = self._current_speaker_id
+        last_speaker_id = self._current_speaker_id
+
+        if not self._user_speaking_buffer.startswith("<speaker_"):
+            # add speaker tag <speaker_{speaker_id}> to the beginning of the current utterance
+            self._user_speaking_buffer = f"<speaker_{new_speaker_id}> {self._user_speaking_buffer}"
+        elif last_speaker_id != new_speaker_id:
+            # change the speaker tag to the dominant speaker id
+            self._user_speaking_buffer = self._user_speaking_buffer[len("<speaker_0>") :]
+            self._user_speaking_buffer = f"<speaker_{new_speaker_id}> {self._user_speaking_buffer}"
+        logger.debug(f"Speaker changed from {last_speaker_id} to {new_speaker_id}")
+        self._current_speaker_id = new_speaker_id

nemo/agents/voice_agent/pipecat/services/nemo/utils.py

@@ -0,0 +1,197 @@
+# Copyright (c) 2025, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# NOTE: This file will be deprecated in the future, as the new inference pipeline will replace it.
+
+import math
+
+import numpy as np
+import torch
+from omegaconf import DictConfig
+
+import nemo.collections.asr as nemo_asr
+
+LOG_MEL_ZERO = -16.635
+
+
+class AudioBufferer:
+    def __init__(self, sample_rate: int, buffer_size_in_secs: float):
+        self.buffer_size = int(buffer_size_in_secs * sample_rate)
+        self.sample_buffer = torch.zeros(self.buffer_size, dtype=torch.float32)
+
+    def reset(self) -> None:
+        """
+        Reset the buffer to zero
+        """
+        self.sample_buffer.zero_()
+
+    def update(self, audio: np.ndarray) -> None:
+        """
+        Update the buffer with the new frame
+        Args:
+            frame (Frame): frame to update the buffer with
+        """
+        if not isinstance(audio, torch.Tensor):
+            audio = torch.from_numpy(audio)
+
+        audio_size = audio.shape[0]
+        if audio_size > self.buffer_size:
+            raise ValueError(f"Frame size ({audio_size}) exceeds buffer size ({self.buffer_size})")
+
+        shift = audio_size
+        self.sample_buffer[:-shift] = self.sample_buffer[shift:].clone()
+        self.sample_buffer[-shift:] = audio.clone()
+
+    def get_buffer(self) -> torch.Tensor:
+        """
+        Get the current buffer
+        Returns:
+            torch.Tensor: current state of the buffer
+        """
+        return self.sample_buffer.clone()
+
+    def is_buffer_empty(self) -> bool:
+        """
+        Check if the buffer is empty
+        Returns:
+            bool: True if the buffer is empty, False otherwise
+        """
+        return self.sample_buffer.sum() == 0
+
+
+class CacheFeatureBufferer:
+    def __init__(
+        self,
+        sample_rate: int,
+        buffer_size_in_secs: float,
+        chunk_size_in_secs: float,
+        preprocessor_cfg: DictConfig,
+        device: torch.device,
+        fill_value: float = LOG_MEL_ZERO,
+    ):
+
+        if buffer_size_in_secs < chunk_size_in_secs:
+            raise ValueError(
+                f"Buffer size ({buffer_size_in_secs}s) should be no less than chunk size ({chunk_size_in_secs}s)"
+            )
+
+        self.sample_rate = sample_rate
+        self.buffer_size_in_secs = buffer_size_in_secs
+        self.chunk_size_in_secs = chunk_size_in_secs
+        self.device = device
+
+        if hasattr(preprocessor_cfg, 'log') and preprocessor_cfg.log:
+            self.ZERO_LEVEL_SPEC_DB_VAL = LOG_MEL_ZERO  # Log-Mel spectrogram value for zero signals
+        else:
+            self.ZERO_LEVEL_SPEC_DB_VAL = fill_value
+
+        self.n_feat = preprocessor_cfg.features
+        self.timestep_duration = preprocessor_cfg.window_stride
+        self.n_chunk_look_back = int(self.timestep_duration * self.sample_rate)
+        self.chunk_size = int(self.chunk_size_in_secs * self.sample_rate)
+        self.sample_buffer = AudioBufferer(sample_rate, buffer_size_in_secs)
+
+        self.feature_buffer_len = int(buffer_size_in_secs / self.timestep_duration)
+        self.feature_chunk_len = int(chunk_size_in_secs / self.timestep_duration)
+        self.feature_buffer = torch.full(
+            [self.n_feat, self.feature_buffer_len],
+            self.ZERO_LEVEL_SPEC_DB_VAL,
+            dtype=torch.float32,
+            device=self.device,
+        )
+
+        self.preprocessor = nemo_asr.models.ASRModel.from_config_dict(preprocessor_cfg)
+        self.preprocessor.to(self.device)
+
+    def is_buffer_empty(self) -> bool:
+        """
+        Check if the buffer is empty
+        Returns:
+            bool: True if the buffer is empty, False otherwise
+        """
+        return self.sample_buffer.is_buffer_empty()
+
+    def reset(self) -> None:
+        """
+        Reset the buffer to zero
+        """
+        self.sample_buffer.reset()
+        self.feature_buffer.fill_(self.ZERO_LEVEL_SPEC_DB_VAL)
+
+    def _update_feature_buffer(self, feat_chunk: torch.Tensor) -> None:
+        """
+        Add an extracted feature to `feature_buffer`
+        """
+        self.feature_buffer[:, : -self.feature_chunk_len] = self.feature_buffer[:, self.feature_chunk_len :].clone()
+        self.feature_buffer[:, -self.feature_chunk_len :] = feat_chunk.clone()
+
+    def preprocess(self, audio_signal: torch.Tensor) -> torch.Tensor:
+        """
+        Preprocess the audio signal using the preprocessor
+        Args:
+            audio_signal (torch.Tensor): audio signal
+        Returns:
+            torch.Tensor: preprocessed features
+        """
+        audio_signal = audio_signal.unsqueeze_(0).to(self.device)
+        audio_signal_len = torch.tensor([audio_signal.shape[1]], device=self.device)
+        features, _ = self.preprocessor(
+            input_signal=audio_signal,
+            length=audio_signal_len,
+        )
+        features = features.squeeze()
+        return features
+
+    def update(self, audio: np.ndarray) -> None:
+        """
+        Update the sample anf feature buffers with the new frame
+        Args:
+            frame (Frame): frame to update the buffer with
+        """
+
+        # Update the sample buffer with the new frame
+        self.sample_buffer.update(audio)
+
+        if math.isclose(self.buffer_size_in_secs, self.chunk_size_in_secs):
+            # If the buffer size is equal to the chunk size, just take the whole buffer
+            samples = self.sample_buffer.sample_buffer.clone()
+        else:
+            # Add look_back to have context for the first feature
+            samples = self.sample_buffer.sample_buffer[-(self.n_chunk_look_back + self.chunk_size) :]
+
+        # Get the mel spectrogram
+        features = self.preprocess(samples)
+
+        # If the features are longer than supposed to be, drop the last frames
+        # Drop the last diff frames because they might be incomplete
+        if (diff := features.shape[1] - self.feature_chunk_len - 1) > 0:
+            features = features[:, :-diff]
+
+        # Update the feature buffer with the new features
+        self._update_feature_buffer(features[:, -self.feature_chunk_len :])
+
+    def get_buffer(self) -> torch.Tensor:
+        """
+        Get the current sample buffer
+        Returns:
+            torch.Tensor: current state of the buffer
+        """
+        return self.sample_buffer.get_buffer()
+
+    def get_feature_buffer(self) -> torch.Tensor:
+        """
+        Get the current feature buffer
+        Returns:
+            torch.Tensor: current state of the feature buffer
+        """
+        return self.feature_buffer.clone()

nemo/agents/voice_agent/pipecat/transports/__init__.py

@@ -0,0 +1,13 @@
+# Copyright (c) 2025, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.

nemo/agents/voice_agent/pipecat/transports/base_input.py

@@ -0,0 +1,58 @@
+# Copyright (c) 2025, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+from loguru import logger
+from pipecat.audio.vad.vad_analyzer import VADState
+from pipecat.frames.frames import (
+    InputAudioRawFrame,
+    UserStartedSpeakingFrame,
+    UserStoppedSpeakingFrame,
+    VADUserStartedSpeakingFrame,
+    VADUserStoppedSpeakingFrame,
+)
+from pipecat.transports.base_input import BaseInputTransport as _BaseInputTransport
+
+
+class BaseInputTransport(_BaseInputTransport):
+    async def _handle_vad(self, audio_frame: InputAudioRawFrame, vad_state: VADState):
+        """Handle Voice Activity Detection results and generate appropriate frames."""
+        new_vad_state = await self._vad_analyze(audio_frame)
+        if new_vad_state != vad_state and new_vad_state != VADState.STARTING and new_vad_state != VADState.STOPPING:
+            frame = None
+            # If the turn analyser is enabled, this will prevent:
+            # - Creating the UserStoppedSpeakingFrame
+            # - Creating the UserStartedSpeakingFrame multiple times
+            can_create_user_frames = (
+                self._params.turn_analyzer is None or not self._params.turn_analyzer.speech_triggered
+            ) and self._params.can_create_user_frames
+
+            if new_vad_state == VADState.SPEAKING:
+                await self.push_frame(VADUserStartedSpeakingFrame())
+                if can_create_user_frames:
+                    frame = UserStartedSpeakingFrame()
+                else:
+                    logger.debug("base_input: VAD state changed to SPEAKING but can_create_user_frames is False")
+            elif new_vad_state == VADState.QUIET:
+                await self.push_frame(VADUserStoppedSpeakingFrame())
+                if can_create_user_frames:
+                    frame = UserStoppedSpeakingFrame()
+                else:
+                    logger.debug("base_input: VAD state changed to QUIET but can_create_user_frames is False")
+
+            if frame:
+                await self._handle_user_interruption(frame)
+
+            vad_state = new_vad_state
+        return vad_state

nemo/{collections/nlp/data/language_modeling/megatron/length_distribution_type.py → agents/voice_agent/pipecat/transports/base_transport.py}

@@ -1,4 +1,4 @@
-# Copyright (c) 2022, NVIDIA CORPORATION.  All rights reserved.
+# Copyright (c) 2025, NVIDIA CORPORATION.  All rights reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -12,10 +12,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import enum
 
+from pipecat.transports.base_transport import TransportParams as _TransportParams
 
-class LengthDistribution(enum.Enum):
-    uniform = 1
-    geometric = 2
-    truncated_normal = 3
+
+class TransportParams(_TransportParams):
+    can_create_user_frames: bool = True

nemo/agents/voice_agent/pipecat/transports/network/__init__.py

@@ -0,0 +1,13 @@
+# Copyright (c) 2025, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.

nemo/agents/voice_agent/pipecat/transports/network/websocket_server.py

@@ -0,0 +1,304 @@
+# Copyright (c) 2025, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+import asyncio
+from typing import Optional
+
+from loguru import logger
+from pipecat.frames.frames import CancelFrame, EndFrame, InputAudioRawFrame, StartFrame
+from pipecat.serializers.base_serializer import FrameSerializer
+from pipecat.transports.base_transport import BaseTransport
+from pipecat.transports.network.websocket_server import (
+    WebsocketServerCallbacks,
+    WebsocketServerOutputTransport,
+    WebsocketServerParams,
+)
+
+from nemo.agents.voice_agent.pipecat.transports.base_input import BaseInputTransport
+from nemo.agents.voice_agent.pipecat.transports.base_transport import TransportParams
+
+try:
+    import websockets
+except ModuleNotFoundError as e:
+    logger.error(f"Exception: {e}")
+    logger.error("In order to use websockets, you need to `pip install pipecat-ai[websocket]`.")
+    raise Exception(f"Missing module: {e}")
+
+
+class WebsocketServerParams(TransportParams):
+    """Configuration parameters for WebSocket server transport.
+
+    Parameters:
+        add_wav_header: Whether to add WAV headers to audio frames.
+        serializer: Frame serializer for message encoding/decoding.
+        session_timeout: Timeout in seconds for client sessions.
+    """
+
+    add_wav_header: bool = False
+    serializer: Optional[FrameSerializer] = None
+    session_timeout: Optional[int] = None
+
+
+class WebsocketServerInputTransport(BaseInputTransport):
+    """WebSocket server input transport for receiving client data.
+
+    Handles incoming WebSocket connections, message processing, and client
+    session management including timeout monitoring and connection lifecycle.
+    """
+
+    def __init__(
+        self,
+        transport: BaseTransport,
+        host: str,
+        port: int,
+        params: WebsocketServerParams,
+        callbacks: WebsocketServerCallbacks,
+        **kwargs,
+    ):
+        """Initialize the WebSocket server input transport.
+
+        Args:
+            transport: The parent transport instance.
+            host: Host address to bind the WebSocket server to.
+            port: Port number to bind the WebSocket server to.
+            params: WebSocket server configuration parameters.
+            callbacks: Callback functions for WebSocket events.
+            **kwargs: Additional arguments passed to parent class.
+        """
+        super().__init__(params, **kwargs)
+
+        self._transport = transport
+        self._host = host
+        self._port = port
+        self._params = params
+        self._callbacks = callbacks
+
+        self._websocket: Optional[websockets.WebSocketServerProtocol] = None
+
+        self._server_task = None
+
+        # This task will monitor the websocket connection periodically.
+        self._monitor_task = None
+
+        self._stop_server_event = asyncio.Event()
+
+        # Whether we have seen a StartFrame already.
+        self._initialized = False
+
+    async def start(self, frame: StartFrame):
+        """Start the WebSocket server and initialize components.
+
+        Args:
+            frame: The start frame containing initialization parameters.
+        """
+        await super().start(frame)
+
+        if self._initialized:
+            return
+
+        self._initialized = True
+
+        if self._params.serializer:
+            await self._params.serializer.setup(frame)
+        if not self._server_task:
+            self._server_task = self.create_task(self._server_task_handler())
+        await self.set_transport_ready(frame)
+
+    async def stop(self, frame: EndFrame):
+        """Stop the WebSocket server and cleanup resources.
+
+        Args:
+            frame: The end frame signaling transport shutdown.
+        """
+        await super().stop(frame)
+        self._stop_server_event.set()
+        if self._monitor_task:
+            await self.cancel_task(self._monitor_task)
+            self._monitor_task = None
+        if self._server_task:
+            await self.wait_for_task(self._server_task)
+            self._server_task = None
+
+    async def cancel(self, frame: CancelFrame):
+        """Cancel the WebSocket server and stop all processing.
+
+        Args:
+            frame: The cancel frame signaling immediate cancellation.
+        """
+        await super().cancel(frame)
+        if self._monitor_task:
+            await self.cancel_task(self._monitor_task)
+            self._monitor_task = None
+        if self._server_task:
+            await self.cancel_task(self._server_task)
+            self._server_task = None
+
+    async def cleanup(self):
+        """Cleanup resources and parent transport."""
+        await super().cleanup()
+        await self._transport.cleanup()
+
+    async def _server_task_handler(self):
+        """Handle WebSocket server startup and client connections."""
+        logger.info(f"Starting websocket server on {self._host}:{self._port}")
+        async with websockets.serve(self._client_handler, self._host, self._port) as server:
+            await self._callbacks.on_websocket_ready()
+            await self._stop_server_event.wait()
+
+    async def _client_handler(self, websocket: websockets.WebSocketServerProtocol, path: Optional[str] = None):
+        """Handle individual client connections and message processing."""
+        logger.info(f"New client connection from {websocket.remote_address}")
+        if self._websocket:
+            await self._websocket.close()
+            logger.warning("Only one client connected, using new connection")
+
+        self._websocket = websocket
+
+        # Notify
+        await self._callbacks.on_client_connected(websocket)
+
+        # Create a task to monitor the websocket connection
+        if not self._monitor_task and self._params.session_timeout:
+            self._monitor_task = self.create_task(self._monitor_websocket(websocket, self._params.session_timeout))
+
+        # Handle incoming messages
+        try:
+            async for message in websocket:
+                if not self._params.serializer:
+                    continue
+
+                frame = await self._params.serializer.deserialize(message)
+
+                if not frame:
+                    continue
+
+                if isinstance(frame, InputAudioRawFrame):
+                    await self.push_audio_frame(frame)
+                else:
+                    await self.push_frame(frame)
+        except Exception as e:
+            logger.error(f"{self} exception receiving data: {e.__class__.__name__} ({e})")
+
+        # Notify disconnection
+        await self._callbacks.on_client_disconnected(websocket)
+
+        await self._websocket.close()
+        self._websocket = None
+
+        logger.info(f"Client {websocket.remote_address} disconnected")
+
+    async def _monitor_websocket(self, websocket: websockets.WebSocketServerProtocol, session_timeout: int):
+        """Monitor WebSocket connection for session timeout."""
+        try:
+            await asyncio.sleep(session_timeout)
+            if not websocket.closed:
+                await self._callbacks.on_session_timeout(websocket)
+        except asyncio.CancelledError:
+            logger.info(f"Monitoring task cancelled for: {websocket.remote_address}")
+            raise
+
+
+class WebsocketServerTransport(BaseTransport):
+    """WebSocket server transport for bidirectional real-time communication.
+
+    Provides a complete WebSocket server implementation with separate input and
+    output transports, client connection management, and event handling for
+    real-time audio and data streaming applications.
+    """
+
+    def __init__(
+        self,
+        params: WebsocketServerParams,
+        host: str = "localhost",
+        port: int = 8765,
+        input_name: Optional[str] = None,
+        output_name: Optional[str] = None,
+    ):
+        """Initialize the WebSocket server transport.
+
+        Args:
+            params: WebSocket server configuration parameters.
+            host: Host address to bind the server to. Defaults to "localhost".
+            port: Port number to bind the server to. Defaults to 8765.
+            input_name: Optional name for the input processor.
+            output_name: Optional name for the output processor.
+        """
+        super().__init__(input_name=input_name, output_name=output_name)
+        self._host = host
+        self._port = port
+        self._params = params
+
+        self._callbacks = WebsocketServerCallbacks(
+            on_client_connected=self._on_client_connected,
+            on_client_disconnected=self._on_client_disconnected,
+            on_session_timeout=self._on_session_timeout,
+            on_websocket_ready=self._on_websocket_ready,
+        )
+        self._input: Optional[WebsocketServerInputTransport] = None
+        self._output: Optional[WebsocketServerOutputTransport] = None
+        self._websocket: Optional[websockets.WebSocketServerProtocol] = None
+
+        # Register supported handlers. The user will only be able to register
+        # these handlers.
+        self._register_event_handler("on_client_connected")
+        self._register_event_handler("on_client_disconnected")
+        self._register_event_handler("on_session_timeout")
+        self._register_event_handler("on_websocket_ready")
+
+    def input(self) -> WebsocketServerInputTransport:
+        """Get the input transport for receiving client data.
+
+        Returns:
+            The WebSocket server input transport instance.
+        """
+        if not self._input:
+            self._input = WebsocketServerInputTransport(
+                self, self._host, self._port, self._params, self._callbacks, name=self._input_name
+            )
+        return self._input
+
+    def output(self) -> WebsocketServerOutputTransport:
+        """Get the output transport for sending data to clients.
+
+        Returns:
+            The WebSocket server output transport instance.
+        """
+        if not self._output:
+            self._output = WebsocketServerOutputTransport(self, self._params, name=self._output_name)
+        return self._output
+
+    async def _on_client_connected(self, websocket):
+        """Handle client connection events."""
+        if self._output:
+            await self._output.set_client_connection(websocket)
+            await self._call_event_handler("on_client_connected", websocket)
+        else:
+            logger.error("A WebsocketServerTransport output is missing in the pipeline")
+
+    async def _on_client_disconnected(self, websocket):
+        """Handle client disconnection events."""
+        if self._output:
+            await self._output.set_client_connection(None)
+            await self._call_event_handler("on_client_disconnected", websocket)
+        else:
+            logger.error("A WebsocketServerTransport output is missing in the pipeline")
+
+    async def _on_session_timeout(self, websocket):
+        """Handle client session timeout events."""
+        await self._call_event_handler("on_session_timeout", websocket)
+
+    async def _on_websocket_ready(self):
+        """Handle WebSocket server ready events."""
+        await self._call_event_handler("on_websocket_ready")

nemo/agents/voice_agent/pipecat/utils/__init__.py

@@ -0,0 +1,13 @@
+# Copyright (c) 2025, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.

nemo/agents/voice_agent/pipecat/utils/text/__init__.py

@@ -0,0 +1,13 @@
+# Copyright (c) 2025, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.

nemo/agents/voice_agent/pipecat/utils/text/simple_text_aggregator.py

@@ -0,0 +1,238 @@
+# Copyright (c) 2025, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import re
+from typing import AsyncIterator, Optional
+
+from loguru import logger
+from pipecat.utils.string import match_endofsentence
+from pipecat.utils.text.base_text_aggregator import Aggregation, AggregationType
+from pipecat.utils.text.simple_text_aggregator import SimpleTextAggregator
+
+
+def has_partial_decimal(text: str) -> bool:
+    """Check if the text ends with a partial decimal.
+
+    Returns True if the text ends with a number that looks like it could
+    be a partial decimal (e.g., "3.", "3.14", "($3.14)"), but NOT if it's
+    clearly a complete sentence (e.g., "It costs $3.14.") or a bullet point
+    (e.g., "1. Alpha; 2.").
+    """
+
+    # Check for bullet point pattern: ends with 1-3 digits followed by period
+    # Examples: "1.", "12.", "123.", or "text; 2."
+    # Bullet points are typically small numbers (1-999) at the end
+    bullet_match = re.search(r'(?:^|[\s;,]|[^\d])(\d{1,3})\.$', text)
+    if bullet_match:
+        # It's likely a bullet point, not a partial decimal
+        return False
+
+    # Pattern to find decimal numbers near the end, allowing for trailing
+    # non-word characters like ), ], ", ', etc.
+    # Match: digit(s) + period + optional digit(s) + optional trailing non-word chars
+    match = re.search(r'\d+\.(?:\d+)?([^\w\s]*)$', text)
+
+    if not match:
+        return False
+
+    trailing = match.group(1)  # e.g., ")" or "" or "."
+
+    # If trailing contains a period, it's sentence-ending punctuation
+    # e.g., "3.14." means complete sentence
+    if '.' in trailing:
+        return False
+
+    # Otherwise, it's a partial decimal (either incomplete like "3."
+    # or complete number but sentence not finished like "($3.14)")
+    return True
+
+
+def find_last_period_index(text: str) -> int:
+    """
+    Find the last occurrence of a period in the text,
+    but return -1 if the text doesn't seem to be a complete sentence.
+    """
+    num_periods = text.count(".")
+    if num_periods == 0:
+        return -1
+
+    if num_periods == 1:
+        if has_partial_decimal(text):
+            # if the only period in the text is part of a number, return -1
+            return -1
+        # Check if the only period is a bullet point (e.g., "1. Alpha" or incomplete "1.")
+        if re.search(r'(?:^|[\s;,]|[^\d])(\d{1,3})\.(?:\s+\w|\s*$)', text):
+            # The period is after a bullet point number, either:
+            # - followed by content (e.g., "1. Alpha")
+            # - or at the end with optional whitespace (e.g., "1." or "1. ")
+            return -1
+
+        # Check if any of the abbreviations "e.", "i." "g.", "etc." are present in the text
+        if re.search(r'\b(e\.|i\.|g\.)\b', text):
+            # The period is after a character/word that is likely to be a abbreviation, return -1
+            return -1
+
+    # otherwise, check the last occurrence of a period
+    idx = text.rfind(".")
+    if idx <= 0:
+        return idx
+    if text[idx - 1].isdigit():
+        # if the period is after a digit, it's likely a partial decimal, return -1
+        return -1
+    elif text[idx - 1].isupper():
+        # if the period is after a capital letter (e.g., "Washington, D.C."), it's likely a abbreviation, return -1
+        return -1
+    elif idx > 1 and text[idx - 2 : idx + 1].lower() in ["a.m.", "p.m."]:
+        # if the period is after a.m. or p.m., it's likely a time, return -1
+        return -1
+    elif idx > 2 and text[idx - 3 : idx + 1] in ["e.g.", "i.e.", "etc."]:
+        # The period is after a character/word that is likely to be a abbreviation, return -1
+        return -1
+    elif idx >= 2 and text[idx - 2 : idx + 1].lower() in ["st.", "mr.", "mrs.", "ms.", "dr."]:
+        # if the period is after a character/word that is likely to be a abbreviation, return -1
+        return -1
+
+    # the text seems to have a complete sentence, return the index of the last period
+    return idx
+
+
+def find_last_comma_index(text: str, min_residual_length: int = 5) -> int:
+    """
+    Find the last occurrence of a valid comma in the text,
+    ignoring the commas in the numbers (e.g., "1,234,567").
+    If the leftover text after the comma is too short, it may be an abbreviation, return -1.
+
+    Args:
+        text: The text to find the last occurrence of a valid comma.
+        min_residual_length: The minimum length of the leftover text after the rightmost comma
+                             to be considered as a valid sentence (e.g., "Santa Clara, CA, US.").
+    Returns:
+        The index of the last occurrence of a valid comma, or -1 if no valid comma is found.
+    """
+    # find the last occurrence of a comma in the text
+    idx = text.rfind(",")
+    if idx == -1:
+        return -1
+    # check if the comma is in a number
+    if re.search(r'\d+,\d+', text[: idx + 1]):
+        # the comma is in a number, return -1
+        return -1
+
+    # check if the leftover text after the comma is too short
+    if len(text[idx + 1 :]) <= min_residual_length:
+        # the leftover text is too short, it may be an abbreviation, return -1
+        return -1
+
+    # the comma is not in a number, return the index of the comma
+    return idx
+
+
+class SimpleSegmentedTextAggregator(SimpleTextAggregator):
+    """A simple text aggregator that segments the text into sentences based on punctuation marks."""
+
+    def __init__(
+        self,
+        punctuation_marks: str | list[str] = ".,!?;:\n",
+        ignore_marks: str | list[str] = "*",
+        min_sentence_length: int = 0,
+        use_legacy_eos_detection: bool = False,
+        **kwargs,
+    ):
+        """
+        Args:
+            punctuation_marks: The punctuation marks to use for sentence detection.
+            ignore_marks: The strings to ignore in the text (e.g., "*").
+            min_sentence_length: The minimum length of a sentence to be considered.
+            use_legacy_eos_detection: Whether to use the legacy EOS detection from pipecat.
+            **kwargs: Additional arguments to pass to the SimpleTextAggregator constructor.
+        """
+        super().__init__(**kwargs)
+        self._use_legacy_eos_detection = use_legacy_eos_detection
+        self._min_sentence_length = min_sentence_length
+        self._ignore_marks = set(["*"] if ignore_marks is None else set(ignore_marks))
+        if not punctuation_marks:
+            self._punctuation_marks = list()
+        else:
+            punctuation_marks = (
+                [c for c in punctuation_marks] if isinstance(punctuation_marks, str) else punctuation_marks
+            )
+            if "." in punctuation_marks:
+                punctuation_marks.remove(".")
+            # put period at the end of the list to ensure it's the last punctuation mark to be matched
+            punctuation_marks += ["."]
+            self._punctuation_marks = punctuation_marks
+
+    def _find_segment_end(self, text: str) -> Optional[int]:
+        """find the end of text segment.
+
+        Args:
+            text: The text to find the end of the segment.
+
+        Returns:
+            The index of the end of the segment, or None if the text is too short.
+        """
+        # drop leading whitespace but keep trailing whitespace to
+        # allow "\n" to trigger the end of the sentence
+        text_len = len(text)
+        text = text.lstrip()
+        offset = text_len - len(text)
+        if len(text) < self._min_sentence_length:
+            return None
+
+        for punc in self._punctuation_marks:
+            if punc == ".":
+                idx = find_last_period_index(text)
+            elif punc == ",":
+                idx = find_last_comma_index(text)
+            else:
+                idx = text.find(punc)
+            if idx != -1:
+                # add the offset to the index to account for the leading whitespace
+                return idx + 1 + offset
+        return None
+
+    async def aggregate(self, text: str) -> AsyncIterator[Aggregation]:
+        """Aggregate the input text and return the first complete sentence in the text.
+
+        Args:
+            text: The text to aggregate.
+
+        Returns:
+            The first complete sentence in the text, or None if none is found.
+        """
+        result: Optional[str] = None
+        self._text += str(text)
+
+        eos_end_index = self._find_segment_end(self._text)
+
+        if not eos_end_index and not has_partial_decimal(self._text) and self._use_legacy_eos_detection:
+            # if the text doesn't have partial decimal, and no punctuation marks,
+            # we use match_endofsentence to find the end of the sentence
+            eos_end_index = match_endofsentence(self._text)
+
+        if eos_end_index:
+            result = self._text[:eos_end_index]
+            if len(result.strip()) < self._min_sentence_length:
+                logger.debug(
+                    f"Text is too short, skipping: `{result}`, full text: `{self._text}`, input text: `{text}`"
+                )
+                result = None
+            else:
+                logger.debug(f"Text Aggregator Result: `{result}`, full text: `{self._text}`, input text: `{text}`")
+                self._text = self._text[eos_end_index:]
+
+        if result:
+            for ignore_mark in self._ignore_marks:
+                result = result.replace(ignore_mark, "")
+            yield Aggregation(text=result, type=AggregationType.SENTENCE)

nemo/{collections/vlm/clip/data → agents/voice_agent/utils}/__init__.py

@@ -11,6 +11,5 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-from nemo.collections.vlm.clip.data.mock import MockDataModule as ClipMockDataModule
 
-__all__ = ['ClipMockDataModule']
+from nemo.agents.voice_agent.utils.config_manager import ConfigManager

nemo/agents/voice_agent/utils/config_manager.py

@@ -0,0 +1,312 @@
+# Copyright (c) 2025, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import os
+from typing import Any, Dict, Optional
+
+from loguru import logger
+from omegaconf import OmegaConf
+from pipecat.audio.vad.silero import VADParams
+
+from nemo.agents.voice_agent.pipecat.services.nemo.diar import NeMoDiarInputParams
+from nemo.agents.voice_agent.pipecat.services.nemo.stt import NeMoSTTInputParams
+
+
+class ConfigManager:
+    """
+    Manages configuration for the voice agent server.
+    Handles loading, merging, and providing access to all configuration parameters.
+    """
+
+    def __init__(self, server_base_path: str, server_config_path: Optional[str] = None):
+        """
+        Initialize the configuration manager.
+
+        Args:
+            config_path: Path to the main server configuration file.
+                        If None, uses default path from environment variable.
+        """
+        if not os.path.exists(server_base_path):
+            raise FileNotFoundError(f"Server base path not found at {server_base_path}")
+
+        self._server_base_path = server_base_path
+        if server_config_path is not None:
+            self._server_config_path = server_config_path
+        else:
+            self._server_config_path = f"{os.path.abspath(self._server_base_path)}/server_configs/default.yaml"
+
+        if not os.path.exists(self._server_config_path):
+            raise FileNotFoundError(f"Server configuration file not found at {self._server_config_path}")
+
+        # Load model registry
+        self.model_registry_path = f"{os.path.abspath(self._server_base_path)}/model_registry.yaml"
+        self.model_registry = self._load_model_registry()
+
+        # Load and process main configuration
+        self.server_config = self._load_server_config()
+
+        # Initialize configuration parameters
+        self._initialize_config_parameters()
+
+        self._generic_hf_llm_model_id = "hf_llm_generic"
+
+        logger.info(f"Configuration loaded from: {self._server_config_path}")
+        logger.info(f"Model registry loaded from: {self.model_registry_path}")
+
+    def _load_model_registry(self) -> Dict[str, Any]:
+        """Load model registry from YAML file."""
+        try:
+            return OmegaConf.load(self.model_registry_path)
+        except Exception as e:
+            logger.error(f"Failed to load model registry: {e}")
+            raise ValueError(f"Failed to load model registry: {e}")
+
+    def _load_server_config(self) -> OmegaConf:
+        """Load and process the main server configuration."""
+        server_config = OmegaConf.load(self._server_config_path)
+        server_config = OmegaConf.to_container(server_config, resolve=True)
+        server_config = OmegaConf.create(server_config)
+        return server_config
+
+    def _initialize_config_parameters(self):
+        """Initialize all configuration parameters from the loaded config."""
+        # Default constants
+        self.SAMPLE_RATE = 16000
+        self.RAW_AUDIO_FRAME_LEN_IN_SECS = 0.016
+        self.SYSTEM_PROMPT = " ".join(
+            [
+                "You are a helpful AI agent named Lisa.",
+                "Begin by warmly greeting the user and introducing yourself in one sentence.",
+                "Keep your answers concise and to the point.",
+            ]
+        )
+
+        # Transport configuration
+        self.TRANSPORT_AUDIO_OUT_10MS_CHUNKS = self.server_config.transport.audio_out_10ms_chunks
+
+        # VAD configuration
+        self.vad_params = VADParams(
+            confidence=self.server_config.vad.confidence,
+            start_secs=self.server_config.vad.start_secs,
+            stop_secs=self.server_config.vad.stop_secs,
+            min_volume=self.server_config.vad.min_volume,
+        )
+        # STT configuration
+        self._configure_stt()
+
+        # Diarization configuration
+        self._configure_diarization()
+
+        # Turn taking configuration
+        self._configure_turn_taking()
+
+        # LLM configuration
+        self._configure_llm()
+
+        # TTS configuration
+        self._configure_tts()
+
+    def _configure_stt(self):
+        """Configure STT parameters."""
+        self.STT_MODEL = self.server_config.stt.model
+        self.STT_DEVICE = self.server_config.stt.device
+        # Apply STT-specific configuration based on model type
+        # Try to get STT config file name from server config first
+        if self.server_config.stt.get("model_config", None) is not None:
+            yaml_file_name = os.path.basename(self.server_config.stt.model_config)
+        else:
+            # Get STT configuration from registry
+            if str(self.STT_MODEL).endswith(".nemo"):
+                model_name = os.path.splitext(os.path.basename(self.STT_MODEL))[0]
+            else:
+                model_name = self.STT_MODEL
+            if model_name in self.model_registry.stt_models:
+                yaml_file_name = self.model_registry.stt_models[model_name].yaml_id
+            else:
+                error_msg = f"STT model {model_name} is not in model registry: {self.model_registry.stt_models}."
+                logger.error(error_msg)
+                raise ValueError(error_msg)
+
+        stt_config_path = f"{os.path.abspath(self._server_base_path)}/server_configs/stt_configs/{yaml_file_name}"
+        if not os.path.exists(stt_config_path):
+            raise FileNotFoundError(f"STT config file not found at {stt_config_path}")
+        stt_config = OmegaConf.load(stt_config_path)
+
+        # merge stt config with server config
+        for key in stt_config:
+            if key in self.server_config.stt and self.server_config.stt[key] != stt_config[key]:
+                logger.info(
+                    f"STT config field `{key}` is overridden from `{self.server_config.stt[key]}` "
+                    f"to `{stt_config[key]}` by {stt_config_path}"
+                )
+            self.server_config.stt[key] = stt_config[key]
+
+        logger.info(f"Final STT config: {self.server_config.stt}")
+
+        audio_chunk_size_in_secs = self.server_config.stt.get("audio_chunk_size_in_secs", 0.08)
+        buffer_size = audio_chunk_size_in_secs // self.RAW_AUDIO_FRAME_LEN_IN_SECS
+        self.stt_params = NeMoSTTInputParams(
+            att_context_size=self.server_config.stt.att_context_size,
+            frame_len_in_secs=self.server_config.stt.frame_len_in_secs,
+            raw_audio_frame_len_in_secs=self.RAW_AUDIO_FRAME_LEN_IN_SECS,
+            buffer_size=buffer_size,
+        )
+
+    def _configure_diarization(self):
+        """
+        Configure diarization parameters.
+        Currently only NeMo End-to-End Diarization is supported.
+        """
+        self.DIAR_MODEL = self.server_config.diar.model
+        self.USE_DIAR = self.server_config.diar.enabled
+        self.diar_params = NeMoDiarInputParams(
+            frame_len_in_secs=self.server_config.diar.frame_len_in_secs,
+            threshold=self.server_config.diar.threshold,
+        )
+
+    def _configure_turn_taking(self):
+        """Configure turn taking parameters."""
+        self.TURN_TAKING_BACKCHANNEL_PHRASES_PATH = self.server_config.turn_taking.backchannel_phrases_path
+        self.TURN_TAKING_MAX_BUFFER_SIZE = self.server_config.turn_taking.max_buffer_size
+        self.TURN_TAKING_BOT_STOP_DELAY = self.server_config.turn_taking.bot_stop_delay
+
+    def _configure_llm(self):
+        """Configure LLM parameters."""
+        llm_model_id = self.server_config.llm.model
+        is_registry_model = False
+
+        # Try to get LLM config file name from server config first
+        if self.server_config.llm.get("model_config", None) is not None:
+            yaml_file_name = os.path.basename(self.server_config.llm.model_config)
+        else:
+            # Get LLM configuration from registry
+            if llm_model_id in self.model_registry.llm_models:
+                yaml_file_name = self.model_registry.llm_models[llm_model_id].yaml_id
+                is_registry_model = True
+            else:
+                logger.warning(
+                    f"LLM model {llm_model_id} is not included in the model registry. "
+                    "Using a generic HuggingFace LLM config instead."
+                )
+                yaml_file_name = self.model_registry.llm_models[self._generic_hf_llm_model_id].yaml_id
+
+        # Load and merge LLM configuration
+        llm_config_path = f"{os.path.abspath(self._server_base_path)}/server_configs/llm_configs/{yaml_file_name}"
+
+        if (
+            is_registry_model
+            and self.model_registry.llm_models[llm_model_id].get("reasoning_supported", False)
+            and self.server_config.llm.get("enable_reasoning", False)
+        ):
+            llm_config_path = llm_config_path.replace(".yaml", "_think.yaml")
+
+        if not os.path.exists(llm_config_path):
+            raise FileNotFoundError(f"LLM config file not found at {llm_config_path}")
+        logger.info(f"Loading LLM config from: {llm_config_path}")
+
+        llm_config = OmegaConf.load(llm_config_path)
+        # merge llm config with server config
+        # print the override keys
+        for key in llm_config:
+            if key in self.server_config.llm and self.server_config.llm[key] != llm_config[key]:
+                logger.info(
+                    f"LLM config field `{key}` is overridden from `{self.server_config.llm[key]}` to "
+                    f"`{llm_config[key]}` by {llm_config_path}"
+                )
+            self.server_config.llm[key] = llm_config[key]
+
+        logger.info(f"Final LLM config: {self.server_config.llm}")
+
+        # Configure system prompt
+        self.SYSTEM_ROLE = self.server_config.llm.get("system_role", "system")
+        if self.server_config.llm.get("system_prompt", None) is not None:
+            system_prompt = self.server_config.llm.system_prompt
+            if os.path.isfile(system_prompt):
+                with open(system_prompt, "r") as f:
+                    system_prompt = f.read()
+            self.SYSTEM_PROMPT = system_prompt
+        else:
+            logger.info(f"No system prompt provided, using default system prompt: {self.SYSTEM_PROMPT}")
+
+        if self.server_config.llm.get("system_prompt_suffix", None) is not None:
+            self.SYSTEM_PROMPT += "\n" + self.server_config.llm.system_prompt_suffix
+            logger.info(f"Adding system prompt suffix: {self.server_config.llm.system_prompt_suffix}")
+
+        logger.info(f"System prompt: {self.SYSTEM_PROMPT}")
+
+    def _configure_tts(self):
+        """Configure TTS parameters."""
+        tts_model_id = self.server_config.tts.model
+
+        # Try to get TTS config file name from server config first
+        if self.server_config.tts.get("model_config", None) is not None:
+            yaml_file_name = os.path.basename(self.server_config.tts.model_config)
+        else:
+            # Get TTS configuration from registry
+            if tts_model_id in self.model_registry.tts_models:
+                yaml_file_name = self.model_registry.tts_models[tts_model_id].yaml_id
+            else:
+                error_msg = f"TTS model {tts_model_id} is not in model registry: {self.model_registry.tts_models}"
+                logger.error(error_msg)
+                raise ValueError(error_msg)
+
+        tts_config_path = f"{os.path.abspath(self._server_base_path)}/server_configs/tts_configs/{yaml_file_name}"
+        if not os.path.exists(tts_config_path):
+            raise FileNotFoundError(f"Default TTS config file not found at {tts_config_path}")
+        tts_config = OmegaConf.load(tts_config_path)
+
+        # merge tts config with server config
+        for key in tts_config:
+            if key in self.server_config.tts and self.server_config.tts[key] != tts_config[key]:
+                logger.info(
+                    f"TTS config field `{key}` is overridden from `{self.server_config.tts[key]}` to "
+                    f"`{tts_config[key]}` by {tts_config_path}"
+                )
+            self.server_config.tts[key] = tts_config[key]
+
+        logger.info(f"Final TTS config: {self.server_config.tts}")
+
+        # Extract TTS parameters
+        self.TTS_MAIN_MODEL_ID = self.server_config.tts.get("main_model_id", None)
+        self.TTS_SUB_MODEL_ID = self.server_config.tts.get("sub_model_id", None)
+        self.TTS_DEVICE = self.server_config.tts.get("device", None)
+
+        # Handle optional TTS parameters
+        self.TTS_THINK_TOKENS = self.server_config.tts.get("think_tokens", None)
+        if self.TTS_THINK_TOKENS is not None:
+            self.TTS_THINK_TOKENS = OmegaConf.to_container(self.TTS_THINK_TOKENS)
+
+        self.TTS_EXTRA_SEPARATOR = self.server_config.tts.get("extra_separator", None)
+        if self.TTS_EXTRA_SEPARATOR is not None:
+            self.TTS_EXTRA_SEPARATOR = OmegaConf.to_container(self.TTS_EXTRA_SEPARATOR)
+
+    def get_server_config(self) -> OmegaConf:
+        """Get the complete server configuration."""
+        return self.server_config
+
+    def get_model_registry(self) -> Dict[str, Any]:
+        """Get the model registry configuration."""
+        return self.model_registry
+
+    def get_vad_params(self) -> VADParams:
+        """Get VAD parameters."""
+        return self.vad_params
+
+    def get_stt_params(self) -> NeMoSTTInputParams:
+        """Get STT parameters."""
+        return self.stt_params
+
+    def get_diar_params(self) -> NeMoDiarInputParams:
+        """Get diarization parameters."""
+        return self.diar_params

nemo/agents/voice_agent/utils/tool_calling/__init__.py

@@ -0,0 +1,13 @@
+# Copyright (c) 2025, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.

nemo/agents/voice_agent/utils/tool_calling/basic_tools.py

@@ -0,0 +1,72 @@
+# Copyright (c) 2025, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import asyncio
+import python_weather
+from loguru import logger
+from pipecat.frames.frames import LLMTextFrame, TTSSpeakFrame
+from pipecat.processors.frame_processor import FrameDirection
+from pipecat.services.llm_service import FunctionCallParams
+
+HTTP_REQUEST_TIMEOUT = 10.0
+
+
+async def tool_get_city_weather(params: FunctionCallParams, city_name: str):
+    """Get the current weather of a city. The result includes city name, weather description,
+    temperature, wind speed, wind direction, precipitation, humidity, visibility, and UV index.
+
+    Args:
+        city_name: The name of the city to get the weather of. For example, "London", "Beijing", "Paris".
+                Other examples are: "Paris, TX, US", "Paris, FR" and "Tokyo, JP".
+    """
+    message = f"Looking up weather data for {city_name}. Please wait a moment..."
+    # Send the message to upstream so that RTVI can log it while doesn't block the actual tool call.
+    await params.llm.push_frame(LLMTextFrame(message), direction=FrameDirection.UPSTREAM)
+    # Send the message to TTS directly so that the user can hear it immediately.
+    await params.llm.push_frame(TTSSpeakFrame(message))
+
+    # The measuring unit defaults to metric (Celsius)
+    # Use imperial for Fahrenheit: python_weather.IMPERIAL
+    async with python_weather.Client(unit=python_weather.METRIC) as client:
+        # Fetch a weather forecast from a city
+        logger.debug(f"Fetching weather forecast for `{city_name}`")
+        try:
+            weather: python_weather.Forecast = await asyncio.wait_for(
+                client.get(city_name),
+                timeout=HTTP_REQUEST_TIMEOUT,
+            )
+        except asyncio.TimeoutError:
+            error_msg = f"python_weather API request timed out after {HTTP_REQUEST_TIMEOUT} seconds for `{city_name}`"
+            logger.error(error_msg)
+            await params.result_callback({"error": error_msg})
+            return
+        except Exception as e:
+            error_msg = f"Error fetching weather forecast for `{city_name}`: {str(e)}"
+            logger.error(error_msg)
+            await params.result_callback({"error": error_msg})
+            return
+
+        results = {
+            "city": city_name,
+            "description": str(weather.description),
+            "temperature": f"{weather.temperature} degrees Celsius",
+            "wind_speed": f"{weather.wind_speed} kilometers per hour",
+            "wind_direction": str(weather.wind_direction.name),
+            "precipitation": f"{weather.precipitation} millimeters",
+            "humidity": f"{weather.humidity} percent",
+            "visibility": f"{weather.visibility} kilometers",
+            "uv_index": str(weather.ultraviolet),
+        }
+        logger.debug(f"Weather results for {city_name}: {results}")
+        await params.result_callback(results)

nemo/agents/voice_agent/utils/tool_calling/mixins.py

@@ -0,0 +1,104 @@
+# Copyright (c) 2025, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from loguru import logger
+from pipecat.adapters.schemas.direct_function import DirectFunction
+from pipecat.adapters.schemas.tools_schema import ToolsSchema
+from pipecat.processors.aggregators.openai_llm_context import OpenAILLMContext
+from pipecat.services.openai.llm import OpenAILLMService
+
+
+class ToolCallingMixin:
+    """
+    A mixin class for tool calling.
+    Subclasses must implement the `setup_tool_calling` method to register all available tools
+    using `self.register_direct_function()`. Then the `__init__` method of the subclass should
+    call the `setup_tool_calling` method to register the tools.
+    """
+
+    def setup_tool_calling(self):
+        """
+        Setup the tool calling mixin by registering all available tools using self.register_direct_function().
+        """
+        raise NotImplementedError(
+            "Subclasses must implement this method to register all available functions "
+            "using self.register_direct_function()"
+        )
+
+    def register_direct_function(self, function_name: str, function: DirectFunction):
+        """
+        Register a direct function to be called by the LLM.
+
+        Args:
+            function_name: The name of the function to register.
+            function: The direct function to register.
+        """
+        if not hasattr(self, "direct_functions"):
+            self.direct_functions = {}
+        logger.info(
+            f"[{self.__class__.__name__}] Registering direct function name {function_name} to "
+            f"{function.__module__ + '.' + function.__qualname__}"
+        )
+        self.direct_functions[function_name] = function
+
+    @property
+    def available_tools(self) -> dict[str, DirectFunction]:
+        """
+        Return a dictionary of available tools, where the key is the tool name and the value is the direct function.
+        """
+        tools = {}
+        for function_name, function in self.direct_functions.items():
+            tools[function_name] = function
+        return tools
+
+
+def register_direct_tools_to_llm(
+    *,
+    llm: OpenAILLMService,
+    context: OpenAILLMContext,
+    tool_mixins: list[ToolCallingMixin] = [],
+    tools: list[DirectFunction] = [],
+    cancel_on_interruption: bool = True,
+) -> None:
+    """
+    Register direct tools to the LLM.
+    Args:
+        llm: The LLM service to use.
+        context: The LLM context to use.
+        tools: The list of tools (instances of either `DirectFunction` or `ToolCallingMixin`) to use.
+    """
+    all_tools = []
+    for tool in tool_mixins:
+        if not isinstance(tool, ToolCallingMixin):
+            logger.warning(f"Tool {tool.__class__.__name__} is not a ToolCallingMixin, skipping.")
+            continue
+        for function_name, function in tool.available_tools.items():
+            logger.info(f"Registering direct function {function_name} from {tool.__class__.__name__}")
+            all_tools.append(function)
+
+    for tool in tools:
+        logger.info(f"Registering direct function: {tool.__module__ + '.' + tool.__qualname__}")
+        all_tools.append(tool)
+
+    if not all_tools:
+        logger.warning("No direct tools provided.")
+        return
+    else:
+        logger.info(f"Registering {len(all_tools)} direct tools to the LLM.")
+
+    tools_schema = ToolsSchema(standard_tools=all_tools)
+    context.set_tools(tools_schema)
+
+    for tool in all_tools:
+        llm.register_direct_function(tool, cancel_on_interruption=cancel_on_interruption)

nemo/collections/asr/README.md

@@ -0,0 +1,37 @@
+# Automatic Speech Recognition (ASR)
+
+## Key Features
+
+* [HuggingFace Space for Audio Transcription (File, Microphone and YouTube)](https://huggingface.co/spaces/smajumdar/nemo_multilingual_language_id)
+* [Pretrained models](https://ngc.nvidia.com/catalog/collections/nvidia:nemo_asr) available in 14+ languages
+* [Automatic Speech Recognition (ASR)](https://docs.nvidia.com/deeplearning/nemo/user-guide/docs/en/main/asr/intro.html)
+    * Supported ASR [models](https://docs.nvidia.com/deeplearning/nemo/user-guide/docs/en/stable/asr/models.html):
+        * Jasper, QuartzNet, CitriNet, ContextNet
+        * Conformer-CTC, Conformer-Transducer, FastConformer-CTC, FastConformer-Transducer
+        * Squeezeformer-CTC and Squeezeformer-Transducer
+        * LSTM-Transducer (RNNT) and LSTM-CTC
+    * Supports the following decoders/losses:
+        * CTC
+        * Transducer/RNNT
+        * Hybrid Transducer/CTC
+        * NeMo Original [Multi-blank Transducers](https://arxiv.org/abs/2211.03541) and [Token-and-Duration Transducers (TDT)](https://arxiv.org/abs/2304.06795)
+    * Streaming/Buffered ASR (CTC/Transducer) - [Chunked Inference Examples](https://github.com/NVIDIA/NeMo/tree/stable/examples/asr/asr_chunked_inference)
+    * [Cache-aware Streaming Conformer](https://docs.nvidia.com/deeplearning/nemo/user-guide/docs/en/stable/asr/models.html#cache-aware-streaming-conformer) with multiple lookaheads (including microphone streaming [tutorial](https://github.com/NVIDIA/NeMo/blob/main/tutorials/asr/Online_ASR_Microphone_Demo_Cache_Aware_Streaming.ipynb).
+    * Beam Search decoding
+    * [Language Modelling for ASR (CTC and RNNT)](https://docs.nvidia.com/deeplearning/nemo/user-guide/docs/en/main/asr/asr_language_modeling.html): N-gram LM in fusion with Beam Search decoding, Neural Rescoring with Transformer
+    * [Support of long audios for Conformer with memory efficient local attention](https://docs.nvidia.com/deeplearning/nemo/user-guide/docs/en/main/asr/results.html#inference-on-long-audio)
+* [Speech Classification, Speech Command Recognition and Language Identification](https://docs.nvidia.com/deeplearning/nemo/user-guide/docs/en/main/asr/speech_classification/intro.html): MatchboxNet (Command Recognition), AmberNet (LangID)
+* [Voice activity Detection (VAD)](https://docs.nvidia.com/deeplearning/nemo/user-guide/docs/en/stable/asr/speech_classification/models.html#marblenet-vad): MarbleNet
+    * ASR with VAD Inference - [Example](https://github.com/NVIDIA/NeMo/tree/stable/examples/asr/asr_vad)
+* [Speaker Recognition](https://docs.nvidia.com/deeplearning/nemo/user-guide/docs/en/main/asr/speaker_recognition/intro.html): TitaNet, ECAPA_TDNN, SpeakerNet
+* [Speaker Diarization](https://docs.nvidia.com/deeplearning/nemo/user-guide/docs/en/main/asr/speaker_diarization/intro.html)
+    * Clustering Diarizer: TitaNet, ECAPA_TDNN, SpeakerNet
+    * Neural Diarizer: Sortformer
+* [Speech Intent Detection and Slot Filling](https://docs.nvidia.com/deeplearning/nemo/user-guide/docs/en/main/asr/speech_intent_slot/intro.html): Conformer-Transformer
+
+You can also get a high-level overview of NeMo ASR by watching the talk *NVIDIA NeMo: Toolkit for Conversational AI*, presented at PyData Yerevan 2022:
+
+
+[![NVIDIA NeMo: Toolkit for Conversational AI](https://img.youtube.com/vi/J-P6Sczmas8/maxres3.jpg
+)](https://www.youtube.com/embed/J-P6Sczmas8?mute=0&start=14&autoplay=0
+ "NeMo presentation at PyData@Yerevan 2022")

nemo/collections/asr/data/audio_to_diar_label.py

@@ -13,140 +13,18 @@
 # limitations under the License.
 
 import os
-from collections import OrderedDict
-from statistics import mode
 from typing import Dict, List, Optional, Tuple
 
 import numpy as np
 import torch
 
-from nemo.collections.asr.parts.utils.offline_clustering import get_argmin_mat
-from nemo.collections.asr.parts.utils.speaker_utils import convert_rttm_line, get_subsegments, prepare_split_data
-from nemo.collections.common.parts.preprocessing.collections import (
-    DiarizationSpeechLabel,
-    EndtoEndDiarizationSpeechLabel,
-)
+from nemo.collections.asr.parts.utils.speaker_utils import convert_rttm_line, get_subsegments
+from nemo.collections.common.parts.preprocessing.collections import EndtoEndDiarizationSpeechLabel
 from nemo.core.classes import Dataset
-from nemo.core.neural_types import AudioSignal, EncodedRepresentation, LengthsType, NeuralType, ProbsType
+from nemo.core.neural_types import AudioSignal, LengthsType, NeuralType, ProbsType
 from nemo.utils import logging
 
 
-def get_scale_mapping_list(uniq_timestamps):
-    """
-    Call get_argmin_mat function to find the index of the non-base-scale segment that is closest to the
-    given base-scale segment. For each scale and each segment, a base-scale segment is assigned.
-
-    Args:
-        uniq_timestamps: (dict)
-            The dictionary containing embeddings, timestamps and multiscale weights.
-            If uniq_timestamps contains only one scale, single scale diarization is performed.
-
-    Returns:
-        scale_mapping_argmat (torch.tensor):
-
-            The element at the m-th row and the n-th column of the scale mapping matrix indicates the (m+1)-th scale
-            segment index which has the closest center distance with (n+1)-th segment in the base scale.
-
-            - Example:
-                `scale_mapping_argmat[2][101] = 85`
-
-            In the above example, the code snippet means that 86-th segment in the 3rd scale (python index is 2) is
-            mapped to the 102-th segment in the base scale. Thus, the longer segments bound to have more repeating
-            numbers since multiple base scale segments (since the base scale has the shortest length) fall into the
-            range of the longer segments. At the same time, each row contains N numbers of indices where N is number
-            of segments in the base-scale (i.e., the finest scale).
-    """
-    timestamps_in_scales = []
-    for key, val in uniq_timestamps['scale_dict'].items():
-        timestamps_in_scales.append(torch.tensor(val['time_stamps']))
-    session_scale_mapping_list = get_argmin_mat(timestamps_in_scales)
-    scale_mapping_argmat = [[] for _ in range(len(uniq_timestamps['scale_dict'].keys()))]
-    for scale_idx in range(len(session_scale_mapping_list)):
-        scale_mapping_argmat[scale_idx] = session_scale_mapping_list[scale_idx]
-    scale_mapping_argmat = torch.stack(scale_mapping_argmat)
-    return scale_mapping_argmat
-
-
-def extract_seg_info_from_rttm(rttm_lines, mapping_dict=None, target_spks=None):
-    """
-    Get RTTM lines containing speaker labels, start time and end time. target_spks contains two targeted
-    speaker indices for creating groundtruth label files. Only speakers in target_spks variable will be
-    included in the output lists.
-
-    Args:
-        uniq_id (str):
-            Unique file ID that refers to an input audio file and corresponding RTTM (Annotation) file.
-        rttm_lines (list):
-            List containing RTTM lines in str format.
-        mapping_dict (dict):
-            Mapping between the estimated speakers and the speakers in the ground-truth annotation.
-            `mapping_dict` variable is only provided when the inference mode is running in sequence-eval mode.
-            Sequence eval mode uses the mapping between the estimated speakers and the speakers
-            in ground-truth annotation.
-    Returns:
-        rttm_tup (tuple):
-            Tuple containing lists of start time, end time and speaker labels.
-
-    """
-    stt_list, end_list, speaker_list, pairwise_infer_spks = [], [], [], []
-    if target_spks:
-        inv_map = {v: k for k, v in mapping_dict.items()}
-        for spk_idx in target_spks:
-            spk_str = f'speaker_{spk_idx}'
-            if spk_str in inv_map:
-                pairwise_infer_spks.append(inv_map[spk_str])
-    for rttm_line in rttm_lines:
-        start, end, speaker = convert_rttm_line(rttm_line)
-        if target_spks is None or speaker in pairwise_infer_spks:
-            end_list.append(end)
-            stt_list.append(start)
-            speaker_list.append(speaker)
-    rttm_tup = (stt_list, end_list, speaker_list)
-    return rttm_tup
-
-
-def assign_frame_level_spk_vector(rttm_timestamps, round_digits, frame_per_sec, target_spks, min_spks=2):
-    """
-    Create a multi-dimensional vector sequence containing speaker timestamp information in RTTM.
-    The unit-length is the frame shift length of the acoustic feature. The feature-level annotations
-    `fr_level_target` will later be converted to base-segment level diarization label.
-
-    Args:
-        rttm_timestamps (list):
-            List containing start and end time for each speaker segment label.
-            `stt_list`, `end_list` and `speaker_list` are contained.
-        frame_per_sec (int):
-            Number of feature frames per second. This quantity is determined by
-            `window_stride` variable in preprocessing module.
-        target_spks (tuple):
-            Speaker indices that are generated from combinations.
-            If there are only one or two speakers,
-            only a single `target_spks` variable is generated.
-
-    Returns:
-        fr_level_target (torch.tensor):
-            Tensor containing label for each feature level frame.
-    """
-    stt_list, end_list, speaker_list = rttm_timestamps
-    if len(speaker_list) == 0:
-        return None
-    else:
-        sorted_speakers = sorted(list(set(speaker_list)))
-        total_fr_len = int(max(end_list) * (10**round_digits))
-        spk_num = max(len(sorted_speakers), min_spks)
-        speaker_mapping_dict = {rttm_key: x_int for x_int, rttm_key in enumerate(sorted_speakers)}
-        fr_level_target = torch.zeros(total_fr_len, spk_num)
-
-        # If RTTM is not provided, then there is no speaker mapping dict in target_spks.
-        # Thus, return a zero-filled tensor as a placeholder.
-        for count, (stt, end, spk_rttm_key) in enumerate(zip(stt_list, end_list, speaker_list)):
-            stt, end = round(stt, round_digits), round(end, round_digits)
-            spk = speaker_mapping_dict[spk_rttm_key]
-            stt_fr, end_fr = int(round(stt, 2) * frame_per_sec), int(round(end, round_digits) * frame_per_sec)
-            fr_level_target[stt_fr:end_fr, spk] = 1
-        return fr_level_target
-
-
 def get_subsegments_to_timestamps(
     subsegments: List[Tuple[float, float]], feat_per_sec: int = 100, max_end_ts: float = None, decimals=2
 ):
@@ -281,736 +159,6 @@ def get_frame_targets_from_rttm(
     return feat_level_target
 
 
-class _AudioMSDDTrainDataset(Dataset):
-    """
-    Dataset class that loads a json file containing paths to audio files,
-    RTTM files and number of speakers. This Dataset class is designed for
-    training or fine-tuning speaker embedding extractor and diarization decoder
-    at the same time.
-
-    Example:
-    {"audio_filepath": "/path/to/audio_0.wav", "num_speakers": 2,
-    "rttm_filepath": "/path/to/diar_label_0.rttm}
-    ...
-    {"audio_filepath": "/path/to/audio_n.wav", "num_speakers": 2,
-    "rttm_filepath": "/path/to/diar_label_n.rttm}
-
-    Args:
-        manifest_filepath (str):
-            Path to input manifest json files.
-        multiscale_args_dict (dict):
-            Dictionary containing the parameters for multiscale segmentation and clustering.
-        emb_dir (str):
-            Path to a temporary folder where segmentation information for embedding extraction is saved.
-        soft_label_thres (float):
-            Threshold that determines the label of each segment based on RTTM file information.
-        featurizer:
-            Featurizer instance for generating features from the raw waveform.
-        window_stride (float):
-            Window stride for acoustic feature. This value is used for calculating the numbers of feature-level frames.
-        emb_batch_size (int):
-            Number of embedding vectors that are trained with attached computational graphs.
-        pairwise_infer (bool):
-            This variable should be True if dataloader is created for an inference task.
-        random_flip (bool):
-            If True, the two labels and input signals are randomly flipped per every epoch while training.
-    """
-
-    @property
-    def output_types(self) -> Optional[Dict[str, NeuralType]]:
-        """Returns definitions of module output ports."""
-        output_types = {
-            "features": NeuralType(('B', 'T'), AudioSignal()),
-            "feature_length": NeuralType(('B'), LengthsType()),
-            "ms_seg_timestamps": NeuralType(('B', 'C', 'T', 'D'), LengthsType()),
-            "ms_seg_counts": NeuralType(('B', 'C'), LengthsType()),
-            "clus_label_index": NeuralType(('B', 'T'), LengthsType()),
-            "scale_mapping": NeuralType(('B', 'C', 'T'), LengthsType()),
-            "targets": NeuralType(('B', 'T', 'C'), ProbsType()),
-        }
-
-        return output_types
-
-    def __init__(
-        self,
-        *,
-        manifest_filepath: str,
-        multiscale_args_dict: str,
-        emb_dir: str,
-        soft_label_thres: float,
-        featurizer,
-        window_stride,
-        emb_batch_size,
-        pairwise_infer: bool,
-        random_flip: bool = True,
-        global_rank: int = 0,
-    ):
-        super().__init__()
-        self.collection = DiarizationSpeechLabel(
-            manifests_files=manifest_filepath.split(','),
-            emb_dict=None,
-            clus_label_dict=None,
-            pairwise_infer=pairwise_infer,
-        )
-        self.featurizer = featurizer
-        self.multiscale_args_dict = multiscale_args_dict
-        self.emb_dir = emb_dir
-        self.round_digits = 2
-        self.decim = 10**self.round_digits
-        self.soft_label_thres = soft_label_thres
-        self.pairwise_infer = pairwise_infer
-        self.max_spks = 2
-        self.frame_per_sec = int(1 / window_stride)
-        self.emb_batch_size = emb_batch_size
-        self.random_flip = random_flip
-        self.global_rank = global_rank
-        self.manifest_filepath = manifest_filepath
-        self.multiscale_timestamp_dict = prepare_split_data(
-            self.manifest_filepath,
-            self.emb_dir,
-            self.multiscale_args_dict,
-            self.global_rank,
-        )
-
-    def __len__(self):
-        return len(self.collection)
-
-    def assign_labels_to_longer_segs(self, uniq_id, base_scale_clus_label):
-        """
-        Assign the generated speaker labels from the base scale (the finest scale) to the longer scales.
-        This process is needed to get the cluster labels for each scale. The cluster labels are needed to
-        calculate the cluster-average speaker embedding for each scale.
-
-        Args:
-            uniq_id (str):
-                Unique sample ID for training.
-            base_scale_clus_label (torch.tensor):
-                Tensor variable containing the speaker labels for the base-scale segments.
-
-        Returns:
-            per_scale_clus_label (torch.tensor):
-                Tensor variable containing the speaker labels for each segment in each scale.
-                Note that the total length of the speaker label sequence differs over scale since
-                each scale has a different number of segments for the same session.
-
-            scale_mapping (torch.tensor):
-                Matrix containing the segment indices of each scale. scale_mapping is necessary for reshaping the
-                multiscale embeddings to form an input matrix for the MSDD model.
-        """
-        per_scale_clus_label = []
-        self.scale_n = len(self.multiscale_timestamp_dict[uniq_id]['scale_dict'])
-        uniq_scale_mapping = get_scale_mapping_list(self.multiscale_timestamp_dict[uniq_id])
-        for scale_index in range(self.scale_n):
-            new_clus_label = []
-            scale_seq_len = len(self.multiscale_timestamp_dict[uniq_id]["scale_dict"][scale_index]["time_stamps"])
-            for seg_idx in range(scale_seq_len):
-                if seg_idx in uniq_scale_mapping[scale_index]:
-                    seg_clus_label = mode(base_scale_clus_label[uniq_scale_mapping[scale_index] == seg_idx])
-                else:
-                    seg_clus_label = 0 if len(new_clus_label) == 0 else new_clus_label[-1]
-                new_clus_label.append(seg_clus_label)
-            per_scale_clus_label.extend(new_clus_label)
-        per_scale_clus_label = torch.tensor(per_scale_clus_label)
-        return per_scale_clus_label, uniq_scale_mapping
-
-    def get_diar_target_labels(self, uniq_id, sample, fr_level_target):
-        """
-        Convert frame-level diarization target variable into segment-level target variable.
-        Since the granularity is reduced from frame level (10ms) to segment level (100ms~500ms),
-        we need a threshold value, `soft_label_thres`, which determines the label of each segment
-        based on the overlap between a segment range (start and end time) and the frame-level target variable.
-
-        Args:
-            uniq_id (str):
-                Unique file ID that refers to an input audio file and corresponding RTTM (Annotation) file.
-            sample:
-                `DiarizationSpeechLabel` instance containing sample information such as
-                audio filepath and RTTM filepath.
-            fr_level_target (torch.tensor):
-                Tensor containing label for each feature-level frame.
-
-        Returns:
-            seg_target (torch.tensor):
-                Tensor containing binary speaker labels for base-scale segments.
-            base_clus_label (torch.tensor):
-                Representative speaker label for each segment. This variable only has one speaker label
-                for each base-scale segment.
-                -1 means that there is no corresponding speaker in the target_spks tuple.
-        """
-        seg_target_list, base_clus_label = [], []
-        self.scale_n = len(self.multiscale_timestamp_dict[uniq_id]['scale_dict'])
-        subseg_time_stamp_list = self.multiscale_timestamp_dict[uniq_id]["scale_dict"][self.scale_n - 1]["time_stamps"]
-        for seg_stt, seg_end in subseg_time_stamp_list:
-            seg_stt_fr, seg_end_fr = int(seg_stt * self.frame_per_sec), int(seg_end * self.frame_per_sec)
-            soft_label_vec_sess = torch.sum(fr_level_target[seg_stt_fr:seg_end_fr, :], axis=0) / (
-                seg_end_fr - seg_stt_fr
-            )
-            label_int_sess = torch.argmax(soft_label_vec_sess)
-            soft_label_vec = soft_label_vec_sess.unsqueeze(0)[:, sample.target_spks].squeeze()
-            if label_int_sess in sample.target_spks and torch.sum(soft_label_vec_sess) > 0:
-                label_int = sample.target_spks.index(label_int_sess)
-            else:
-                label_int = -1
-            label_vec = (soft_label_vec > self.soft_label_thres).float()
-            seg_target_list.append(label_vec.detach())
-            base_clus_label.append(label_int)
-        seg_target = torch.stack(seg_target_list)
-        base_clus_label = torch.tensor(base_clus_label)
-        return seg_target, base_clus_label
-
-    def parse_rttm_for_ms_targets(self, sample):
-        """
-        Generate target tensor variable by extracting groundtruth diarization labels from an RTTM file.
-        This function converts (start, end, speaker_id) format into base-scale (the finest scale) segment level
-        diarization label in a matrix form.
-
-        Example of seg_target:
-            [[0., 1.], [0., 1.], [1., 1.], [1., 0.], [1., 0.], ..., [0., 1.]]
-
-        Args:
-            sample:
-                `DiarizationSpeechLabel` instance containing sample information such as
-                audio filepath and RTTM filepath.
-            target_spks (tuple):
-                Speaker indices that are generated from combinations. If there are only one or two speakers,
-                only a single target_spks tuple is generated.
-
-        Returns:
-            clus_label_index (torch.tensor):
-                Groundtruth clustering label (cluster index for each segment) from RTTM files for training purpose.
-            seg_target  (torch.tensor):
-                Tensor variable containing hard-labels of speaker activity in each base-scale segment.
-            scale_mapping (torch.tensor):
-                Matrix containing the segment indices of each scale. scale_mapping is necessary for reshaping the
-                multiscale embeddings to form an input matrix for the MSDD model.
-
-        """
-        with open(sample.rttm_file, 'r') as file:
-            rttm_lines = file.readlines()
-        uniq_id = self.get_uniq_id_with_range(sample)
-        rttm_timestamps = extract_seg_info_from_rttm(rttm_lines)
-        fr_level_target = assign_frame_level_spk_vector(
-            rttm_timestamps, self.round_digits, self.frame_per_sec, target_spks=sample.target_spks
-        )
-        seg_target, base_clus_label = self.get_diar_target_labels(uniq_id, sample, fr_level_target)
-        clus_label_index, scale_mapping = self.assign_labels_to_longer_segs(uniq_id, base_clus_label)
-        return clus_label_index, seg_target, scale_mapping
-
-    def get_uniq_id_with_range(self, sample, deci=3):
-        """
-        Generate unique training sample ID from unique file ID, offset and duration. The start-end time added
-        unique ID is required for identifying the sample since multiple short audio samples are generated from a single
-        audio file. The start time and end time of the audio stream uses millisecond units if `deci=3`.
-
-        Args:
-            sample:
-                `DiarizationSpeechLabel` instance from collections.
-
-        Returns:
-            uniq_id (str):
-                Unique sample ID which includes start and end time of the audio stream.
-                Example: abc1001_3122_6458
-
-        """
-        bare_uniq_id = os.path.splitext(os.path.basename(sample.rttm_file))[0]
-        offset = str(int(round(sample.offset, deci) * pow(10, deci)))
-        endtime = str(int(round(sample.offset + sample.duration, deci) * pow(10, deci)))
-        uniq_id = f"{bare_uniq_id}_{offset}_{endtime}"
-        return uniq_id
-
-    def get_ms_seg_timestamps(self, sample):
-        """
-        Get start and end time of each diarization frame.
-
-        Args:
-            sample:
-                `DiarizationSpeechLabel` instance from preprocessing.collections
-        Returns:
-            ms_seg_timestamps (torch.tensor):
-                Tensor containing timestamps for each frame.
-            ms_seg_counts (torch.tensor):
-                Number of segments for each scale. This information is used for reshaping embedding batch
-                during forward propagation.
-        """
-        uniq_id = self.get_uniq_id_with_range(sample)
-        ms_seg_timestamps_list = []
-        max_seq_len = len(self.multiscale_timestamp_dict[uniq_id]["scale_dict"][self.scale_n - 1]["time_stamps"])
-        ms_seg_counts = [0 for _ in range(self.scale_n)]
-        for scale_idx in range(self.scale_n):
-            scale_ts_list = []
-            for k, (seg_stt, seg_end) in enumerate(
-                self.multiscale_timestamp_dict[uniq_id]["scale_dict"][scale_idx]["time_stamps"]
-            ):
-                stt, end = (
-                    int((seg_stt - sample.offset) * self.frame_per_sec),
-                    int((seg_end - sample.offset) * self.frame_per_sec),
-                )
-                scale_ts_list.append(torch.tensor([stt, end]).detach())
-            ms_seg_counts[scale_idx] = len(
-                self.multiscale_timestamp_dict[uniq_id]["scale_dict"][scale_idx]["time_stamps"]
-            )
-            scale_ts = torch.stack(scale_ts_list)
-            scale_ts_padded = torch.cat([scale_ts, torch.zeros(max_seq_len - len(scale_ts_list), 2)], dim=0)
-            ms_seg_timestamps_list.append(scale_ts_padded.detach())
-        ms_seg_timestamps = torch.stack(ms_seg_timestamps_list)
-        ms_seg_counts = torch.tensor(ms_seg_counts)
-        return ms_seg_timestamps, ms_seg_counts
-
-    def __getitem__(self, index):
-        sample = self.collection[index]
-        if sample.offset is None:
-            sample.offset = 0
-        clus_label_index, targets, scale_mapping = self.parse_rttm_for_ms_targets(sample)
-        features = self.featurizer.process(sample.audio_file, offset=sample.offset, duration=sample.duration)
-        feature_length = torch.tensor(features.shape[0]).long()
-        ms_seg_timestamps, ms_seg_counts = self.get_ms_seg_timestamps(sample)
-        if self.random_flip:
-            torch.manual_seed(index)
-            flip = torch.cat([torch.randperm(self.max_spks), torch.tensor(-1).unsqueeze(0)])
-            clus_label_index, targets = flip[clus_label_index], targets[:, flip[: self.max_spks]]
-        return features, feature_length, ms_seg_timestamps, ms_seg_counts, clus_label_index, scale_mapping, targets
-
-
-class _AudioMSDDInferDataset(Dataset):
-    """
-    Dataset class that loads a json file containing paths to audio files,
-    RTTM files and number of speakers. This Dataset class is built for diarization inference and
-    evaluation. Speaker embedding sequences, segment timestamps, cluster-average speaker embeddings
-    are loaded from memory and fed into the dataloader.
-
-    Example:
-    {"audio_filepath": "/path/to/audio_0.wav", "num_speakers": 2,
-    "rttm_filepath": "/path/to/diar_label_0.rttm}
-    ...
-    {"audio_filepath": "/path/to/audio_n.wav", "num_speakers": 2,
-    "rttm_filepath": "/path/to/diar_label_n.rttm}
-
-    Args:
-        manifest_filepath (str):
-             Path to input manifest json files.
-        emb_dict (dict):
-            Dictionary containing cluster-average embeddings and speaker mapping information.
-        emb_seq (dict):
-            Dictionary containing multiscale speaker embedding sequence,
-            scale mapping and corresponding segment timestamps.
-        clus_label_dict (dict):
-            Subsegment-level (from base-scale) speaker labels from clustering results.
-        soft_label_thres (float):
-            A threshold that determines the label of each segment based on RTTM file information.
-        featurizer:
-            Featurizer instance for generating features from raw waveform.
-        seq_eval_mode (bool):
-            If True, F1 score will be calculated for each speaker pair during inference mode.
-        window_stride (float):
-            Window stride for acoustic feature. This value is used for calculating the numbers of feature-level frames.
-        use_single_scale_clus (bool):
-            Use only one scale for clustering instead of using multiple scales of embeddings for clustering.
-        pairwise_infer (bool):
-            This variable should be True if dataloader is created for an inference task.
-    """
-
-    @property
-    def output_types(self) -> Optional[Dict[str, NeuralType]]:
-        """Returns definitions of module output ports."""
-        output_types = OrderedDict(
-            {
-                "ms_emb_seq": NeuralType(('B', 'T', 'C', 'D'), SpectrogramType()),
-                "length": NeuralType(tuple('B'), LengthsType()),
-                "ms_avg_embs": NeuralType(('B', 'C', 'D', 'C'), EncodedRepresentation()),
-                "targets": NeuralType(('B', 'T', 'C'), ProbsType()),
-            }
-        )
-        return output_types
-
-    def __init__(
-        self,
-        *,
-        manifest_filepath: str,
-        emb_dict: Dict,
-        emb_seq: Dict,
-        clus_label_dict: Dict,
-        soft_label_thres: float,
-        seq_eval_mode: bool,
-        window_stride: float,
-        use_single_scale_clus: bool,
-        pairwise_infer: bool,
-    ):
-        super().__init__()
-        self.collection = DiarizationSpeechLabel(
-            manifests_files=manifest_filepath.split(','),
-            emb_dict=emb_dict,
-            clus_label_dict=clus_label_dict,
-            seq_eval_mode=seq_eval_mode,
-            pairwise_infer=pairwise_infer,
-        )
-        self.emb_dict = emb_dict
-        self.emb_seq = emb_seq
-        self.clus_label_dict = clus_label_dict
-        self.round_digits = 2
-        self.decim = 10**self.round_digits
-        self.frame_per_sec = int(1 / window_stride)
-        self.soft_label_thres = soft_label_thres
-        self.pairwise_infer = pairwise_infer
-        self.max_spks = 2
-        self.use_single_scale_clus = use_single_scale_clus
-        self.seq_eval_mode = seq_eval_mode
-
-    def __len__(self):
-        return len(self.collection)
-
-    def parse_rttm_multiscale(self, sample):
-        """
-        Generate target tensor variable by extracting groundtruth diarization labels from an RTTM file.
-        This function is only used when ``self.seq_eval_mode=True`` and RTTM files are provided. This function converts
-        (start, end, speaker_id) format into base-scale (the finest scale) segment level diarization label in a matrix
-        form to create target matrix.
-
-        Args:
-            sample:
-                DiarizationSpeechLabel instance containing sample information such as audio filepath and RTTM filepath.
-            target_spks (tuple):
-                Two Indices of targeted speakers for evaluation.
-                Example of target_spks: (2, 3)
-        Returns:
-            seg_target (torch.tensor):
-                Tensor variable containing hard-labels of speaker activity in each base-scale segment.
-        """
-        if sample.rttm_file is None:
-            raise ValueError(f"RTTM file is not provided for this sample {sample}")
-        rttm_lines = open(sample.rttm_file).readlines()
-        uniq_id = os.path.splitext(os.path.basename(sample.rttm_file))[0]
-        mapping_dict = self.emb_dict[max(self.emb_dict.keys())][uniq_id]['mapping']
-        rttm_timestamps = extract_seg_info_from_rttm(rttm_lines, mapping_dict, sample.target_spks)
-        fr_level_target = assign_frame_level_spk_vector(
-            rttm_timestamps, self.round_digits, self.frame_per_sec, sample.target_spks
-        )
-        seg_target = self.get_diar_target_labels_from_fr_target(uniq_id, fr_level_target)
-        return seg_target
-
-    def get_diar_target_labels_from_fr_target(self, uniq_id: str, fr_level_target: torch.Tensor) -> torch.Tensor:
-        """
-        Generate base-scale level binary diarization label from frame-level target matrix. For the given frame-level
-        speaker target matrix fr_level_target, we count the number of frames that belong to each speaker and calculate
-        ratios for each speaker into the `soft_label_vec` variable. Finally, `soft_label_vec` variable is compared
-        with `soft_label_thres` to determine whether a label vector should contain 0 or 1 for each speaker bin.
-        Note that seg_target variable has dimension of (number of base-scale segments x 2) dimension.
-
-        Example of seg_target:
-            [[0., 1.], [0., 1.], [1., 1.], [1., 0.], [1., 0.], ..., [0., 1.]]
-
-        Args:
-            uniq_id (str):
-                Unique file ID that refers to an input audio file and corresponding RTTM (Annotation) file.
-            fr_level_target (torch.tensor):
-                frame-level binary speaker annotation (1: exist 0: non-exist) generated from RTTM file.
-
-        Returns:
-            seg_target (torch.tensor):
-                Tensor variable containing binary hard-labels of speaker activity in each base-scale segment.
-
-        """
-        if fr_level_target is None:
-            return None
-        else:
-            seg_target_list = []
-            for seg_stt, seg_end, label_int in self.clus_label_dict[uniq_id]:
-                seg_stt_fr, seg_end_fr = int(seg_stt * self.frame_per_sec), int(seg_end * self.frame_per_sec)
-                soft_label_vec = torch.sum(fr_level_target[seg_stt_fr:seg_end_fr, :], axis=0) / (
-                    seg_end_fr - seg_stt_fr
-                )
-                label_vec = (soft_label_vec > self.soft_label_thres).int()
-                seg_target_list.append(label_vec)
-            seg_target = torch.stack(seg_target_list)
-            return seg_target
-
-    def __getitem__(self, index):
-        sample = self.collection[index]
-        if sample.offset is None:
-            sample.offset = 0
-
-        uniq_id = os.path.splitext(os.path.basename(sample.audio_file))[0]
-        scale_n = len(self.emb_dict.keys())
-        _avg_embs = torch.stack([self.emb_dict[scale_index][uniq_id]['avg_embs'] for scale_index in range(scale_n)])
-
-        if self.pairwise_infer:
-            avg_embs = _avg_embs[:, :, self.collection[index].target_spks]
-        else:
-            avg_embs = _avg_embs
-
-        if avg_embs.shape[2] > self.max_spks:
-            raise ValueError(
-                f" avg_embs.shape[2] {avg_embs.shape[2]} should be less than or equal to "
-                f"self.max_num_speakers {self.max_spks}"
-            )
-
-        feats = []
-        for scale_index in range(scale_n):
-            repeat_mat = self.emb_seq["session_scale_mapping"][uniq_id][scale_index]
-            feats.append(self.emb_seq[scale_index][uniq_id][repeat_mat, :])
-        feats_out = torch.stack(feats).permute(1, 0, 2)
-        feats_len = feats_out.shape[0]
-
-        if self.seq_eval_mode:
-            targets = self.parse_rttm_multiscale(sample)
-        else:
-            targets = torch.zeros(feats_len, 2).float()
-
-        return feats_out, feats_len, targets, avg_embs
-
-
-def _msdd_train_collate_fn(self, batch):
-    """
-    Collate batch of variables that are needed for raw waveform to diarization label training.
-    The following variables are included in training/validation batch:
-
-    Args:
-        batch (tuple):
-            Batch tuple containing the variables for the diarization training.
-    Returns:
-        features (torch.tensor):
-            Raw waveform samples (time series) loaded from the audio_filepath in the input manifest file.
-        feature lengths (time series sample length):
-            A list of lengths of the raw waveform samples.
-        ms_seg_timestamps (torch.tensor):
-            Matrix containing the start time and end time (timestamps) for each segment and each scale.
-            ms_seg_timestamps is needed for extracting acoustic features from raw waveforms.
-        ms_seg_counts (torch.tensor):
-            Matrix containing The number of segments for each scale. ms_seg_counts is necessary for reshaping
-            the input matrix for the MSDD model.
-        clus_label_index (torch.tensor):
-            Groundtruth Clustering label (cluster index for each segment) from RTTM files for training purpose.
-            clus_label_index is necessary for calculating cluster-average embedding.
-        scale_mapping (torch.tensor):
-            Matrix containing the segment indices of each scale. scale_mapping is necessary for reshaping the
-            multiscale embeddings to form an input matrix for the MSDD model.
-        targets (torch.tensor):
-            Groundtruth Speaker label for the given input embedding sequence.
-    """
-    packed_batch = list(zip(*batch))
-    features, feature_length, ms_seg_timestamps, ms_seg_counts, clus_label_index, scale_mapping, targets = packed_batch
-    features_list, feature_length_list = [], []
-    ms_seg_timestamps_list, ms_seg_counts_list, scale_clus_label_list, scale_mapping_list, targets_list = (
-        [],
-        [],
-        [],
-        [],
-        [],
-    )
-
-    max_raw_feat_len = max([x.shape[0] for x in features])
-    max_target_len = max([x.shape[0] for x in targets])
-    max_total_seg_len = max([x.shape[0] for x in clus_label_index])
-
-    for feat, feat_len, ms_seg_ts, ms_seg_ct, scale_clus, scl_map, tgt in batch:
-        seq_len = tgt.shape[0]
-        pad_feat = (0, max_raw_feat_len - feat_len)
-        pad_tgt = (0, 0, 0, max_target_len - seq_len)
-        pad_sm = (0, max_target_len - seq_len)
-        pad_ts = (0, 0, 0, max_target_len - seq_len)
-        pad_sc = (0, max_total_seg_len - scale_clus.shape[0])
-        padded_feat = torch.nn.functional.pad(feat, pad_feat)
-        padded_tgt = torch.nn.functional.pad(tgt, pad_tgt)
-        padded_sm = torch.nn.functional.pad(scl_map, pad_sm)
-        padded_ms_seg_ts = torch.nn.functional.pad(ms_seg_ts, pad_ts)
-        padded_scale_clus = torch.nn.functional.pad(scale_clus, pad_sc)
-
-        features_list.append(padded_feat)
-        feature_length_list.append(feat_len.clone().detach())
-        ms_seg_timestamps_list.append(padded_ms_seg_ts)
-        ms_seg_counts_list.append(ms_seg_ct.clone().detach())
-        scale_clus_label_list.append(padded_scale_clus)
-        scale_mapping_list.append(padded_sm)
-        targets_list.append(padded_tgt)
-
-    features = torch.stack(features_list)
-    feature_length = torch.stack(feature_length_list)
-    ms_seg_timestamps = torch.stack(ms_seg_timestamps_list)
-    clus_label_index = torch.stack(scale_clus_label_list)
-    ms_seg_counts = torch.stack(ms_seg_counts_list)
-    scale_mapping = torch.stack(scale_mapping_list)
-    targets = torch.stack(targets_list)
-    return features, feature_length, ms_seg_timestamps, ms_seg_counts, clus_label_index, scale_mapping, targets
-
-
-def _msdd_infer_collate_fn(self, batch):
-    """
-    Collate batch of feats (speaker embeddings), feature lengths, target label sequences
-    and cluster-average embeddings.
-
-    Args:
-        batch (tuple):
-            Batch tuple containing feats, feats_len, targets and ms_avg_embs.
-    Returns:
-        feats (torch.tensor):
-            Collated speaker embedding with unified length.
-        feats_len (torch.tensor):
-            The actual length of each embedding sequence without zero padding.
-        targets (torch.tensor):
-            Groundtruth Speaker label for the given input embedding sequence.
-        ms_avg_embs (torch.tensor):
-            Cluster-average speaker embedding vectors.
-    """
-
-    packed_batch = list(zip(*batch))
-    feats, feats_len, targets, ms_avg_embs = packed_batch
-    feats_list, flen_list, targets_list, ms_avg_embs_list = [], [], [], []
-    max_audio_len = max(feats_len)
-    max_target_len = max([x.shape[0] for x in targets])
-
-    for feature, feat_len, target, ivector in batch:
-        flen_list.append(feat_len)
-        ms_avg_embs_list.append(ivector)
-        if feat_len < max_audio_len:
-            pad_a = (0, 0, 0, 0, 0, max_audio_len - feat_len)
-            pad_t = (0, 0, 0, max_target_len - target.shape[0])
-            padded_feature = torch.nn.functional.pad(feature, pad_a)
-            padded_target = torch.nn.functional.pad(target, pad_t)
-            feats_list.append(padded_feature)
-            targets_list.append(padded_target)
-        else:
-            targets_list.append(target.clone().detach())
-            feats_list.append(feature.clone().detach())
-
-    feats = torch.stack(feats_list)
-    feats_len = torch.tensor(flen_list)
-    targets = torch.stack(targets_list)
-    ms_avg_embs = torch.stack(ms_avg_embs_list)
-    return feats, feats_len, targets, ms_avg_embs
-
-
-class AudioToSpeechMSDDTrainDataset(_AudioMSDDTrainDataset):
-    """
-    Dataset class that loads a json file containing paths to audio files,
-    rttm files and number of speakers. This Dataset class is designed for
-    training or fine-tuning speaker embedding extractor and diarization decoder
-    at the same time.
-
-    Example:
-    {"audio_filepath": "/path/to/audio_0.wav", "num_speakers": 2,
-    "rttm_filepath": "/path/to/diar_label_0.rttm}
-    ...
-    {"audio_filepath": "/path/to/audio_n.wav", "num_speakers": 2,
-    "rttm_filepath": "/path/to/diar_label_n.rttm}
-
-    Args:
-        manifest_filepath (str):
-            Path to input manifest json files.
-        multiscale_args_dict (dict):
-            Dictionary containing the parameters for multiscale segmentation and clustering.
-        emb_dir (str):
-            Path to a temporary folder where segmentation information for embedding extraction is saved.
-        soft_label_thres (float):
-            A threshold that determines the label of each segment based on RTTM file information.
-        featurizer:
-            Featurizer instance for generating features from the raw waveform.
-        window_stride (float):
-            Window stride for acoustic feature. This value is used for calculating the numbers of feature-level frames.
-        emb_batch_size (int):
-            Number of embedding vectors that are trained with attached computational graphs.
-        pairwise_infer (bool):
-            This variable should be True if dataloader is created for an inference task.
-    """
-
-    def __init__(
-        self,
-        *,
-        manifest_filepath: str,
-        multiscale_args_dict: Dict,
-        emb_dir: str,
-        soft_label_thres: float,
-        featurizer,
-        window_stride,
-        emb_batch_size,
-        pairwise_infer: bool,
-        global_rank: int,
-    ):
-        super().__init__(
-            manifest_filepath=manifest_filepath,
-            multiscale_args_dict=multiscale_args_dict,
-            emb_dir=emb_dir,
-            soft_label_thres=soft_label_thres,
-            featurizer=featurizer,
-            window_stride=window_stride,
-            emb_batch_size=emb_batch_size,
-            pairwise_infer=pairwise_infer,
-            global_rank=global_rank,
-        )
-
-    def msdd_train_collate_fn(self, batch):
-        """Collate batch of audio features, feature lengths, target label sequences for training."""
-        return _msdd_train_collate_fn(self, batch)
-
-
-class AudioToSpeechMSDDInferDataset(_AudioMSDDInferDataset):
-    """
-    Dataset class that loads a json file containing paths to audio files,
-    rttm files and number of speakers. The created labels are used for diarization inference.
-
-    Example:
-    {"audio_filepath": "/path/to/audio_0.wav", "num_speakers": 2,
-    "rttm_filepath": "/path/to/diar_label_0.rttm}
-    ...
-    {"audio_filepath": "/path/to/audio_n.wav", "num_speakers": 2,
-    "rttm_filepath": "/path/to/diar_label_n.rttm}
-
-    Args:
-        manifest_filepath (str):
-            Path to input manifest json files.
-        emb_dict (dict):
-            Dictionary containing cluster-average embeddings and speaker mapping information.
-        emb_seq (dict):
-            Dictionary containing multiscale speaker embedding sequence, scale mapping
-            and corresponding segment timestamps.
-        clus_label_dict (dict):
-            Subsegment-level (from base-scale) speaker labels from clustering results.
-        soft_label_thres (float):
-            Threshold that determines speaker labels of segments depending on the overlap
-            with groundtruth speaker timestamps.
-        featurizer:
-            Featurizer instance for generating features from raw waveform.
-        use_single_scale_clus (bool):
-            Use only one scale for clustering instead of using multiple scales of embeddings for clustering.
-        seq_eval_mode (bool):
-            If True, F1 score will be calculated for each speaker pair during inference mode.
-        window_stride (float):
-            Window stride for acoustic feature. This value is used for calculating the numbers of
-            feature-level frames.
-        pairwise_infer (bool):
-            If True, this Dataset class operates in inference mode. In inference mode, a set of speakers
-            in the input audio is split into multiple pairs of speakers and speaker tuples
-            (e.g. 3 speakers: [(0,1), (1,2), (0,2)]) and then fed into the MSDD to merge the individual results.
-    """
-
-    def __init__(
-        self,
-        *,
-        manifest_filepath: str,
-        emb_dict: Dict,
-        emb_seq: Dict,
-        clus_label_dict: Dict,
-        soft_label_thres: float,
-        use_single_scale_clus: bool,
-        seq_eval_mode: bool,
-        window_stride: float,
-        pairwise_infer: bool,
-    ):
-        super().__init__(
-            manifest_filepath=manifest_filepath,
-            emb_dict=emb_dict,
-            emb_seq=emb_seq,
-            clus_label_dict=clus_label_dict,
-            soft_label_thres=soft_label_thres,
-            use_single_scale_clus=use_single_scale_clus,
-            window_stride=window_stride,
-            seq_eval_mode=seq_eval_mode,
-            pairwise_infer=pairwise_infer,
-        )
-
-    def msdd_infer_collate_fn(self, batch):
-        """Collate batch of audio features, feature lengths, target label sequences for inference."""
-        return _msdd_infer_collate_fn(self, batch)
-
-
 class _AudioToSpeechE2ESpkDiarDataset(Dataset):
     """
     Dataset class that loads a json file containing paths to audio files,
@@ -1058,6 +206,7 @@ class _AudioToSpeechE2ESpkDiarDataset(Dataset):
         session_len_sec: float,
         num_spks: int,
         featurizer,
+        fb_featurizer,
         window_stride: float,
         min_subsegment_duration: float = 0.03,
         global_rank: int = 0,
@@ -1073,6 +222,13 @@ class _AudioToSpeechE2ESpkDiarDataset(Dataset):
             round_digits=round_digits,
         )
         self.featurizer = featurizer
+        self.fb_featurizer = fb_featurizer
+        # STFT and subsampling factor parameters
+        self.n_fft = self.fb_featurizer.n_fft
+        self.hop_length = self.fb_featurizer.hop_length
+        self.stft_pad_amount = self.fb_featurizer.stft_pad_amount
+        self.subsampling_factor = subsampling_factor
+        # Annotation and target length parameters
         self.round_digits = round_digits
         self.feat_per_sec = int(1 / window_stride)
         self.diar_frame_length = round(subsampling_factor * window_stride, round_digits)
@@ -1086,10 +242,30 @@ class _AudioToSpeechE2ESpkDiarDataset(Dataset):
         self.round_digits = 2
         self.floor_decimal = 10**self.round_digits
         self.device = device
+        self.global_rank = global_rank
 
     def __len__(self):
         return len(self.collection)
 
+    def get_frame_count_from_time_series_length(self, seq_len):
+        """
+        This function is used to get the sequence length of the audio signal. This is required to match
+        the feature frame length with ASR (STT) models. This function is copied from
+        NeMo/nemo/collections/asr/parts/preprocessing/features.py::FilterbankFeatures::get_seq_len.
+
+        Args:
+            seq_len (int):
+                The sequence length of the time-series data.
+
+        Returns:
+            seq_len (int):
+                The sequence length of the feature frames.
+        """
+        pad_amount = self.stft_pad_amount * 2 if self.stft_pad_amount is not None else self.n_fft // 2 * 2
+        seq_len = torch.floor_divide((seq_len + pad_amount - self.n_fft), self.hop_length).to(dtype=torch.long)
+        frame_count = int(np.ceil(seq_len / self.subsampling_factor))
+        return frame_count
+
     def get_uniq_id_with_range(self, sample, deci=3):
         """
         Generate unique training sample ID from unique file ID, offset and duration. The start-end time added
@@ -1098,7 +274,7 @@ class _AudioToSpeechE2ESpkDiarDataset(Dataset):
 
         Args:
             sample:
-                `DiarizationSpeechLabel` instance from collections.
+                `EndtoEndDiarizationSpeechLabel` instance from collections.
 
         Returns:
             uniq_id (str):
@@ -1188,7 +364,7 @@ class _AudioToSpeechE2ESpkDiarDataset(Dataset):
 
         Args:
             sample:
-                `DiarizationSpeechLabel` instance from preprocessing.collections
+                `EndtoEndDiarizationSpeechLabel` instance from preprocessing.collections
         Returns:
             segment_timestamps (torch.tensor):
                 Tensor containing Multiscale segment timestamps.
@@ -1238,10 +414,15 @@ class _AudioToSpeechE2ESpkDiarDataset(Dataset):
         )
         audio_signal = audio_signal[: round(self.featurizer.sample_rate * session_len_sec)]
         audio_signal_length = torch.tensor(audio_signal.shape[0]).long()
+
+        # Target length should be following the ASR feature extraction convention: Use self.get_frame_count_from_time_series_length.
         target_len = self.get_segment_timestamps(duration=session_len_sec, sample_rate=self.featurizer.sample_rate)
+        target_len = torch.clamp(target_len, max=self.get_frame_count_from_time_series_length(audio_signal.shape[0]))
+
         targets = self.parse_rttm_for_targets_and_lens(
             rttm_file=sample.rttm_file, offset=offset, duration=session_len_sec, target_len=target_len
         )
+        targets = targets[:target_len, :]
         return audio_signal, audio_signal_length, targets, target_len
 
 
@@ -1357,6 +538,7 @@ class AudioToSpeechE2ESpkDiarDataset(_AudioToSpeechE2ESpkDiarDataset):
         session_len_sec: float,
         num_spks: int,
         featurizer,
+        fb_featurizer,
         window_stride,
         global_rank: int,
         soft_targets: bool,
@@ -1368,6 +550,7 @@ class AudioToSpeechE2ESpkDiarDataset(_AudioToSpeechE2ESpkDiarDataset):
             session_len_sec=session_len_sec,
             num_spks=num_spks,
             featurizer=featurizer,
+            fb_featurizer=fb_featurizer,
             window_stride=window_stride,
             global_rank=global_rank,
             soft_targets=soft_targets,

nemo/collections/asr/data/audio_to_diar_label_lhotse.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2024, NVIDIA CORPORATION.  All rights reserved.
+# Copyright (c) 2025, NVIDIA CORPORATION.  All rights reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -23,6 +23,7 @@ from nemo.collections.asr.parts.utils.asr_multispeaker_utils import (
     speaker_to_target,
 )
 from nemo.core.neural_types import AudioSignal, LabelsType, LengthsType, NeuralType
+from nemo.utils import logging
 
 
 class LhotseAudioToSpeechE2ESpkDiarDataset(torch.utils.data.Dataset):
@@ -55,22 +56,53 @@ class LhotseAudioToSpeechE2ESpkDiarDataset(torch.utils.data.Dataset):
             self.cfg.get('window_stride', 0.01) * self.cfg.get('sample_rate', 16000)
         )  # 160 samples for every 1ms by default
         self.num_mel_frame_per_target_frame = int(self.cfg.get('subsampling_factor', 8))
-        self.spk_tar_all_zero = self.cfg.get('spk_tar_all_zero', False)
 
     def __getitem__(self, cuts) -> Tuple[torch.Tensor, ...]:
-        audio, audio_lens, cuts = self.load_audio(cuts)
+        # NOTE: This end-to-end diarization dataloader only loads the 1st ch of the audio file.
+        # Process cuts in a single loop: convert to mono and compute speaker activities
+        mono_cuts = []
         speaker_activities = []
         for cut in cuts:
+            if cut.num_channels is not None and cut.num_channels > 1:
+                logging.warning(
+                    "Multiple channels detected in cut '%s' (%d channels). "
+                    "Only the first channel will be used; remaining channels are ignored.",
+                    cut.id,
+                    cut.num_channels,
+                )
+            mono_cut = cut.with_channels(channels=[0])
+            mono_cuts.append(mono_cut)
+
             speaker_activity = speaker_to_target(
-                a_cut=cut,
+                a_cut=mono_cut,
                 num_speakers=self.num_speakers,
                 num_sample_per_mel_frame=self.num_sample_per_mel_frame,
                 num_mel_frame_per_asr_frame=self.num_mel_frame_per_target_frame,
-                spk_tar_all_zero=self.spk_tar_all_zero,
                 boundary_segments=True,
             )
+            # This line prevents dimension mismatch error in the collate_matrices function.
+            if speaker_activity.shape[1] > self.num_speakers:
+                logging.warning(
+                    "Number of speakers in the target %s is greater than "
+                    "the maximum number of speakers %s. Truncating extra speakers. "
+                    "Set the `num_speakers` to higher value to avoid this warning.",
+                    speaker_activity.shape[1],
+                    self.num_speakers,
+                )
+                speaker_activity = speaker_activity[:, : self.num_speakers]
             speaker_activities.append(speaker_activity)
-        targets = collate_matrices(speaker_activities).to(audio.dtype)
+
+        cuts = type(cuts).from_cuts(mono_cuts)
+        audio, audio_lens, cuts = self.load_audio(cuts)
+        targets = collate_matrices(speaker_activities).to(audio.dtype)  # (B, T, N)
+
+        if targets.shape[2] > self.num_speakers:
+            targets = targets[:, :, : self.num_speakers]
+        elif targets.shape[2] < self.num_speakers:
+            targets = torch.nn.functional.pad(
+                targets, (0, self.num_speakers - targets.shape[2]), mode='constant', value=0
+            )
+
         target_lens_list = []
         for audio_len in audio_lens:
             target_fr_len = get_hidden_length_from_sample_length(

nemo/collections/asr/data/audio_to_eou_label_lhotse.py

@@ -0,0 +1,524 @@
+# Copyright (c) 2025, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import math
+from dataclasses import dataclass
+from typing import Dict, List, Optional
+
+import numpy as np
+import torch.utils.data
+from lhotse.cut import Cut, CutSet, MixedCut
+from lhotse.dataset import AudioSamples
+from lhotse.dataset.collation import collate_vectors
+from omegaconf import DictConfig, OmegaConf
+
+from nemo.collections.asr.parts.preprocessing.perturb import process_augmentations
+from nemo.collections.asr.parts.preprocessing.segment import AudioSegment
+from nemo.collections.common.tokenizers.aggregate_tokenizer import TokenizerWrapper
+from nemo.collections.common.tokenizers.tokenizer_spec import TokenizerSpec
+from nemo.core.neural_types import AudioSignal, LabelsType, LengthsType, NeuralType
+from nemo.utils import logging
+
+NON_SPEECH_LABEL = 0
+SPEECH_LABEL = 1
+EOU_LABEL = 2
+EOB_LABEL = 3
+EOU_STRING = '<EOU>'
+EOB_STRING = '<EOB>'
+
+# These augmentations are not supported yet, since they will need to change the SOU/EOU timestamps
+EOU_INVALID_AUGMENTATIONS = ['random_segment', 'speed', 'time_stretch']
+
+
+@dataclass
+class AudioToTextEOUBatch:
+    """
+    Data class for ASR-EOU batch.
+    """
+
+    sample_ids: List | None = None
+    audio_filepaths: List | None = None
+    audio_signal: torch.Tensor | None = None
+    audio_lengths: torch.Tensor | None = None
+    text_tokens: torch.Tensor | None = None
+    text_token_lengths: torch.Tensor | None = None
+    eou_targets: torch.Tensor | None = None
+    eou_target_lengths: torch.Tensor | None = None
+
+
+@dataclass
+class RandomPaddingConfig:
+    prob: float = 0.9  # probability of applying padding
+    min_pad_duration: float = 0.0  # minimum duration of pre/post padding in seconds
+    max_pad_duration: float = 5.0  # maximum duration of pre/post padding in seconds
+    max_total_duration: float = 40.0  # maximum total duration of the padded audio in seconds
+    min_pre_pad_duration: float = 0.0  # minimum duration of pre-padding in seconds
+    min_post_pad_duration: float = 2.0  # minimum duration of post-padding in seconds
+    pad_distribution: str = 'uniform'  # distribution of padding duration, 'uniform' or 'normal' or 'constant'
+    normal_mean: float = 0.5  # mean of normal distribution for padding duration
+    normal_std: float = 2.0  # standard deviation of normal distribution for padding duration
+    pre_pad_duration: float = 0.2  # amount of left-padding when pad_distribution='constant'
+    post_pad_duration: float = 3.0  # amount of right-padding when pad_distribution='constant'
+
+
+class LhotseSpeechToTextBpeEOUDataset(torch.utils.data.Dataset):
+    """
+    This dataset processes the audio data and the corresponding text data to generate the ASR labels,
+    along with EOU labels for each frame. The audios used in this dataset should only contain speech with
+    NO precedding or following silence. The dataset also randomly pads non-speech frames before and after
+    the audio signal for training EOU prediction task.
+
+    To generate EOU labels, the last frame of utterance will be marked as "end of utterance" (labeled as `2`),
+    while if it's a backchannel utterance it'll be marked asd "end of backchannel" (labeled as `3`).
+    The rest of the speech frames will be marked as "speech" (labeled as `1`).
+    The padded non-speech signals will be marked as "non-speech" (labeled as 0).
+
+    Args:
+        cfg: DictConfig object container following keys, usually taken from your `model.train_ds`
+            or `model.validation_ds` config:
+        ```
+            sample_rate: # int, Sample rate of the audio signal
+            window_stride: # float, Window stride for audio encoder
+            subsampling_factor: # Subsampling factor for audio encoder
+            random_padding:  # Random padding configuration
+                prob: 0.9  # probability of applying padding
+                min_pad_duration: 0.5  # minimum duration of pre/post padding in seconds
+                max_pad_duration: 2.0 # maximum duration of pre/post padding in seconds
+                max_total_duration: 30.0  # maximum total duration of the padded audio in seconds
+                pad_distribution: 'uniform'  # distribution of padding duration, 'uniform' or 'normal' or 'constant'
+                normal_mean: 0.5  # mean of normal distribution for padding duration
+                normal_std: 2.0  # standard deviation of normal distribution for padding duration
+                pre_pad_duration: 0.2 # amount of left-padding when pad_distribution='constant'
+                post_pad_duration: 3.0  # amount of right-padding when pad_distribution='constant'
+        ```
+
+    Returns:
+        audio: torch.Tensor of audio signal
+        audio_lens: torch.Tensor of audio signal length
+        text_tokens: torch.Tensor of text text_tokens
+        text_token_lens: torch.Tensor of text token length
+        eou_targets (optional): torch.Tensor of EOU labels
+        eou_target_lens (optional): torch.Tensor of EOU label length
+
+    The input manifest should be a jsonl file where each line is a python dictionary.
+    Example manifest sample:
+    {
+        "audio_filepath": "/path/to/audio.wav",
+        "offset": 0.0,
+        "duration": 6.0,
+        "sou_time": [0.3, 4.0],
+        "eou_time": [1.3, 4.5],
+        "utterances": ["Tell me a joke", "Ah-ha"],
+        "is_backchannel": [False, True],
+    }
+
+    Padding logic:
+    0. Don't pad when `random_padding` is None or during validation/test
+    1. randomly draw a probability to decide whether to apply padding
+    2. if not padding or audio duration is longer than the maximum duration,
+        1) return the original audio and EOU labels
+    3. if apply padding,
+        1) get the max padding duration based on the maximum total duration and the audio duration
+        2) randomly draw a total padding duration based on the given distribution
+        3) randomly split the total padding duration into pre-padding and post-padding
+        4) randomly generate the non-speech signal (audio signal=0) for pre-padding and post-padding
+        5) concatenate the pre-padding, audio, and post-padding to get the padded audio signal
+        6) update the EOU labels accordingly
+
+    """
+
+    @property
+    def output_types(self) -> Optional[Dict[str, NeuralType]]:
+        """Define the output types of the dataset."""
+        return {
+            'audio': NeuralType(('B', 'T'), AudioSignal()),
+            'audio_lens': NeuralType(tuple('B'), LengthsType()),
+            'eou_targets': NeuralType(('B', 'T'), LabelsType()),
+            'eou_target_lens': NeuralType(tuple('B'), LengthsType()),
+            'text_tokens': NeuralType(tuple('B', 'T'), LengthsType(), optional=True),
+            'text_token_lens': NeuralType(tuple('B'), LengthsType(), optional=True),
+        }
+
+    def __init__(self, cfg: DictConfig, tokenizer: TokenizerSpec, return_cuts: bool = False):
+        super().__init__()
+        self.cfg = cfg
+        self.return_cuts = return_cuts
+        self.eou_string = self.cfg.get('eou_string', EOU_STRING)
+        self.eob_string = self.cfg.get('eob_string', EOB_STRING)
+        if cfg.get('check_tokenizer', True):
+            self._check_special_tokens(tokenizer)
+
+        self.tokenizer = TokenizerWrapper(tokenizer)
+        self.load_audio = AudioSamples(fault_tolerant=True)
+        self.sample_rate = self.cfg.get('sample_rate', 16000)
+        self.window_stride = self.cfg.get('window_stride', 0.01)
+        self.num_sample_per_mel_frame = int(
+            self.window_stride * self.sample_rate
+        )  # 160 samples for every 1ms by default
+        self.num_mel_frame_per_target_frame = int(self.cfg.get('subsampling_factor', 8))
+        self.add_sep_before_eou = self.cfg.get('add_sep_before_eou', False)
+        self.add_eou_to_text = self.cfg.get('add_eou_to_text', True)
+        self.pad_eou_label_secs = self.cfg.get('pad_eou_label_secs', 0.0)
+        self.padding_cfg = self.cfg.get('random_padding', None)
+        if self.padding_cfg is not None:
+            self.padding_cfg = OmegaConf.to_container(self.padding_cfg, resolve=True)
+            self.padding_cfg = RandomPaddingConfig(**self.padding_cfg)
+        self.ignore_eob_label = self.cfg.get('ignore_eob_label', False)
+        self.augmentor = None
+        if self.cfg.get('augmentor', None) is not None:
+            augmentor = {}
+            aug_cfg = OmegaConf.to_container(self.cfg.augmentor, resolve=True)
+            for k, v in aug_cfg.items():
+                if k in EOU_INVALID_AUGMENTATIONS:
+                    logging.warning(f"EOU dataset does not support {k} augmentation yet, skipping.")
+                    continue
+                augmentor[k] = v
+
+            if len(augmentor) > 0:
+                logging.info(f"EOU dataset will apply augmentations: {augmentor}")
+                self.augmentor = process_augmentations(augmentor)
+
+    def _check_special_tokens(self, tokenizer: TokenizerSpec):
+        """
+        Check if the special tokens are in the tokenizer vocab.
+        """
+        special_tokens = set([self.eou_string, self.eob_string])
+        vocab_size = tokenizer.vocab_size
+        special_tokens_in_vocab = set([tokenizer.ids_to_text(vocab_size - 1), tokenizer.ids_to_text(vocab_size - 2)])
+        if special_tokens != special_tokens_in_vocab:
+            raise ValueError(
+                f"Input special tokens {special_tokens} don't match with the tokenizer vocab {special_tokens_in_vocab}. "
+                f"Please add them to tokenizer or change input `eou_string` and/or `eob_string` accordingly. "
+                "Special tokens should be added as the last two tokens in the new tokenizer. "
+                "Please refer to scripts/asr_end_of_utterance/tokenizers/add_special_tokens_to_sentencepiece.py for details."
+            )
+
+    def __getitem__(self, cuts: CutSet) -> AudioToTextEOUBatch:
+        audio, audio_lens, cuts = self.load_audio(cuts)
+        audio_signals = []
+        audio_lengths = []
+        eou_targets = []
+        text_tokens = []
+        sample_ids = []
+        audio_filepaths = []
+
+        for i in range(len(cuts)):
+            c = cuts[i]
+            if isinstance(c, MixedCut):
+                c = c.first_non_padding_cut
+
+            sample_ids.append(c.id)
+            audio_filepaths.append(c.recording.sources[0].source)
+
+            audio_i = audio[i]
+            audio_len_i = audio_lens[i]
+
+            # Get EOU labels and text tokens
+            eou_targets_i = self._get_frame_labels(c, audio_len_i)
+            text_tokens_i = self._get_text_tokens(c)
+
+            # Maybe apply random padding to both sides of the audio
+            audio_i, audio_len_i, eou_targets_i = self._random_pad_audio(audio_i, audio_len_i, eou_targets_i)
+
+            # Maybe apply augmentations to the audio signal after padding
+            audio_i, audio_len_i = self._maybe_augment_audio(audio_i, audio_len_i)
+
+            # Append the processed audio, EOU labels, and text tokens to the lists
+            audio_signals.append(audio_i)
+            audio_lengths.append(audio_len_i)
+            eou_targets.append(eou_targets_i)
+            text_tokens.append(text_tokens_i)
+
+        audio_signals = collate_vectors(audio_signals, padding_value=0)
+        audio_lengths = torch.tensor(audio_lengths, dtype=torch.long)
+        eou_target_lens = torch.tensor([t.size(0) for t in eou_targets], dtype=torch.long)
+        eou_targets = collate_vectors(eou_targets, padding_value=0)
+        text_token_lens = torch.tensor([t.size(0) for t in text_tokens], dtype=torch.long)
+        text_tokens = collate_vectors(text_tokens, padding_value=0)
+
+        if self.return_cuts:
+            return audio_signals, audio_lengths, cuts
+
+        return AudioToTextEOUBatch(
+            sample_ids=sample_ids,
+            audio_filepaths=audio_filepaths,
+            audio_signal=audio_signals,
+            audio_lengths=audio_lengths,
+            text_tokens=text_tokens,
+            text_token_lengths=text_token_lens,
+            eou_targets=eou_targets,
+            eou_target_lengths=eou_target_lens,
+        )
+
+    def _audio_len_to_frame_len(self, num_samples: int):
+        """
+        Convert the raw audio length to the number of frames after audio encoder.
+
+        self.num_sample_per_mel_frame = int(
+            self.cfg.get('window_stride', 0.01) * self.cfg.get('sample_rate', 16000)
+        )  # 160 samples for every 1ms by default
+        self.num_mel_frame_per_target_frame = int(self.cfg.get('subsampling_factor', 8))
+        """
+        mel_frame_count = math.ceil((num_samples + 1) / self.num_sample_per_mel_frame)
+        hidden_length = math.ceil(mel_frame_count / self.num_mel_frame_per_target_frame)
+        return hidden_length
+
+    def _repeat_eou_labels(self, eou_targets: torch.Tensor) -> torch.Tensor:
+        """
+        Repeat EOU labels according to self.pad_eou_label_secs
+        Args:
+            eou_targets: torch.Tensor of EOU labels, shape [T]
+        Returns:
+            eou_targets: torch.Tensor of padded EOU labels, shape [T]
+        """
+        if not self.pad_eou_label_secs or self.pad_eou_label_secs <= 0:
+            return eou_targets
+
+        eou_len = self._audio_len_to_frame_len(int(self.pad_eou_label_secs * self.sample_rate))
+
+        i = 0
+        while i < eou_targets.size(0):
+            if eou_targets[i] == EOU_LABEL or eou_targets[i] == EOB_LABEL:
+                # repeat the label for the next eou_len samples
+                start = i
+                end = min(i + eou_len, eou_targets.size(0))
+                j = start + 1
+                while j < end:
+                    if eou_targets[j] != NON_SPEECH_LABEL:
+                        # do not overwrite the label if it's not non-speech
+                        break
+                    j += 1
+                end = min(j, end)
+                # fill the non-speech label with the current EOU/EOB label
+                eou_targets[start:end] = eou_targets[i]
+                i = end
+            else:
+                i += 1
+        return eou_targets
+
+    def _get_frame_labels(self, cut: Cut, num_samples: int):
+        """
+        Get the frame-level EOU labels for a single audio segment.
+        Args:
+            cut: Cut object
+            num_samples: int, the number of samples in the audio segment
+        Returns:
+            eou_targets: torch.Tensor of EOU labels, shape [T]
+        """
+        hidden_length = self._audio_len_to_frame_len(num_samples)
+        if not "sou_time" in cut.custom or not "eou_time" in cut.custom:
+            # assume only single speech segment
+            text = cut.supervisions[0].text
+            if not text:
+                # skip empty utterances
+                return torch.zeros(hidden_length).long()
+            eou_targets = torch.ones(hidden_length).long()  # speech label
+            eou_targets[-1] = EOU_LABEL  # by default it's end of utterance
+            if cut.has_custom("is_backchannel") and cut.custom["is_backchannel"] and not self.ignore_eob_label:
+                eou_targets[-1] = EOB_LABEL  # end of backchannel
+            return eou_targets
+
+        sou_time = cut.custom["sou_time"]
+        eou_time = cut.custom["eou_time"]
+        if not isinstance(sou_time, list):
+            sou_time = [sou_time]
+        if not isinstance(eou_time, list):
+            eou_time = [eou_time]
+
+        assert len(sou_time) == len(
+            eou_time
+        ), f"Number of SOU time and EOU time do not match: SOU ({sou_time}) vs EOU ({eou_time})"
+
+        if cut.has_custom("is_backchannel"):
+            is_backchannel = cut.custom["is_backchannel"]
+            if not isinstance(is_backchannel, list):
+                is_backchannel = [is_backchannel]
+            assert len(sou_time) == len(
+                is_backchannel
+            ), f"Number of SOU and backchannel do not match: SOU ({len(sou_time)}) vs backchannel ({len(is_backchannel)})"
+        else:
+            is_backchannel = [False] * len(sou_time)
+
+        eou_targets = torch.zeros(hidden_length).long()
+        for i in range(len(sou_time)):
+            if sou_time[i] is None or eou_time[i] is None or sou_time[i] < 0 or eou_time[i] < 0:
+                # skip empty utterances
+                continue
+            sou_idx = self._audio_len_to_frame_len(int((sou_time[i] - cut.start) * self.sample_rate))
+            seg_len_in_secs = eou_time[i] - sou_time[i]
+            seg_len = self._audio_len_to_frame_len(int(seg_len_in_secs * self.sample_rate))
+            eou_targets[sou_idx : sou_idx + seg_len] = SPEECH_LABEL
+            last_idx = min(sou_idx + seg_len - 1, hidden_length - 1)
+            if is_backchannel[i] and not self.ignore_eob_label:
+                eou_targets[last_idx] = EOB_LABEL  # end of backchannel
+            else:
+                eou_targets[last_idx] = EOU_LABEL  # end of utterance
+
+        return eou_targets
+
+    def _get_text_tokens(self, cut: Cut):
+        """
+        Add EOU labels to the text and get the text tokens for a single audio segment.
+        Args:
+            cut: Cut object
+        Returns:
+            text_tokens: torch.Tensor of text tokens, shape [T]
+        """
+        if not cut.has_custom("sou_time") or not cut.has_custom("eou_time") or not cut.has_custom("utterances"):
+            # assume only single speech segment
+            utterances = [cut.supervisions[0].text]
+        else:
+            utterances = cut.custom["utterances"]
+
+        if not isinstance(utterances, list):
+            utterances = [utterances]
+
+        if cut.has_custom("is_backchannel"):
+            is_backchannel = cut.custom["is_backchannel"]
+            if not isinstance(is_backchannel, list):
+                is_backchannel = [is_backchannel]
+            assert len(utterances) == len(
+                is_backchannel
+            ), f"Number of utterances and backchannel do not match: utterance ({len(utterances)}) vs backchannel ({len(is_backchannel)})"
+        else:
+            is_backchannel = [False] * len(utterances)
+
+        total_text = ""
+        for i, text in enumerate(utterances):
+            if not text:
+                # skip empty utterances
+                continue
+            if self.add_eou_to_text:
+                eou_string = self.eob_string if is_backchannel[i] and not self.ignore_eob_label else self.eou_string
+                if self.add_sep_before_eou:
+                    eou_string = " " + eou_string
+            else:
+                eou_string = ""
+            total_text += text + eou_string + " "
+        total_text = total_text.strip()
+        return torch.as_tensor(self.tokenizer(total_text))
+
+    def _random_pad_audio(self, audio: torch.Tensor, audio_len: torch.Tensor, eou_targets: torch.Tensor):
+        """
+        Randomly pad the audio signal with non-speech signal before and after the audio signal.
+        Args:
+            audio: torch.Tensor of a single audio signal, shape [T]
+            audio_len: torch.Tensor of audio signal length, shape [1]
+            eou_targets: torch.Tensor of EOU labels, shape [T]
+        Returns:
+            padded_audio: torch.Tensor of padded audio signal, shape [T+padding]
+            padded_audio_len: torch.Tensor of padded audio signal length, shape [1]
+            padded_eou_targets: torch.Tensor of padded EOU labels, shape [T+padding]
+            padded_eou_targets_len: torch.Tensor of padded EOU label length, shape [1]
+        """
+        p = np.random.rand()
+        if self.padding_cfg is None or p > self.padding_cfg.prob:
+            # don't apply padding
+            eou_targets = self._repeat_eou_labels(eou_targets)
+            return audio, audio_len, eou_targets
+
+        duration = audio_len.item() / self.cfg.sample_rate
+        # if already longer than the maximum duration, return the original audio
+        if duration >= self.padding_cfg.max_total_duration:
+            return audio, audio_len, eou_targets
+
+        # apply padding
+        audio = audio[:audio_len]
+
+        self.padding_cfg.min_pre_pad_duration = max(
+            self.padding_cfg.min_pre_pad_duration, self.padding_cfg.min_pad_duration
+        )
+        self.padding_cfg.min_post_pad_duration = max(
+            self.padding_cfg.min_post_pad_duration, self.padding_cfg.min_pad_duration
+        )
+
+        max_padding_duration = max(0, self.padding_cfg.max_total_duration - duration)
+        if max_padding_duration <= self.padding_cfg.min_pre_pad_duration + self.padding_cfg.min_post_pad_duration:
+            min_padding_duration = 0
+        else:
+            min_padding_duration = self.padding_cfg.min_pre_pad_duration + self.padding_cfg.min_post_pad_duration
+
+        pre_padding_duration = None
+        post_padding_duration = None
+
+        if self.padding_cfg.pad_distribution == 'uniform':
+            total_padding_duration = np.random.uniform(min_padding_duration, max_padding_duration)
+        elif self.padding_cfg.pad_distribution == 'normal':
+            total_padding_duration = np.random.normal(self.padding_cfg.normal_mean, self.padding_cfg.normal_std)
+            total_padding_duration = max(min_padding_duration, min(max_padding_duration, total_padding_duration))
+        elif self.padding_cfg.pad_distribution == 'constant':
+            pass
+        else:
+            raise ValueError(f"Unknown padding distribution: {self.padding_cfg.pad_distribution}")
+
+        if self.padding_cfg.pad_distribution == 'constant':
+            pre_padding_duration = self.padding_cfg.pre_pad_duration
+            post_padding_duration = self.padding_cfg.post_pad_duration
+        elif min_padding_duration == 0:
+            pre_padding_duration = total_padding_duration / 2
+            post_padding_duration = total_padding_duration / 2
+        else:
+            post_padding_duration = np.random.uniform(
+                self.padding_cfg.min_post_pad_duration, total_padding_duration - self.padding_cfg.min_pre_pad_duration
+            )
+            pre_padding_duration = total_padding_duration - post_padding_duration
+
+        if self.padding_cfg.max_pad_duration is not None:
+            pre_padding_duration = min(pre_padding_duration, self.padding_cfg.max_pad_duration)
+            post_padding_duration = min(post_padding_duration, self.padding_cfg.max_pad_duration)
+
+        pre_padding_len = math.ceil(pre_padding_duration * self.cfg.sample_rate)
+        post_padding_len = math.ceil(post_padding_duration * self.cfg.sample_rate)
+
+        # pad the audio signal
+        pre_padding = torch.zeros(pre_padding_len, dtype=audio.dtype)
+        post_padding = torch.zeros(post_padding_len, dtype=audio.dtype)
+        padded_audio = torch.cat((pre_padding, audio, post_padding), dim=0)
+        padded_audio_len = audio_len + pre_padding_len + post_padding_len
+
+        # pad the EOU labels
+        pre_padding_eou_len = self._audio_len_to_frame_len(pre_padding_len)
+        post_padding_eou_len = self._audio_len_to_frame_len(post_padding_len)
+        pre_padding_eou = torch.zeros(pre_padding_eou_len, dtype=eou_targets.dtype)
+        post_padding_eou = torch.zeros(post_padding_eou_len, dtype=eou_targets.dtype)
+        padded_eou_targets = torch.cat((pre_padding_eou, eou_targets, post_padding_eou), dim=0)
+        padded_eou_targets = self._repeat_eou_labels(padded_eou_targets)
+        return padded_audio, padded_audio_len, padded_eou_targets
+
+    def _maybe_augment_audio(self, audio: torch.Tensor, audio_len: torch.Tensor):
+        """
+        Apply augmentation to the audio signal if augmentor is provided.
+        Args:
+            audio: torch.Tensor of a single audio signal, shape [T]
+            audio_len: torch.Tensor of audio signal length, shape [1]
+        Returns:
+            augmented_audio: torch.Tensor of augmented audio signal, shape [T]
+            augmented_audio_len: torch.Tensor of augmented audio signal length, shape [1]
+        """
+        if self.augmentor is None:
+            return audio, audio_len
+
+        # Cast to AudioSegment
+        audio_segment = AudioSegment(
+            samples=audio[:audio_len].numpy(),
+            sample_rate=self.sample_rate,
+            offset=0,
+            duration=audio_len.item() / self.sample_rate,
+        )
+        # Apply augmentation
+        self.augmentor.perturb(audio_segment)
+        audio = torch.from_numpy(audio_segment.samples).float()
+        audio_len = audio.size(0)
+
+        return audio, audio_len

nemo/collections/asr/data/audio_to_label.py

@@ -16,7 +16,6 @@ import os
 from typing import Dict, List, Optional, Union
 
 import torch
-import webdataset as wds
 
 from nemo.collections.asr.data.audio_to_text import cache_datastore_manifests, expand_sharded_filepaths
 from nemo.collections.asr.parts.preprocessing.features import WaveformFeaturizer
@@ -25,6 +24,7 @@ from nemo.collections.common.parts.preprocessing import collections
 from nemo.core.classes import Dataset, IterableDataset
 from nemo.core.neural_types import AudioSignal, LabelsType, LengthsType, NeuralType, RegressionValuesType
 from nemo.utils import logging
+from nemo.utils import webdataset as wds
 from nemo.utils.distributed import webdataset_split_by_workers
 
 # List of valid file formats (prioritized by order of importance)
@@ -587,6 +587,7 @@ class _TarredAudioLabelDataset(IterableDataset):
             world_size=world_size,
             global_rank=global_rank,
         )
+
         # Put together WebDataset
         self._dataset = wds.DataPipeline(
             wds.SimpleShardList(urls=audio_tar_filepaths),
@@ -1193,6 +1194,7 @@ class TarredAudioToMultiLabelDataset(IterableDataset):
             world_size=world_size,
             global_rank=global_rank,
         )
+
         # Put together WebDataset
         self._dataset = wds.DataPipeline(
             wds.SimpleShardList(urls=audio_tar_filepaths),

nemo/collections/asr/data/audio_to_text.py

@@ -22,7 +22,6 @@ from typing import Callable, Dict, Iterable, List, Optional, Tuple, Union
 import braceexpand
 import numpy as np
 import torch
-import webdataset as wds
 from torch.utils.data import ChainDataset
 from tqdm import tqdm
 
@@ -34,14 +33,8 @@ from nemo.collections.common.parts.preprocessing import collections, parsers
 from nemo.core.classes import Dataset, IterableDataset
 from nemo.core.neural_types import *
 from nemo.utils import logging
-from nemo.utils.data_utils import (
-    DataStoreObject,
-    datastore_object_get,
-    datastore_path_to_webdataset_url,
-    is_datastore_cache_shared,
-    is_datastore_path,
-    is_tarred_path,
-)
+from nemo.utils import webdataset as wds
+from nemo.utils.data_utils import DataStoreObject, datastore_object_get, is_datastore_cache_shared, is_datastore_path
 from nemo.utils.decorators import deprecated
 from nemo.utils.distributed import webdataset_split_by_workers
 from nemo.utils.get_rank import is_global_rank_zero
@@ -209,12 +202,6 @@ def expand_sharded_filepaths(sharded_filepaths, shard_strategy: str, world_size:
         # Brace expand, set escape=False for Windows compatibility
         sharded_filepaths = list(braceexpand.braceexpand(sharded_filepaths, escape=False))
 
-    # Expand store paths into WebDataset URLs
-    sharded_filepaths = [
-        datastore_path_to_webdataset_url(p) if is_datastore_path(p) and is_tarred_path(p) else p
-        for p in sharded_filepaths
-    ]
-
     # Check for distributed and partition shards accordingly
     if world_size > 1:
         if shard_strategy == 'scatter':
@@ -949,9 +936,7 @@ class _TarredAudioToTextDataset(IterableDataset):
                     self.current_bytes, self.current_fn = next(self.iterator)
                     self.offset_id = 0
                 else:
-                    import os
-                    file_id, _ = os.path.splitext(os.path.basename(self.current_fn))
-                    offset_list = self.collection.mapping[file_id]
+                    offset_list = self.collection.mapping[self.current_fn]
                     if len(offset_list) == self.offset_id + 1:
                         self.current_bytes, self.current_fn = next(self.iterator)
                         self.offset_id = 0

nemo/collections/asr/data/audio_to_text_dali.py

@@ -300,9 +300,7 @@ class _AudioTextDALIDataset(Iterator):
                     f"'clamp'."
                 )
 
-            self.log_zero_guard_value = (
-                params['log_zero_guard_value'] if 'log_zero_guard_value' in params else 2 ** -24
-            )
+            self.log_zero_guard_value = params['log_zero_guard_value'] if 'log_zero_guard_value' in params else 2**-24
             if isinstance(self.log_zero_guard_value, str):
                 if self.log_zero_guard_value == "tiny":
                     self.log_zero_guard_value = torch.finfo(torch.float32).tiny
@@ -346,8 +344,12 @@ class _AudioTextDALIDataset(Iterator):
 
             elif audio_tar_filepaths is not None and audio_tar_index_filepaths is not None:
                 audio_tar_filepaths = expand_sharded_filepaths(
-                    audio_tar_filepaths, shard_strategy=shard_strategy, world_size=world_size, global_rank=global_rank
+                    audio_tar_filepaths,
+                    shard_strategy=shard_strategy,
+                    world_size=world_size,
+                    global_rank=global_rank,
                 )
+
                 audio_tar_index_filepaths = expand_sharded_filepaths(
                     audio_tar_index_filepaths,
                     shard_strategy=shard_strategy,
@@ -374,7 +376,10 @@ class _AudioTextDALIDataset(Iterator):
                     pad_last_batch=True,
                 )
                 audio, _ = dali.fn.decoders.audio(
-                    tar_file, dtype=dali.types.FLOAT, downmix=True, sample_rate=float(self.sample_rate),
+                    tar_file,
+                    dtype=dali.types.FLOAT,
+                    downmix=True,
+                    sample_rate=float(self.sample_rate),
                 )
                 indices = dali.fn.get_property(tar_file, key="source_info")
                 indices = dali.fn.pad(indices)
@@ -446,7 +451,7 @@ class _AudioTextDALIDataset(Iterator):
                 )
 
                 # Normalization
-                spec = dali.fn.normalize(spec, axes=self.normalization_axes, epsilon=1e-5 ** 2, ddof=1)
+                spec = dali.fn.normalize(spec, axes=self.normalization_axes, epsilon=1e-5**2, ddof=1)
 
                 # Extracting the length of the spectrogram
                 spec_len = dali.fn.slice(dali.fn.shapes(spec), 1, 1, axes=(0,))

nemo/collections/asr/data/audio_to_text_dataset.py

@@ -18,7 +18,9 @@ import random
 from math import isclose
 from typing import Any, List, Optional, Union
 
+import numpy as np
 import torch
+from lightning.pytorch import LightningModule
 from lightning.pytorch.callbacks import BasePredictionWriter
 from omegaconf import DictConfig, OmegaConf, open_dict
 from omegaconf.listconfig import ListConfig
@@ -29,8 +31,9 @@ from nemo.collections.asr.data.huggingface.hf_audio_to_text_dataset import (
     get_hf_audio_to_text_bpe_dataset,
     get_hf_audio_to_text_char_dataset,
 )
-from nemo.collections.asr.parts.preprocessing.perturb import process_augmentations
+from nemo.collections.asr.parts.preprocessing.perturb import AudioAugmentor, process_augmentations
 from nemo.collections.common.data.dataset import CodeSwitchedDataset, ConcatDataset
+from nemo.collections.common.tokenizers import TokenizerSpec
 from nemo.utils import logging
 
 
@@ -94,7 +97,7 @@ def get_concat_char_dataset(
         An instance of ConcatDataset containing one or more instances of AudioToCharDataset.
     """
     if 'labels' not in config:
-        logging.warning(f"dataset does not have explicitly defined labels")
+        logging.warning("dataset does not have explicitly defined labels")
 
     manifest_filepaths = config['manifest_filepath']
     datasets = []
@@ -138,7 +141,7 @@ def get_char_dataset(config: dict, augmentor: Optional['AudioAugmentor'] = None)
         An instance of AudioToCharDataset.
     """
     if 'labels' not in config:
-        logging.warning(f"dataset does not have explicitly defined labels")
+        logging.warning("dataset does not have explicitly defined labels")
 
     dataset = audio_to_text.AudioToCharDataset(
         manifest_filepath=config['manifest_filepath'],
@@ -332,7 +335,7 @@ def get_tarred_dataset(
     if bucketing_weights:
         for idx, weight in enumerate(bucketing_weights):
             if not isinstance(weight, int) or weight <= 0:
-                raise ValueError(f"bucket weights must be positive integers")
+                raise ValueError("bucket weights must be positive integers")
 
     if len(manifest_filepaths) != len(tarred_audio_filepaths):
         raise ValueError(
@@ -340,10 +343,10 @@ def get_tarred_dataset(
         )
 
     if 'labels' not in config:
-        logging.warning(f"dataset does not have explicitly defined labels")
+        logging.warning("dataset does not have explicitly defined labels")
 
     if 'max_utts' in config:
-        raise ValueError('"max_utts" parameter is not supported for tarred datasets')
+        logging.warning('"max_utts" parameter is not supported for tarred datasets')
 
     for dataset_idx, (tarred_audio_filepath, manifest_filepath) in enumerate(
         zip(tarred_audio_filepaths, manifest_filepaths)
@@ -861,7 +864,7 @@ class ASRPredictionWriter(BasePredictionWriter):
     ):
         import lhotse
 
-        for sample_id, transcribed_text in prediction:
+        for sample_id, hypotheses in prediction:
             item = {}
             if isinstance(sample_id, lhotse.cut.Cut):
                 sample = sample_id
@@ -876,18 +879,29 @@ class ASRPredictionWriter(BasePredictionWriter):
                 item["text"] = sample.supervisions[0].text or ''
                 if hasattr(sample, 'shard_id'):
                     item["shard_id"] = sample.shard_id
-                item["pred_text"] = transcribed_text
-                self.outf.write(json.dumps(item) + "\n")
-                self.samples_num += 1
+                item["pred_text"] = hypotheses.text
+
             else:
                 sample = self.dataset.get_manifest_sample(sample_id)
                 item["audio_filepath"] = sample.audio_file
                 item["offset"] = sample.offset
                 item["duration"] = sample.duration
                 item["text"] = sample.text_raw
-                item["pred_text"] = transcribed_text
-                self.outf.write(json.dumps(item) + "\n")
-                self.samples_num += 1
+                item["pred_text"] = hypotheses.text
+
+            if hasattr(hypotheses, "timestamp") and isinstance(hypotheses.timestamp, dict):
+                for timestamp_type, timestamps in hypotheses.timestamp.items():
+                    if timestamp_type in ['char', 'word', 'segment']:
+                        item[f'{timestamp_type}_timestamps'] = [
+                            {
+                                key: int(value) if isinstance(value, np.int64) else value
+                                for key, value in offset.items()
+                            }
+                            for offset in timestamps
+                        ]
+
+            self.outf.write(json.dumps(item) + "\n")
+            self.samples_num += 1
         return
 
     def close_output_file(self):

nemo/collections/asr/data/audio_to_text_lhotse.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2024, NVIDIA CORPORATION.  All rights reserved.
+# Copyright (c) 2025, NVIDIA CORPORATION.  All rights reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import os
 from typing import Dict, Optional, Tuple
 
 import torch.utils.data
@@ -31,6 +32,11 @@ class LhotseSpeechToTextBpeDataset(torch.utils.data.Dataset):
     Specifically, it performs tokenization, I/O, augmentation, and feature extraction (if any).
     Managing data, sampling, de-duplication across workers/nodes etc. is all handled
     by Lhotse samplers instead.
+
+    NOTE:
+    If the environment variable ``USE_AIS_GET_BATCH`` is set to ``true`` (case-insensitive),
+    then batch audio loading from AIStore will be enabled for this dataset. This will use the
+    AISBatchLoader to load the audio from AIStore. This can improve data loading efficiency in some setups.
     """
 
     @property
@@ -46,7 +52,22 @@ class LhotseSpeechToTextBpeDataset(torch.utils.data.Dataset):
     def __init__(self, tokenizer: TokenizerSpec, return_cuts: bool = False):
         super().__init__()
         self.tokenizer = TokenizerWrapper(tokenizer)
-        self.load_audio = AudioSamples(fault_tolerant=True)
+        self.use_ais_get_batch = os.environ.get("USE_AIS_GET_BATCH", "False").lower() == "true"
+
+        # Try to use use_batch_loader if available (Lhotse >= 1.32.0)
+        try:
+            self.load_audio = AudioSamples(fault_tolerant=True, use_batch_loader=self.use_ais_get_batch)
+        except TypeError:
+            # Lhotse < 1.32.0 doesn't support use_batch_loader
+            if self.use_ais_get_batch:
+                import logging
+
+                logging.warning(
+                    "AIS batch loading requested but not supported by this Lhotse version. "
+                    "Please upgrade to Lhotse >= 1.32.0"
+                )
+            self.load_audio = AudioSamples(fault_tolerant=True)
+
         self.return_cuts = return_cuts
 
     def __getitem__(self, cuts) -> Tuple[torch.Tensor, ...]:

nemo/collections/asr/data/audio_to_text_lhotse_prompt.py

@@ -0,0 +1,177 @@
+# Copyright (c) 2025, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import math
+from typing import Dict, Optional, Tuple
+
+import numpy as np
+import torch
+import torch.utils.data
+from lhotse.dataset import AudioSamples
+from lhotse.dataset.collation import collate_matrices, collate_vectors
+
+from nemo.collections.common.tokenizers.aggregate_tokenizer import AggregateTokenizer
+from nemo.collections.common.tokenizers.tokenizer_spec import TokenizerSpec
+from nemo.core.neural_types import AudioSignal, LabelsType, LengthsType, NeuralType
+
+
+class LhotseSpeechToTextBpeDatasetWithPrompt(torch.utils.data.Dataset):
+    """
+    Dataset class for speech-to-text with prompt vectors.
+    Supports both language ID and custom prompts.
+    """
+
+    @property
+    def output_types(self) -> Optional[Dict[str, NeuralType]]:
+        return {
+            'audio_signal': NeuralType(('B', 'T'), AudioSignal()),
+            'audio_signal_length': NeuralType(tuple('B'), LengthsType()),
+            'transcripts': NeuralType(('B', 'T'), LabelsType()),
+            'transcript_length': NeuralType(tuple('B'), LengthsType()),
+            'prompt': NeuralType(('B', 'T', 'D'), LabelsType()),
+        }
+
+    def __init__(self, tokenizer, cfg):
+        super().__init__()
+        self.tokenizer = TokenizerWrapper(tokenizer)
+        self.load_audio = AudioSamples(fault_tolerant=True)
+        self.cfg = cfg
+
+        # Calculate num_sample_per_mel_frame from config
+        sample_rate = cfg.get('sample_rate', 16000)
+        window_stride = cfg.get('window_stride', 0.01)
+        self.num_sample_per_mel_frame = int(sample_rate * window_stride)
+
+        self.subsampling_factor = cfg.get('subsampling_factor', 8)
+
+        # Load prompt dictionary from config if provided
+        self.prompt_dict = cfg.get('prompt_dictionary')
+        if self.prompt_dict:
+            # Set num_prompts based on the length of prompt_dictionary or a minimum value
+            # This ensures we have enough dimensions in our embedding space to add scale up without changing the model
+            self.num_prompts = cfg.get('num_prompts', 128)
+
+        # Field to use for prompt key (default to 'language')
+        self.prompt_field = cfg.get('prompt_field', 'language')
+
+    def _get_prompt_index(self, prompt_key: str) -> int:
+        """
+        Maps prompt keys to indices using the prompt dictionary.
+        """
+        if not self.prompt_dict:
+            raise ValueError("Prompt dictionary is empty. Please provide a valid prompt_dictionary in the config.")
+
+        if prompt_key not in self.prompt_dict:
+            available_keys = list(self.prompt_dict.keys())
+            raise ValueError(
+                f"Unknown prompt key: '{prompt_key}'. Available prompts: {available_keys[:10]}{'...' if len(available_keys) > 10 else ''}"
+            )
+
+        return self.prompt_dict[prompt_key]
+
+    def prompt_to_target(self, cut, num_prompts: int, window_stride: int, subsampling_factor: int):
+        """
+        Create prompt target tensor for the sequence.
+        """
+        # Calculate encoder output length based on subsampling factor
+        encoder_hidden_len = self.get_hidden_length_from_sample_length(cut.num_samples)
+
+        # Initialize prompt target matrix
+        mask = np.zeros((num_prompts, encoder_hidden_len))
+
+        # Get prompt index - default to language if prompt not specified
+        # revise supervisions to include prompt key
+        # prompt_key = getattr(cut.supervisions[0].custom_fields, cut.supervisions[0].language)cut.supervisions[0].custom_fields,
+        prompt_id = self._get_prompt_index(cut.supervisions[0].language)
+
+        # Set the corresponding prompt ID to 1 for all time steps
+        mask[prompt_id, :] = 1
+
+        return mask
+
+    def get_hidden_length_from_sample_length(self, num_samples: int) -> int:
+        """
+        Calculate the hidden length from the given number of samples.
+
+        Parameters:
+            num_samples (int): The total number of audio samples.
+
+        Returns:
+            hidden_length (int): The calculated hidden length in terms of the number of frames.
+        """
+        mel_frame_count = math.ceil((num_samples + 1) / self.num_sample_per_mel_frame)
+        hidden_length = math.ceil(mel_frame_count / self.subsampling_factor)
+        return int(hidden_length)
+
+    def __getitem__(self, cuts) -> Tuple[torch.Tensor, ...]:
+        audio, audio_lens, cuts = self.load_audio(cuts)
+        tokens = [torch.as_tensor(self.tokenizer(c.supervisions[0].text, c.supervisions[0].language)) for c in cuts]
+
+        # Create prompt targets
+        prompt_targets = [
+            torch.transpose(
+                torch.as_tensor(
+                    self.prompt_to_target(
+                        c,
+                        self.num_prompts,
+                        self.num_sample_per_mel_frame,
+                        self.subsampling_factor,
+                    ),
+                    dtype=torch.float32,
+                ),
+                0,
+                1,
+            )
+            for c in cuts
+        ]
+
+        # Create final tensors
+        token_lens = torch.tensor([t.size(0) for t in tokens], dtype=torch.long)
+        tokens = collate_vectors(tokens, padding_value=0)
+        prompt_targets = collate_matrices(prompt_targets)
+
+        return (
+            audio,  # Audio signal
+            audio_lens,  # Audio lengths
+            tokens,  # Text tokens
+            token_lens,  # Token lengths
+            prompt_targets,  # Prompt targets
+        )
+
+
+class TokenizerWrapper:
+    """
+    Provide a unified interface for NeMo Tokenizer, AggregateTokenizer, and (char) Parser.
+    """
+
+    def __init__(self, tokenizer):
+        self._tokenizer = tokenizer
+        if isinstance(tokenizer, AggregateTokenizer):
+            self._impl = self._call_agg_tokenizer
+        elif isinstance(tokenizer, TokenizerSpec):
+            self._impl = self._call_tokenizer
+        else:
+            self._impl = self._call_parser
+
+    def __call__(self, text: str, lang: Optional[str] = None):
+        return self._impl(text, lang)
+
+    def _call_agg_tokenizer(self, text: str, lang: Optional[str] = None):
+        assert lang is not None, "Expected 'lang' to be set for AggregateTokenizer."
+        return self._tokenizer.text_to_ids(text, lang)
+
+    def _call_tokenizer(self, text: str, lang: Optional[str] = None):
+        return self._tokenizer.text_to_ids(text)
+
+    def _call_parser(self, text: str, lang: Optional[str] = None):
+        return self._tokenizer(text)

nemo/collections/asr/data/audio_to_text_lhotse_prompted.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2024, NVIDIA CORPORATION.  All rights reserved.
+# Copyright (c) 2025, NVIDIA CORPORATION.  All rights reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -11,8 +11,9 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+import os
 from dataclasses import dataclass
-from typing import Callable, Optional, Union
+from typing import Optional, Union
 
 import torch.utils.data
 from lhotse import CutSet
@@ -21,7 +22,7 @@ from lhotse.dataset import AudioSamples
 from lhotse.dataset.collation import collate_vectors
 
 from nemo.collections.common.data import apply_prompt_format_fn
-from nemo.collections.common.prompts import CanaryPromptFormatter, PromptFormatter
+from nemo.collections.common.prompts import PromptFormatter
 from nemo.collections.common.tokenizers import TokenizerSpec
 
 
@@ -61,23 +62,68 @@ class PromptedAudioToTextLhotseDataset(torch.utils.data.Dataset):
     Tokenized utterances will be extended with special prompt tokens according to ``prompt_format_fn`` logic.
     We support cuts with multiple supervision segments -- their tokenized texts will be concatenated before we add the prompt tokens.
     This is useful, for example, in code-switched scenarios where each segment is spoken in a different language.
+
+    Chunking:
+    If `enable_chunking` is True, each audio sample is split into optimally sized chunks
+    (see `find_optimal_chunk_size` and `chunk_waveform`). This is useful for long audio inputs,
+    allowing the model to process them in manageable segments.
+
+    NOTE:
+    If the environment variable `USE_AIS_GET_BATCH` is set to `true` (case-insensitive),
+    then batch audio loading from AIStore will be enabled for this dataset. This will use the
+    AISBatchLoader to load the audio from AIStore. This can improve data loading efficiency in some setups.
     """
 
     def __init__(
         self,
         tokenizer: TokenizerSpec,
         prompt: PromptFormatter,
+        enable_chunking: bool = False,
     ):
         super().__init__()
         self.tokenizer = tokenizer
-        self.load_audio = AudioSamples(fault_tolerant=True)
+        self.use_ais_get_batch = os.environ.get("USE_AIS_GET_BATCH", "False").lower() == "true"
+
+        # Try to use use_batch_loader if available (Lhotse >= 1.32.0)
+        try:
+            self.load_audio = AudioSamples(fault_tolerant=True, use_batch_loader=self.use_ais_get_batch)
+        except TypeError:
+            # Lhotse < 1.32.0 doesn't support use_batch_loader
+            if self.use_ais_get_batch:
+                import logging
+
+                logging.warning(
+                    "AIS batch loading requested but not supported by this Lhotse version. "
+                    "Please upgrade to Lhotse >= 1.32.0"
+                )
+            self.load_audio = AudioSamples(fault_tolerant=True)
+
         self.padding_value = self.tokenizer.pad_id
         self.prompt = prompt
+        self.enable_chunking = enable_chunking
 
     def __getitem__(self, cuts: CutSet) -> PromptedAudioToTextMiniBatch:
+        # Load the audio's from AIS and add them to the CutSet
         audio, audio_lens, cuts = self.load_audio(cuts)
 
-        # Fast-path: the tokenization and prompt formatting was already done before sampling.
+        # Will work if batch_size is set to 1.
+        if self.enable_chunking:
+            # If dynamic chunking is enabled, split each audio sample into chunks.
+            new_audio = []
+            new_audio_lens = []
+            for i in range(audio.shape[0]):
+                waveform = audio[i, : audio_lens[i]]
+                # Split the waveform into chunks and get their lengths.
+                chunks, chunk_lens = self._chunk_waveform(waveform)
+                new_audio.extend(chunks)
+                new_audio_lens.extend(chunk_lens)
+            # Stack all chunks into a batch.
+            audio = torch.stack(new_audio)
+            audio_lens = torch.tensor(new_audio_lens, dtype=torch.long)
+            # Adding this to allow gathering results of the same audio from different batches
+            if cuts[0].start != 0:
+                cuts[0].id = cuts[0].id + '_cut_segmented'
+        # Fast-path: the tokenization and prompt format ting was already done before sampling.
         attrs = ("input_ids", "context_ids", "answer_ids")
         pre_formatted = all(hasattr(c, a) for c in cuts for a in attrs)
         if pre_formatted:
@@ -110,6 +156,93 @@ class PromptedAudioToTextLhotseDataset(torch.utils.data.Dataset):
         tokens = collate_vectors(tokens, padding_value=self.padding_value)
         return tokens, token_lens
 
+    def _find_optimal_chunk_size(
+        self, total_len: int, min_sec: int = 30, max_sec: int = 40, sample_rate: int = 16000, overlap_sec: float = 1.0
+    ) -> int:
+        """
+        Find the optimal chunk size for audio processing that minimizes paddings to the last chunk.
+
+        Args:
+            total_len (int): Total length of the audio waveform in samples
+            min_sec (int, optional): Minimum chunk size in seconds. Defaults to 30.
+            max_sec (int, optional): Maximum chunk size in seconds. Defaults to 40.
+            sample_rate (int, optional): Audio sample rate in Hz. Defaults to 16000.
+            overlap_sec (float, optional): Overlap duration between consecutive chunks in seconds.
+                                         Defaults to 1.0.
+
+        Returns:
+            int: Optimal chunk size in samples that maximizes the last chunk length
+        """
+        best_chunk_size = min_sec * sample_rate
+        best_last_chunk_len = 0
+        if total_len < max_sec * sample_rate:
+            return total_len
+        # Try each possible chunk duration in the range
+        for sec in range(min_sec, max_sec + 1):
+            chunk_size = sec * sample_rate
+            overlap_size = int(overlap_sec * sample_rate)
+            step_size = chunk_size - overlap_size
+
+            if step_size <= 0:  # Invalid overlap
+                continue
+            if chunk_size > total_len:
+                continue
+
+            # Calculate how many chunks we'd need and the last chunk's length
+            n_chunks = (total_len + step_size - 1) // step_size
+            last_chunk_len = total_len - step_size * (n_chunks - 1)
+
+            if last_chunk_len > best_last_chunk_len:
+                best_last_chunk_len = last_chunk_len
+                best_chunk_size = chunk_size
+
+        return best_chunk_size
+
+    def _chunk_waveform(
+        self, waveform: torch.Tensor, chunk_size: int = None, overlap_sec: float = 1.0, sample_rate: int = 16000
+    ) -> tuple[list[torch.Tensor], list[int]]:
+        """
+        Split a waveform tensor into overlapping chunks.
+
+        Args:
+            waveform (torch.Tensor): Input audio waveform tensor of shape (time_samples,)
+            chunk_size (int, optional): Size of each chunk in samples. If None, automatically
+                                       determines optimal chunk size using find_optimal_chunk_size().
+                                       Defaults to None.
+            sample_rate (int, optional): Audio sample rate in Hz. Defaults to 16000.
+            overlap_sec (float, optional): Overlap duration between consecutive chunks in seconds.
+                                          Used to calculate step size. Defaults to 2.
+
+        Returns:
+            tuple[list[torch.Tensor], list[int]]: A tuple containing:
+                - List of chunk tensors, each of shape (chunk_size,)
+                - List of original lengths for each chunk before padding (useful for masking
+                  padded regions during processing.
+        """
+        # If chunk_size is None, find the optimal chunk size for this waveform
+        total_len = waveform.shape[0]
+        if chunk_size is None:
+            chunk_size = self._find_optimal_chunk_size(total_len, overlap_sec=overlap_sec)
+        if chunk_size >= total_len:
+            return [waveform], [total_len]
+        overlap_size = int(overlap_sec * sample_rate)
+        step_size = chunk_size - overlap_size
+        chunks = []
+        chunk_lens = []
+        start = 0
+        while start + overlap_size < total_len:
+            end = min(start + chunk_size, total_len)
+            chunk = waveform[start:end]
+            length = chunk.shape[0]
+            if length < chunk_size:
+                pad = torch.zeros(chunk_size - length, dtype=chunk.dtype, device=chunk.device)
+                chunk = torch.cat([chunk, pad], dim=0)
+            chunks.append(chunk)
+            chunk_lens.append(length)
+            start += step_size
+
+        return chunks, chunk_lens
+
 
 class ProbablyIncorrectLanguageKeyError(RuntimeError):
     pass

nemo/collections/asr/data/audio_to_text_lhotse_speaker.py

@@ -0,0 +1,97 @@
+# Copyright (c) 2024, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import random
+from typing import Dict, Optional, Tuple
+
+import torch.utils.data
+from lhotse.dataset import AudioSamples
+from lhotse.dataset.collation import collate_vectors
+
+from nemo.collections.asr.data.audio_to_text_lhotse import TokenizerWrapper
+from nemo.collections.asr.parts.utils.asr_multispeaker_utils import speaker_to_target
+from nemo.collections.common.tokenizers.tokenizer_spec import TokenizerSpec
+from nemo.core.neural_types import AudioSignal, LabelsType, LengthsType, NeuralType
+
+
+class LhotseSpeechToTextSpkBpeDataset(torch.utils.data.Dataset):
+    """
+    This dataset is based on BPE datasets from audio_to_text.py. It has the same functionality of LhotseSpeechToTextBpeDataset but also yield speaker target tensor.
+    Unlike native NeMo datasets, Lhotse dataset defines only the mapping from
+    a CutSet (meta-data) to a mini-batch with PyTorch tensors.
+    Specifically, it performs tokenization, I/O, augmentation, and feature extraction (if any).
+    Managing data, sampling, de-duplication across workers/nodes etc. is all handled
+    by Lhotse samplers instead.
+    """
+
+    @property
+    def output_types(self) -> Optional[Dict[str, NeuralType]]:
+        return {
+            'audio_signal': NeuralType(('B', 'T'), AudioSignal()),
+            'a_sig_length': NeuralType(tuple('B'), LengthsType()),
+            'transcripts': NeuralType(('B', 'T'), LabelsType()),
+            'transcript_length': NeuralType(tuple('B'), LengthsType()),
+            'spk_targets': NeuralType(('B', 'T'), LabelsType()),
+            'bg_spk_targets': NeuralType(('B', 'T'), LabelsType()),
+        }
+
+    def __init__(self, cfg, tokenizer: TokenizerSpec):
+        super().__init__()
+        self.tokenizer = TokenizerWrapper(tokenizer)
+        self.load_audio = AudioSamples(fault_tolerant=True)
+        self.cfg = cfg
+        self.num_speakers = self.cfg.get('num_speakers', 4)
+        self.num_sample_per_mel_frame = self.cfg.get('num_sample_per_mel_frame', 160)
+        self.num_mel_frame_per_asr_frame = self.cfg.get('num_mel_frame_per_asr_frame', 8)
+        self.fixed_spk_id = self.cfg.get('fixed_spk_id', None)
+        self.inference_mode = self.cfg.get('inference_mode', False)
+
+    def __getitem__(self, cuts) -> Tuple[torch.Tensor, ...]:
+
+        audio, audio_lens, cuts = self.load_audio(cuts)
+
+        tokens = []
+        spk_targets = []
+        bg_spk_targets = []
+
+        if self.inference_mode:
+            return audio, audio_lens, None, None, None, None
+
+        for idx, cut in enumerate(cuts):
+
+            speaker_targets, texts = speaker_to_target(
+                a_cut=cut,
+                num_speakers=self.num_speakers,
+                num_sample_per_mel_frame=self.num_sample_per_mel_frame,
+                num_mel_frame_per_asr_frame=self.num_mel_frame_per_asr_frame,
+                return_text=True,
+            )
+            speaker_targets = speaker_targets.transpose(0, 1)[: len(texts)]
+
+            target_speaker_id = random.choice(range(len(texts)))
+            non_target_speaker_ids = [i for i in range(len(texts)) if i != target_speaker_id]
+            text = texts[target_speaker_id]
+            speaker_target = speaker_targets[target_speaker_id]
+            bg_speaker_target = speaker_targets[non_target_speaker_ids].sum(dim=0) > 0
+
+            tokens.append(torch.as_tensor(self.tokenizer(text, cut.supervisions[0].language)))
+            spk_targets.append(speaker_target)
+            bg_spk_targets.append(bg_speaker_target)
+
+        token_lens = torch.tensor([t.size(0) for t in tokens], dtype=torch.long)
+        tokens = collate_vectors(tokens, padding_value=0)
+        spk_targets = collate_vectors(spk_targets, padding_value=0)
+        bg_spk_targets = collate_vectors(bg_spk_targets, padding_value=0)
+
+        return audio, audio_lens, tokens, token_lens, spk_targets, bg_spk_targets

nemo/collections/asr/data/data_simulation.py

@@ -67,122 +67,86 @@ class MultiSpeakerSimulator(object):
     Multispeaker Audio Session Simulator - Simulates multispeaker audio sessions using single-speaker audio files and
     corresponding word alignments.
 
-    Change Log:
-    v1.0: Dec 2022
-        - First working verison, supports multispeaker simulation with overlaps, silence and RIR
-        v1.0.1: Feb 2023
-            - Multi-GPU support for speed up
-            - Faster random sampling routine
-            - Fixed sentence duration bug
-            - Silence and overlap length sampling algorithms are updated to guarantee `mean_silence` approximation
-        v1.0.2: March 2023
-            - Added support for segment-level gain perturbation and session-level white-noise perturbation
-            - Modified speaker sampling mechanism to include as many speakers as possible in each data-generation run
-            - Added chunking mechanism to avoid freezing in multiprocessing processes
-
-    v1.1.0 March 2023
-        - Faster audio-file loading with maximum audio duration parameter
-        - Re-organized MultiSpeakerSimulator class and moved util functions to util files.
-        v1.1.1 March 2023
-            - Changed `silence_mean` to use exactly the same sampling equation as `overlap_mean`.
-
-
     Args:
         cfg: OmegaConf configuration loaded from yaml file.
 
-    Parameters:
-      manifest_filepath (str): Manifest file with paths to single speaker audio files
-      sr (int): Sampling rate of the input audio files from the manifest
-      random_seed (int): Seed to random number generator
-
-    session_config:
-      num_speakers (int): Number of unique speakers per multispeaker audio session
-      num_sessions (int): Number of sessions to simulate
-      session_length (int): Length of each simulated multispeaker audio session (seconds). Short sessions
-                            (e.g. ~240 seconds) tend to fall short of the expected overlap-ratio and silence-ratio.
-
-    session_params:
-      max_audio_read_sec (int): The maximum audio length in second when loading an audio file.
-                                The bigger the number, the slower the reading speed. Should be greater than 2.5 second.
-      sentence_length_params (list): k,p values for a negative_binomial distribution which is sampled to get the
-                                     sentence length (in number of words)
-      dominance_var (float): Variance in speaker dominance (where each speaker's dominance is sampled from a normal
-                             distribution centered on 1/`num_speakers`, and then the dominance values are together
-                             normalized to 1)
-      min_dominance (float): Minimum percentage of speaking time per speaker (note that this can cause the dominance of
-                             the other speakers to be slightly reduced)
-      turn_prob (float): Probability of switching speakers after each utterance
-
-      mean_silence (float): Mean proportion of silence to speaking time in the audio session. Should be in range [0, 1).
-      mean_silence_var (float): Variance for mean silence in all audio sessions.
-                                This value should be 0 <= mean_silence_var < mean_silence * (1 - mean_silence).
-      per_silence_var (float):  Variance for each silence in an audio session, set large values (e.g., 20) for de-correlation.
-      per_silence_min (float): Minimum duration for each silence, default to 0.
-      per_silence_max (float): Maximum duration for each silence, default to -1 for no maximum.
-      mean_overlap (float): Mean proportion of overlap in the overall non-silence duration. Should be in range [0, 1) and
-                            recommend [0, 0.15] range for accurate results.
-      mean_overlap_var (float): Variance for mean overlap in all audio sessions.
-                                This value should be 0 <= mean_overlap_var < mean_overlap * (1 - mean_overlap).
-      per_overlap_var (float): Variance for per overlap in each session, set large values to de-correlate silence lengths
-                               with the latest speech segment lengths
-      per_overlap_min (float): Minimum per overlap duration in seconds
-      per_overlap_max (float): Maximum per overlap duration in seconds, set -1 for no maximum
-      start_window (bool): Whether to window the start of sentences to smooth the audio signal (and remove silence at
-                            the start of the clip)
-      window_type (str): Type of windowing used when segmenting utterances ("hamming", "hann", "cosine")
-      window_size (float): Length of window at the start or the end of segmented utterance (seconds)
-      start_buffer (float): Buffer of silence before the start of the sentence (to avoid cutting off speech or starting
-                            abruptly)
-      split_buffer (float): Split RTTM labels if greater than twice this amount of silence (to avoid long gaps between
-                            utterances as being labelled as speech)
-      release_buffer (float): Buffer before window at end of sentence (to avoid cutting off speech or ending abruptly)
-      normalize (bool): Normalize speaker volumes
-      normalization_type (str): Normalizing speakers ("equal" - same volume per speaker, "var" - variable volume per
-                                speaker)
-      normalization_var (str): Variance in speaker volume (sample from standard deviation centered at 1)
-      min_volume (float): Minimum speaker volume (only used when variable normalization is used)
-      max_volume (float): Maximum speaker volume (only used when variable normalization is used)
-      end_buffer (float): Buffer at the end of the session to leave blank
-
-    outputs:
-      output_dir (str): Output directory for audio sessions and corresponding label files
-      output_filename (str): Output filename for the wav and RTTM files
-      overwrite_output (bool): If true, delete the output directory if it exists
-      output_precision (int): Number of decimal places in output files
-
-    background_noise:
-      add_bg (bool): Add ambient background noise if true
-      background_manifest (str): Path to background noise manifest file
-      snr (int): SNR for background noise (using average speaker power), set `snr_min` and `snr_max` values to enable random SNR
-      snr_min (int):  Min random SNR for background noise (using average speaker power), set `null` to use fixed SNR
-      snr_max (int):  Max random SNR for background noise (using average speaker power), set `null` to use fixed SNR
-
-    segment_augmentor:
-      add_seg_aug (bool): Set True to enable augmentation on each speech segment (Default: False)
-      segmentor:
-        gain:
-            prob (float): Probability range (uniform distribution) gain augmentation for individual segment
-            min_gain_dbfs (float): minimum gain in terms of dB
-            max_gain_dbfs (float): maximum gain in terms of dB
-
-    session_augmentor:
-      add_sess_aug: (bool) set True to enable audio augmentation on the whole session (Default: False)
-      segmentor:
-        white_noise:
+    Configuration parameters (YAML)::
+
+        Parameters:
+          manifest_filepath (str): Manifest file with paths to single speaker audio files
+          sr (int): Sampling rate of the input audio files from the manifest
+          random_seed (int): Seed to random number generator
+
+        session_config:
+          num_speakers (int): Number of unique speakers per multispeaker audio session
+          num_sessions (int): Number of sessions to simulate
+          session_length (int): Length of each simulated multispeaker audio session (seconds)
+
+        session_params:
+          max_audio_read_sec (int): Max audio length in seconds when loading an audio file
+          sentence_length_params (list): k,p values for a negative_binomial distribution
+          dominance_var (float): Variance in speaker dominance
+          min_dominance (float): Minimum percentage of speaking time per speaker
+          turn_prob (float): Probability of switching speakers after each utterance
+          mean_silence (float): Mean proportion of silence to speaking time [0, 1)
+          mean_silence_var (float): Variance for mean silence in all audio sessions
+          per_silence_var (float): Variance for each silence in an audio session
+          per_silence_min (float): Minimum duration for each silence (default: 0)
+          per_silence_max (float): Maximum duration for each silence (default: -1, no max)
+          mean_overlap (float): Mean proportion of overlap in non-silence duration [0, 1)
+          mean_overlap_var (float): Variance for mean overlap in all audio sessions
+          per_overlap_var (float): Variance for per overlap in each session
+          per_overlap_min (float): Minimum per overlap duration in seconds
+          per_overlap_max (float): Maximum per overlap duration in seconds (-1 for no max)
+          start_window (bool): Whether to window the start of sentences
+          window_type (str): Type of windowing ("hamming", "hann", "cosine")
+          window_size (float): Length of window at start/end of segmented utterance (seconds)
+          start_buffer (float): Buffer of silence before the start of the sentence
+          split_buffer (float): Split RTTM labels if greater than twice this amount of silence
+          release_buffer (float): Buffer before window at end of sentence
+          normalize (bool): Normalize speaker volumes
+          normalization_type (str): "equal" or "var" volume per speaker
+          normalization_var (str): Variance in speaker volume
+          min_volume (float): Minimum speaker volume (variable normalization only)
+          max_volume (float): Maximum speaker volume (variable normalization only)
+          end_buffer (float): Buffer at the end of the session to leave blank
+
+        outputs:
+          output_dir (str): Output directory for audio sessions and label files
+          output_filename (str): Output filename for the wav and RTTM files
+          overwrite_output (bool): If true, delete the output directory if it exists
+          output_precision (int): Number of decimal places in output files
+
+        background_noise:
+          add_bg (bool): Add ambient background noise if true
+          background_manifest (str): Path to background noise manifest file
+          snr (int): SNR for background noise (using average speaker power)
+          snr_min (int): Min random SNR (set null to use fixed SNR)
+          snr_max (int): Max random SNR (set null to use fixed SNR)
+
+        segment_augmentor:
+          add_seg_aug (bool): Enable augmentation on each speech segment (Default: False)
+          segmentor.gain:
+            prob (float): Probability of gain augmentation
+            min_gain_dbfs (float): minimum gain in dB
+            max_gain_dbfs (float): maximum gain in dB
+
+        session_augmentor:
+          add_sess_aug (bool): Enable audio augmentation on the whole session (Default: False)
+          segmentor.white_noise:
             prob (float): Probability of adding white noise (Default: 1.0)
-            min_level (float): minimum gain in terms of dB
-            max_level (float): maximum gain in terms of dB
-
-    speaker_enforcement:
-      enforce_num_speakers (bool): Enforce that all requested speakers are present in the output wav file
-      enforce_time (list): Percentage of the way through the audio session that enforcement mode is triggered (sampled
-                           between time 1 and 2)
-
-    segment_manifest: (parameters for regenerating the segment manifest file)
-      window (float): Window length for segmentation
-      shift (float): Shift length for segmentation
-      step_count (int): Number of the unit segments you want to create per utterance
-      deci (int): Rounding decimals for segment manifest file
+            min_level (float): minimum gain in dB
+            max_level (float): maximum gain in dB
+
+        speaker_enforcement:
+          enforce_num_speakers (bool): Enforce all requested speakers are present
+          enforce_time (list): Percentage through session that enforcement triggers
+
+        segment_manifest:
+          window (float): Window length for segmentation
+          shift (float): Shift length for segmentation
+          step_count (int): Number of unit segments per utterance
+          deci (int): Rounding decimals for segment manifest file
     """
 
     def __init__(self, cfg):
@@ -629,7 +593,7 @@ class MultiSpeakerSimulator(object):
         if num_missing != 0:
             warnings.warn(
                 f"{self._params.data_simulator.session_config.num_speakers - num_missing}"
-                f"speakers were included in the clip instead of the requested amount of "
+                "speakers were included in the clip instead of the requested amount of "
                 f"{self._params.data_simulator.session_config.num_speakers}"
             )
 
@@ -1117,7 +1081,7 @@ class MultiSpeakerSimulator(object):
             )
             self.annotator.annote_lists['json'].append(new_json_entry)
 
-            new_ctm_entries = self.annotator.create_new_ctm_entry(
+            new_ctm_entries, _ = self.annotator.create_new_ctm_entry(
                 words=self._words,
                 alignments=self._alignments,
                 session_name=filename,
@@ -1148,7 +1112,7 @@ class MultiSpeakerSimulator(object):
         if self._params.data_simulator.background_noise.add_bg:
             if len(self._noise_samples) > 0:
                 avg_power_array = torch.mean(array[is_speech == 1] ** 2)
-                bg, snr = get_background_noise(
+                bg, snr, _ = get_background_noise(
                     len_array=len(array),
                     power_array=avg_power_array,
                     noise_samples=self._noise_samples,
@@ -1190,7 +1154,7 @@ class MultiSpeakerSimulator(object):
         Args:
             random_seed (int): random seed for reproducibility
         """
-        logging.info(f"Generating Diarization Sessions")
+        logging.info("Generating Diarization Sessions")
         if random_seed is None:
             random_seed = self._params.data_simulator.random_seed
         np.random.seed(random_seed)
@@ -1286,29 +1250,25 @@ class RIRMultiSpeakerSimulator(MultiSpeakerSimulator):
     Args:
         cfg: OmegaConf configuration loaded from yaml file.
 
-    Parameters (in addition to the base MultiSpeakerSimulator parameters):
-    rir_generation:
-      use_rir (bool): Whether to generate synthetic RIR
-      toolkit (str): Which toolkit to use ("pyroomacoustics", "gpuRIR")
-      room_config:
-        room_sz (list): Size of the shoebox room environment (1d array for specific, 2d array for random range to be
-                        sampled from)
-        pos_src (list): Positions of the speakers in the simulated room environment (2d array for specific, 3d array
-                        for random ranges to be sampled from)
-        noise_src_pos (list): Position in room for the ambient background noise source
-      mic_config:
-        num_channels (int): Number of output audio channels
-        pos_rcv (list): Microphone positions in the simulated room environment (1d/2d array for specific, 2d/3d array
-                        for range assuming num_channels is 1/2+)
-        orV_rcv (list or null): Microphone orientations (needed for non-omnidirectional microphones)
-        mic_pattern (str): Microphone type ("omni" - omnidirectional) - currently only omnidirectional microphones are
-                           supported for pyroomacoustics
-      absorbtion_params: (Note that only `T60` is used for pyroomacoustics simulations)
-        abs_weights (list): Absorption coefficient ratios for each surface
-        T60 (float): Room reverberation time (`T60` is the time it takes for the RIR to decay by 60DB)
-        att_diff (float): Starting attenuation (if this is different than att_max, the diffuse reverberation model is
-                          used by gpuRIR)
-        att_max (float): End attenuation when using the diffuse reverberation model (gpuRIR)
+    Additional configuration parameters (on top of ``MultiSpeakerSimulator``)::
+
+        rir_generation:
+          use_rir (bool): Whether to generate synthetic RIR
+          toolkit (str): Which toolkit to use ("pyroomacoustics", "gpuRIR")
+          room_config:
+            room_sz (list): Size of the shoebox room environment
+            pos_src (list): Positions of the speakers in the simulated room
+            noise_src_pos (list): Position in room for background noise source
+          mic_config:
+            num_channels (int): Number of output audio channels
+            pos_rcv (list): Microphone positions in the simulated room
+            orV_rcv (list or null): Microphone orientations
+            mic_pattern (str): Microphone type ("omni")
+          absorbtion_params:
+            abs_weights (list): Absorption coefficient ratios for each surface
+            T60 (float): Room reverberation time (decay by 60dB)
+            att_diff (float): Starting attenuation for diffuse reverberation model
+            att_max (float): End attenuation for diffuse reverberation model (gpuRIR)
     """
 
     def __init__(self, cfg):
@@ -1466,6 +1426,8 @@ class RIRMultiSpeakerSimulator(MultiSpeakerSimulator):
         if self._params.data_simulator.rir_generation.mic_config.mic_pattern == 'omni':
             mic_pattern = DirectivityPattern.OMNI
             dir_vec = DirectionVector(azimuth=0, colatitude=90, degrees=True)
+        else:
+            raise Exception("Currently, microphone pattern must be omni. Aborting RIR generation.")
         dir_obj = CardioidFamily(
             orientation=dir_vec,
             pattern_enum=mic_pattern,
@@ -1509,6 +1471,8 @@ class RIRMultiSpeakerSimulator(MultiSpeakerSimulator):
                 out_channel = convolve(input, RIR[speaker_turn, channel, : len(input)]).tolist()
             elif self._params.data_simulator.rir_generation.toolkit == 'pyroomacoustics':
                 out_channel = convolve(input, RIR[channel][speaker_turn][: len(input)]).tolist()
+            else:
+                raise Exception("Toolkit must be pyroomacoustics or gpuRIR. Aborting RIR convolution.")
             if len(out_channel) > length:
                 length = len(out_channel)
             output_sound.append(torch.tensor(out_channel))
@@ -1643,8 +1607,12 @@ class RIRMultiSpeakerSimulator(MultiSpeakerSimulator):
             )
             self.annotator.annote_lists['json'].append(new_json_entry)
 
-            new_ctm_entries = self.annotator.create_new_ctm_entry(
-                filename, speaker_ids[speaker_turn], start / self._params.data_simulator.sr
+            new_ctm_entries, _ = self.annotator.create_new_ctm_entry(
+                words=self._text,
+                alignments=self._alignments,
+                session_name=filename,
+                speaker_id=speaker_ids[speaker_turn],
+                start=start / self._params.data_simulator.sr,
             )
             self.annotator.annote_lists['ctm'].extend(new_ctm_entries)
 
@@ -1659,23 +1627,21 @@ class RIRMultiSpeakerSimulator(MultiSpeakerSimulator):
             array = perturb_audio(array, self._params.data_simulator.sr, self.session_augmentor)
 
         # Step 7-2: Additive background noise from noise manifest files
-        if self._params.data_simulator.background_noise.add_bg:
-            if len(self._noise_samples) > 0:
-                avg_power_array = torch.mean(array[is_speech == 1] ** 2)
-                bg, snr = get_background_noise(
-                    len_array=len(array),
-                    power_array=avg_power_array,
-                    noise_samples=self._noise_samples,
-                    audio_read_buffer_dict=self._audio_read_buffer_dict,
-                    snr_min=self._params.data_simulator.background_noise.snr_min,
-                    snr_max=self._params.data_simulator.background_noise.snr_max,
-                    background_noise_snr=self._params.data_simulator.background_noise.snr,
-                    seed=(random_seed + idx),
-                    device=self._device,
-                )
-                array += bg
+        if self._params.data_simulator.background_noise.add_bg and len(self._noise_samples) > 0:
+            avg_power_array = torch.mean(array[is_speech == 1] ** 2)
+            bg, snr, _ = get_background_noise(
+                len_array=len(array),
+                power_array=avg_power_array,
+                noise_samples=self._noise_samples,
+                audio_read_buffer_dict=self._audio_read_buffer_dict,
+                snr_min=self._params.data_simulator.background_noise.snr_min,
+                snr_max=self._params.data_simulator.background_noise.snr_max,
+                background_noise_snr=self._params.data_simulator.background_noise.snr,
+                seed=(random_seed + idx),
+                device=self._device,
+            )
+            array += bg
             length = array.shape[0]
-            bg, snr = self._get_background(length, avg_power_array)
             augmented_bg, _ = self._convolve_rir(bg, -1, RIR)
             for channel in range(self._params.data_simulator.rir_generation.mic_config.num_channels):
                 array[:, channel] += augmented_bg[channel][:length]

nemo/collections/asr/data/ssl_dataset.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2024, NVIDIA CORPORATION.  All rights reserved.
+# Copyright (c) 2025, NVIDIA CORPORATION.  All rights reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -103,12 +103,8 @@ def _audio_noise_collate_fn(batch: List[AudioNoiseItem], batch_augmentor: Any =
     noises = [x.noise for x in batch]
     noise_lengths = [x.noise_len for x in batch]
 
-    noisy_audios = [x.noisy_audio for x in batch]
-    noisy_audio_lengths = [x.noisy_audio_len for x in batch]
-
     audio_signal_list = []
     noise_signal_list = []
-    noisy_audio_signal_list = []
     for i, audio in enumerate(audios):
         audio_len = audio.size(0)
         if audio_len < max_audio_len:
@@ -123,31 +119,23 @@ def _audio_noise_collate_fn(batch: List[AudioNoiseItem], batch_augmentor: Any =
             noise = torch.nn.functional.pad(noise, pad)
         noise_signal_list.append(noise[:max_audio_len])
 
-        noisy_audio = noisy_audios[i]
-        noisy_audio_len = noisy_audio.size(0)
-        if noisy_audio_len < max_audio_len:
-            pad = (0, max_audio_len - noisy_audio_len)
-            noisy_audio = torch.nn.functional.pad(noisy_audio, pad)
-        noisy_audio_signal_list.append(noisy_audio[:max_audio_len])
-
     audio_signal = torch.stack(audio_signal_list).float()
     audio_lengths = torch.stack(audio_lengths).long()
     noise_signal = torch.stack(noise_signal_list).float()
     noise_lengths = torch.stack(noise_lengths).long()
-    noisy_audio_signal = torch.stack(noisy_audio_signal_list).float()
-    noisy_audio_lengths = torch.stack(noisy_audio_lengths).long()
 
     output = AudioNoiseBatch(
         audio=audio_signal,
         audio_len=audio_lengths,
         noise=noise_signal,
         noise_len=noise_lengths,
-        noisy_audio=noisy_audio_signal,
-        noisy_audio_len=noisy_audio_lengths,
     )
 
     if batch_augmentor is not None:
         output = batch_augmentor(output)
+    else:
+        output.noisy_audio = output.audio + output.noise
+        output.noisy_audio_len = output.audio_len
 
     return output
 
@@ -344,8 +332,6 @@ class AudioNoiseDataset(audio_to_text.AudioToCharDataset):
             audio_len=audio_len,
             noise=noise,
             noise_len=noise_len,
-            noisy_audio=audio + noise,
-            noisy_audio_len=audio_len,
         )
         return item
 
@@ -421,8 +407,6 @@ class TarredAudioNoiseDataset(audio_to_text.TarredAudioToCharDataset):
             audio_len=audio_len,
             noise=noise,
             noise_len=noise_len,
-            noisy_audio=audio + noise,
-            noisy_audio_len=audio_len,
         )
         return item
 
@@ -460,21 +444,29 @@ class LhotseAudioNoiseDataset(torch.utils.data.Dataset):
     def __getitem__(self, cuts):
 
         audios, audio_lens, cuts = self.load_audio(cuts)
-        sampled_noises = [sample_noise(self.noise_data, cut.sampling_rate, cut.num_samples) for cut in cuts]
-
-        items = [
-            AudioNoiseItem(
-                sample_id=str(cuts[i].id),
-                audio=audios[i],
-                audio_len=audio_lens[i],
-                noise=sampled_noises[i][0],
-                noise_len=sampled_noises[i][1],
-                noisy_audio=audios[i] + sampled_noises[i][0],
-                noisy_audio_len=audio_lens[i],
-            )
-            for i in range(len(cuts))
-        ]
-        return _audio_noise_collate_fn(items, self.batch_augmentor)
+        if len(self.noise_data) > 0:
+            sampled_noises = [sample_noise(self.noise_data, cut.sampling_rate, cut.num_samples) for cut in cuts]
+            sampled_noises, sampled_noises_lens = zip(*sampled_noises)
+            sampled_noises = torch.stack(sampled_noises).float()
+            sampled_noises_lens = torch.tensor(sampled_noises_lens).long()
+        else:
+            sampled_noises = torch.zeros_like(audios)
+            sampled_noises_lens = audio_lens
+
+        output = AudioNoiseBatch(
+            audio=audios,
+            audio_len=audio_lens,
+            noise=sampled_noises,
+            noise_len=sampled_noises_lens,
+        )
+
+        if self.batch_augmentor is not None:
+            output = self.batch_augmentor(output)
+        else:
+            output.noisy_audio = output.audio + output.noise
+            output.noisy_audio_len = output.audio_len
+
+        return output
 
 
 def get_audio_noise_dataset(

nemo/collections/asr/data/text_to_text.py

@@ -335,7 +335,9 @@ class TextToTextDatasetBase:
                 tts_tokenizer_global = copy.deepcopy(tokenizer)
 
             with concurrent.futures.ProcessPoolExecutor(
-                initializer=_init_tts_tokenize_process, initargs=(tts_parser,), max_workers=tokenizer_workers,
+                initializer=_init_tts_tokenize_process,
+                initargs=(tts_parser,),
+                max_workers=tokenizer_workers,
             ) as pool:
                 # chunk size for pool map is empirically chosen as a trade-off between speed and responsiveness
                 for i, tokenized_text in enumerate(
@@ -373,7 +375,7 @@ class TextToTextDatasetBase:
 
 
 class TextToTextDataset(TextToTextDatasetBase, Dataset):
-    """Text-to-Text Map-style Dataset for hybrid ASR-TTS models"""
+    """Text-to-Text Map-style Dataset."""
 
     def __init__(
         self,
@@ -418,8 +420,8 @@ class TextToTextDataset(TextToTextDatasetBase, Dataset):
 
 class TextToTextIterableDataset(TextToTextDatasetBase, IterableDataset):
     """
-    Text-to-Text Iterable Dataset for hybrid ASR-TTS models
-    Only part necessary for current process should be loaded and stored
+    Text-to-Text Iterable Dataset.
+    Only part necessary for current process should be loaded and stored.
     """
 
     def __init__(

nemo/collections/asr/inference/__init__.py

@@ -0,0 +1,13 @@
+# Copyright (c) 2025, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.

nemo/collections/asr/inference/factory/__init__.py

@@ -0,0 +1,13 @@
+# Copyright (c) 2025, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.