simulstream 0.1.0__py3-none-any.whl

simulstream/server/speech_processors/incremental_output.py

@@ -0,0 +1,85 @@
+# Copyright 2025 FBK
+
+# 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
+from dataclasses import dataclass
+from typing import List, Callable
+
+
+@dataclass
+class IncrementalOutput:
+    """
+    Represents the incremental output of a speech processor for a single
+    processed chunk of audio.
+
+    Attributes:
+        new_tokens (List[str]): List of newly generated tokens in this chunk.
+        new_string (str): Concatenated string representation of the new tokens.
+        deleted_tokens (List[str]): List of tokens that were deleted/overwritten.
+        deleted_string (str): Concatenated string representation of the deleted tokens.
+    """
+    new_tokens: List[str]
+    new_string: str
+    deleted_tokens: List[str]
+    deleted_string: str
+
+    def strings_to_json(self) -> str:
+        """
+        Serialize the incremental output to a JSON string.
+
+        Returns:
+            str: A JSON string containing the newly generated and the deleted text.
+        """
+        return json.dumps({"new": self.new_string, "deleted": self.deleted_string})
+
+
+def merge_incremental_outputs(
+        outputs: List[IncrementalOutput],
+        tokens_to_string: Callable[[List[str]], str]) -> IncrementalOutput:
+    """
+    Merge the incremental outputs passed as input into a single incremental output.
+    The outputs must be sorted in cronological order.
+
+    Args:
+        outputs (List[IncrementalOutput]): List of incremental outputs to be merged.
+        tokens_to_string (Callable[[List[str]], str]): A function that takes a list of tokens and
+            returns a string that contains the detokenized text.
+    """
+    if len(outputs) == 1:
+        return outputs[0]
+    if len(outputs) == 0:
+        return IncrementalOutput([], "", [], "")
+
+    current_output_tokens = outputs[0].new_tokens
+    current_output_deleted_tokens = outputs[0].deleted_tokens
+    for output in outputs[1:]:
+        num_deleted_tokens = len(output.deleted_tokens)
+        if num_deleted_tokens > 0:
+            if num_deleted_tokens < len(current_output_tokens):
+                assert output.deleted_tokens == current_output_tokens[-num_deleted_tokens:]
+                current_output_tokens = current_output_tokens[:-num_deleted_tokens]
+            else:
+                # we are deleting more than it was generated so far, so extra deleted tokens
+                # should be included
+                extra_deleted_tokens = output.deleted_tokens[:-len(current_output_tokens)]
+                current_output_deleted_tokens = \
+                    extra_deleted_tokens + current_output_deleted_tokens
+                current_output_tokens = []
+        current_output_tokens += output.new_tokens
+
+    return IncrementalOutput(
+        current_output_tokens,
+        tokens_to_string(current_output_tokens),
+        current_output_deleted_tokens,
+        tokens_to_string(current_output_deleted_tokens))

simulstream/server/speech_processors/seamless_sliding_window_retranslation.py

@@ -0,0 +1,84 @@
+# Copyright 2025 FBK
+
+# 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 types import SimpleNamespace
+from typing import List
+
+import numpy as np
+import torch
+from transformers import AutoProcessor, SeamlessM4TModel, SeamlessM4Tv2Model
+
+from simulstream.server.speech_processors import SAMPLE_RATE
+from simulstream.server.speech_processors.sliding_window_retranslation import \
+    SlidingWindowRetranslator
+
+
+class SeamlessSlidingWindowRetranslator(SlidingWindowRetranslator):
+    """
+    Perform Sliding Window Retranslation with a SeamlessM4T speech-to-text model.
+    """
+
+    @classmethod
+    def load_model(cls, config: SimpleNamespace):
+        if not hasattr(cls, "model") or cls.model is None:
+            cls.processor = AutoProcessor.from_pretrained(config.hf_model_name)
+            seamless_version = getattr(config, "seamless_version", 1)
+            if seamless_version == 2:
+                cls.model = SeamlessM4Tv2Model.from_pretrained(config.hf_model_name)
+            else:
+                cls.model = SeamlessM4TModel.from_pretrained(config.hf_model_name)
+            cls.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+            cls.model.to(cls.device)
+
+    def _generate(self, speech: torch.Tensor) -> List[str]:
+        speech_seconds = speech.shape[1] / 50  # 1 frame every 20 ms
+        extra_kwargs = {
+            "max_new_tokens": int(max(self.max_tokens_per_second * speech_seconds, 10)),
+            "generate_speech": False
+        }
+        if self.tgt_lang_tag is not None:
+            extra_kwargs["tgt_lang"] = self.tgt_lang_tag
+        generated_ids = self.model.generate(input_features=speech, **extra_kwargs)[0]
+        return self.processor.tokenizer.convert_ids_to_tokens(
+            generated_ids.squeeze(), skip_special_tokens=True)
+
+    def tokens_to_string(self, tokens: List[str]) -> str:
+        # avoid that the initial space, if it is there, get removed in the detokenization
+        if self.text_history is not None and len(self.text_history) > 0:
+            tokens = [''] + tokens
+        return self.processor.tokenizer.convert_tokens_to_string(tokens)
+
+    def _preprocess(self, waveform: np.float32) -> torch.Tensor:
+        """
+        Extracts the filter-bank features from the input waveform and appends them to the audio
+        history. Returns the concatenated audio history and new frames, taking the last
+        `self.window_len` frames, and returns it after storing it in the audio history.
+        """
+        if self.audio_history is not None:
+            waveform = np.concatenate((self.audio_history, waveform))
+        new_speech_len = len(waveform)
+        if new_speech_len > self.window_len:
+            waveform = waveform[-self.window_len:]
+        self.audio_history = waveform
+        new_speech = self.processor(
+            audios=waveform,
+            sampling_rate=SAMPLE_RATE,
+            return_tensors="pt")
+        return new_speech["input_features"].to(self.device)
+
+    def set_target_language(self, language: str) -> None:
+        self.tgt_lang_tag = language
+
+    def set_source_language(self, language: str) -> None:
+        pass

simulstream/server/speech_processors/seamless_streamatt.py

@@ -0,0 +1,268 @@
+# Copyright 2025 FBK
+
+# 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 types import SimpleNamespace
+from typing import List, Tuple
+
+import numpy as np
+import torch
+from transformers import AutoProcessor, SeamlessM4TModel, SeamlessM4Tv2Model
+
+from simulstream.server.speech_processors import SAMPLE_RATE
+from simulstream.server.speech_processors.base_streamatt import BaseStreamAtt
+
+
+SHIFT_SIZE = 10
+SEAMLESS_AUDIO_SUBSAMPLING_FACTOR = 8
+# `FRAME_LENGTH` is the length of the window used for computing the mel-filterbank features that,
+# with a sample rate of 16kHz, corresponds to 25ms while `HOP_LENGTH` is how much the feature
+# computation is shifted at each step, corresponding to 10ms. Values from `transformers.models.
+# seamless_m4t.feature_extraction_seamless_m4t.SeamlessM4TFeatureExtractor._extract_fbank_features`
+FRAME_LENGTH = 400
+HOP_LENGTH = 160
+# `OVERLAP_WINDOW` is length of the features that overlap at each step, as described in
+# `transformers.audio_utils.spectrogram`, and corresponding to 15ms.
+OVERLAP_WINDOW = FRAME_LENGTH - HOP_LENGTH
+
+
+class SeamlessStreamAtt(BaseStreamAtt):
+    """
+    Perform StreamAtt policy with the chosen textual history selection using a SeamlessM4T
+    speech-to-text model.
+
+    Args:
+       config (SimpleNamespace): Configuration object.
+           The following additional attributes are expected:
+           - **max_new_tokens (int)**: The maximum numbers of tokens to generate
+           - **num_beams (int)**: The number of beams of the beam search
+           - **no_repeat_ngram_size (int)**: The maximum number of ngram repeats that
+             cannot be emitted
+           - **audio_history_max_duration (int)**: Maximum length of the audio history to store,
+             in seconds. Defaults to 1 hour.
+
+    """
+
+    def __init__(self, config: SimpleNamespace):
+        super().__init__(config)
+        self.audio_subsampling_factor = SEAMLESS_AUDIO_SUBSAMPLING_FACTOR
+        self.max_new_tokens = getattr(self.config, "max_new_tokens", 128)
+        self.num_beams = getattr(self.config, "num_beams", 5)
+        self.audio_history_max_duration = getattr(self.config, "audio_history_max_duration", 360)
+        self.no_repeat_ngram_size = getattr(self.config, "no_repeat_ngram_size", 5)
+        self.waveform_accumulator = None
+
+    @property
+    def audio_max_len(self) -> float:
+        """
+        Returns the maximum allowed length for the audio history converted in the space of
+        audio features. The number of encoded features is obtained by first converting the
+        self.audio_history_max_duration, originally in seconds, into milliseconds, and then
+        by the dimension of the shift (SHIFT_SIZE). Since the SeamlessM4t encoder subsamples
+        the input sequence, the resulting *audio_max_len* is obtained by further dividing
+        the original sequence length by *self.audio_subsampling_factor*.
+        """
+        return self.audio_history_max_duration * 1000 // SHIFT_SIZE // \
+            self.audio_subsampling_factor
+
+    @classmethod
+    def load_model(cls, config: SimpleNamespace):
+        if not hasattr(cls, "model") or cls.model is None:
+            cls.processor = AutoProcessor.from_pretrained(config.hf_model_name)
+            seamless_version = getattr(config, "seamless_version", 1)
+            if seamless_version == 2:
+                cls.model = SeamlessM4Tv2Model.from_pretrained(config.hf_model_name)
+            else:
+                cls.model = SeamlessM4TModel.from_pretrained(config.hf_model_name)
+            cls.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+            cls.model.to(cls.device)
+
+    @staticmethod
+    def mean_variance_normalization(features: np.ndarray) -> torch.Tensor:
+        """
+        Normalization function taken from `transformers.models.seamless_m4t.
+        feature_extraction_seamless_m4t.SeamlessM4TFeatureExtractor`.
+        """
+        # torch defaults to ddof=1, and numpy defaults to ddof=0
+        mu = np.expand_dims(features.mean(axis=0), 0)
+        sigma = np.sqrt(np.expand_dims(features.var(axis=0, ddof=1), 0) + 1e-7)
+        normalized = (features - mu) / sigma
+        return torch.tensor(np.array(normalized))
+
+    def _preprocess(self, waveform: np.ndarray) -> torch.Tensor:
+        """
+        Extract normalized input features for the SeamlessM4T model from the new
+        audio chunk (`waveform`) and the overlapping tail contained in
+        `self.waveform_accumulator`,  and then concatenating them with previously
+        extracted features stored in `self.audio_history`.
+
+        Steps:
+        1. Convert the new waveform and the overlapping tail into mel-filterbank features.
+        2. Concatenate the new features with any stored `self.audio_history`.
+        3. Apply mean-variance normalization.
+        4. Cache the overlapping tail of the waveform for the next step.
+
+        Returns:
+            torch.Tensor: Normalized feature tensor on `self.device`.
+        """
+        # Combine with overlapping part from previous step, if any
+        if self.waveform_accumulator is not None:
+            waveform = np.concatenate((self.waveform_accumulator, waveform))
+
+        if len(waveform) >= FRAME_LENGTH:
+            # Extract new mel-filterbank features (unnormalized)
+            new_features = self.processor(
+                audios=waveform,
+                return_tensors="np",
+                do_normalize_per_mel_bins=False,
+                sampling_rate=SAMPLE_RATE,
+            )["input_features"].squeeze(0)  # shape: (T_new, 160)
+
+            # Concatenate with previous features, if available
+            if self.audio_history is not None:
+                self.audio_history = np.concatenate((self.audio_history, new_features), axis=0)
+            else:
+                self.audio_history = new_features
+
+        # Normalize all features
+        normalized_features = self.mean_variance_normalization(self.audio_history)
+
+        # Store the last part of the waveform for the next preprocessing step
+        self.waveform_accumulator = waveform[-OVERLAP_WINDOW:]
+
+        return normalized_features.unsqueeze(0).to(self.device)
+
+    def get_prefix(self):
+        """
+        Creates a prefix for the generation phase with the previous outputs stored in
+        the text_history. The prefix is formatted following the SeamlessM4T template
+        (tgt language token id + text history ids).
+        """
+        prefix_ids = torch.tensor(
+            [[self.model.generation_config.text_decoder_lang_to_code_id.get(self.tgt_lang)]]
+        ).to(self.device)
+        if self.text_history:
+            text_history_ids = torch.tensor(
+                self.processor.tokenizer.convert_tokens_to_ids(self.text_history)).unsqueeze(
+                dim=0).to(self.device)
+            prefix_ids = torch.cat((prefix_ids, text_history_ids), dim=1)
+        return prefix_ids.long()
+
+    def _generate(
+            self, input_features: torch.Tensor, normalize_attn: bool = True
+    ) -> Tuple[List[str], torch.Tensor]:
+        """
+        Generates a new hypothesis returning also the cross attention scores.
+        The hypothesis is forced to start with the `prefix_ids` prefix tokens,
+        which are then removed from the returned output tokens.
+        The attention scores are returned with dimensions (sequence_len, n_audio_features)
+        where `sequence_len` is the length of the prefix (excluding the language ID)
+        and of the new hypothesis.
+        """
+        prefix_ids = self.get_prefix()
+        gen_out = self.model.generate(
+            input_features=input_features,
+            decoder_input_ids=prefix_ids,
+            max_new_tokens=self.max_new_tokens,
+            num_beams=self.num_beams,
+            return_dict_in_generate=True,
+            output_attentions=True,
+            no_repeat_ngram_size=self.no_repeat_ngram_size,
+            generate_speech=False)
+        out_ids = list(gen_out.sequences[0])
+
+        # Exclude BOS, prefix, and EOS from the generated sequence
+        new_hypo_ids = out_ids[prefix_ids.shape[1] + 1:-1]
+
+        cross_attn = self.get_cross_attention(
+            gen_out, len(new_hypo_ids), normalize_attn=normalize_attn)
+
+        assert cross_attn.shape[0] == (prefix_ids.shape[1] - 1) + len(new_hypo_ids), \
+            f"Cross attention scores along tokens dimension ({cross_attn.shape[0]}) " \
+            f"mismatch with the length of the hypothesis " \
+            f"({(prefix_ids.shape[1] - 1) + len(new_hypo_ids)})."
+
+        new_hypo = self.processor.tokenizer.convert_ids_to_tokens(
+            new_hypo_ids, skip_special_tokens=True)
+        return new_hypo, cross_attn
+
+    def _extract_new_hypo_attention_scores(self, new_hypo_len: int, gen_out):
+        """
+        Extract attention scores `cross_attentions` from `gen_out`, which are stored for each
+        generation step and Layer `layer`, based on the beam index selected at each step of the
+        beam search and stored in `beam_indices` (if num_beams > 1) for the new hypotheses.
+        """
+        cross_attns = []
+        if self.num_beams > 1:
+            # Beam search: for each token of the new hypothesis, we select the corresponding cross
+            # attention from the cross attentions stored at each step of the beam search using the
+            # index contained in the tensor of indices beam_indices (num_beams * sequence length)
+            for tok_idx in range(new_hypo_len):
+                # Select the cross attention matrix using the beam_indices
+                beam_indices = gen_out.beam_indices[:, tok_idx]
+                # add some comments on why tok_idx + 1, and the -1 selection
+                cross_attn = gen_out.cross_attentions[
+                    tok_idx + 1][self.cross_attn_layer][:, :, -1, :]
+                cross_attn = cross_attn.index_select(dim=0, index=beam_indices)
+                cross_attns.append(cross_attn)
+        else:
+            # Greedy search
+            for tok_idx in range(new_hypo_len):
+                cross_attn = gen_out.cross_attentions[
+                    tok_idx + 1][self.cross_attn_layer][:, :, -1, :]
+                cross_attns.append(cross_attn)
+
+        # Cross attention scores with shape [num_heads, sequence_len, n_audio_features]
+        cross_attns = torch.stack(cross_attns).squeeze(1)
+        return cross_attns
+
+    def get_cross_attention(
+            self, gen_out, new_hypo_len: int, normalize_attn: bool) -> torch.Tensor:
+        """
+        Given the attention scores for the generated output (including both prefix and new
+        hypothesis), this function returns the cross attention scores from Layer *layer* by
+        averaging the scores along the attention heads dimension.
+        """
+        # The prefix is stored in the first element of the cross_attentions, equal for each beam
+        # and, therefore, the first is selected. Also, BOS and language ID are excluded from the
+        # sequence_len (first two elements).
+        cross_attns = (
+            gen_out.cross_attentions[0][self.cross_attn_layer][0, :, 2:, :].transpose(0, 1))
+
+        if new_hypo_len > 0:
+            new_cross_attns = self._extract_new_hypo_attention_scores(new_hypo_len, gen_out)
+            cross_attns = torch.cat([cross_attns, new_cross_attns], dim=0)
+
+        # Average on the attention heads dimension
+        cross_attns = cross_attns.mean(dim=1)
+
+        # Normalize attention scores
+        if normalize_attn:
+            cross_attns = self.normalize_attn(cross_attns)
+        return cross_attns
+
+    def tokens_to_string(self, tokens: List[str]) -> str:
+        # avoid that the initial space, if it is there, get removed in the detokenization
+        if self.text_history is not None and len(self.text_history) > 0:
+            tokens = [''] + tokens
+        return self.processor.tokenizer.convert_tokens_to_string(tokens)
+
+    def set_target_language(self, language: str) -> None:
+        self.tgt_lang = language
+
+    def set_source_language(self, language: str) -> None:
+        pass
+
+    def clear(self) -> None:
+        super().clear()
+        self.waveform_accumulator = None

simulstream/server/speech_processors/simuleval_wrapper.py

@@ -0,0 +1,165 @@
+# Copyright 2025 FBK
+
+# 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 logging
+import torch
+import numpy as np
+
+from types import SimpleNamespace
+from typing import List
+
+from simulstream.metrics.detokenizers import get_detokenizer
+from simulstream.server.speech_processors import IncrementalOutput, SpeechProcessor, class_load
+from simulstream.server.speech_processors import SAMPLE_RATE
+
+
+logger = logging.getLogger(__name__)
+
+
+try:
+    from simuleval.agents.agent import SEGMENT_TYPE_DICT
+    from simuleval.agents.actions import Action
+    from simuleval.data.segments import SpeechSegment
+except Exception as e:
+    logger.error(
+        "Not able to import SimulEval. Please install SimulEval or add it to your PYTHONPATH.")
+    # In case we are running unit tests, avoid failures when importing the Wrapper
+    import os
+    is_testing = os.getenv("IS_TESTING")
+    if not (is_testing is not None and bool(is_testing)):
+        raise e
+    import builtins
+    # Temporarily inject types to satisfy simuleval_wrapper imports
+    # These need to remain in builtins for type annotations in the class definition
+    builtins.Action = type("Action", (), {})
+    builtins.SpeechSegment = type("SpeechSegment", (), {})
+
+
+class SimulEvalWrapper(SpeechProcessor):
+    """
+    Wrapper processor that calls the configured `simuleval_agent` implemented on SimulEval>=1.1.0.
+    """
+    def __init__(self, config: SimpleNamespace):
+        super().__init__(config)
+        agent_class_name = getattr(config, "simuleval_agent")
+        agent_class = class_load(agent_class_name)
+        config.source_segment_size = config.speech_chunk_size * 1000
+        config.device = "cuda" if torch.cuda.is_available() else "cpu"
+        self.simuleval_agent = agent_class(config)
+        self.latency_unit = config.latency_unit
+        self.segment_type = self._segment_type_class()
+        self.emission_started = False
+        self.detokenizer = get_detokenizer(config)
+
+    def _segment_type_class(self):
+        return SEGMENT_TYPE_DICT[self.simuleval_agent.target_type]
+
+    @classmethod
+    def load_model(cls, config: SimpleNamespace):
+        """
+        In SimulEval, the model is loaded in the init of the `simuleval_agent` and,
+        therefore, a copy of the model for each client is created.
+        """
+        pass
+
+    def set_target_language(self, language: str) -> None:
+        if hasattr(self.simuleval_agent, "tgt_lang"):
+            self.simuleval_agent.tgt_lang = language
+        else:
+            logger.warning("Unable to set the target language for SimulEval agent.")
+
+    def set_source_language(self, language: str) -> None:
+        pass
+
+    def tokens_to_string(self, tokens: List[str]) -> str:
+        return self.detokenizer(tokens)
+
+    def _process_action(self, action: Action) -> str:
+        """
+        Processes a SimulEval action and updates the target state accordingly.
+
+        If the action is of type READ, no output is produced and an empty prediction string is
+        returned. Otherwise (WRITE action), the method extracts the generated content from the
+        action, wraps it in the appropriate target segment type, and updates the SimulEval agent's
+        target state with this new segment.
+
+        Args:
+            action (Action): The current SimulEval action to process. It can either
+                request reading more input (READ) or writing an output (WRITE).
+
+        Returns:
+            str: The predicted output text if the action is WRITE, or an empty string
+                if the action is READ.
+        """
+        if action.is_read():
+            return ""
+
+        prediction = action.content
+        segment = self.segment_type(index=0, content=prediction, finished=action.finished)
+        self.simuleval_agent.states.update_target(segment)
+        return prediction
+
+    def _build_incremental_outputs(self, generated_text: str) -> IncrementalOutput:
+        """
+        Transform the prediction string from `Action.content` of SimulEval into the required
+        IncrementalOutput format. The token conversion follows the original SimulEval Instance
+        handling (https://github.com/facebookresearch/SimulEval/blob/
+        536de8253b82d805c9845440169a5010ff507357/simuleval/evaluator/instance.py#L209) with the
+        sole exception of not removing generated spaces in the character-level languages.
+        Since SimulEval only supports incremental outputs, no tokens are deleted.
+        """
+        if self.latency_unit in ["word", "spm"]:
+            generated_tokens = generated_text.strip().split()
+        elif self.latency_unit == "char":
+            generated_tokens = list(generated_text.strip())
+        else:
+            raise NotImplementedError
+
+        if self.emission_started and self.latency_unit == "word":
+            generated_text = " " + generated_text
+
+        self.emission_started = True
+
+        return IncrementalOutput(
+            new_tokens=generated_tokens,
+            new_string=generated_text,
+            deleted_tokens=[],
+            deleted_string="",
+        )
+
+    def process_chunk(self, waveform: np.float32) -> IncrementalOutput:
+        source_segment = SpeechSegment(
+            index=0,
+            content=waveform.tolist(),
+            sample_rate=SAMPLE_RATE,
+            finished=False,
+            tgt_lang=self.simuleval_agent.tgt_lang,
+        )
+        self.simuleval_agent.states.update_source(source_segment)
+        action = self.simuleval_agent.policy(self.simuleval_agent.states)
+        prediction = self._process_action(action)
+        new_output = self._build_incremental_outputs(prediction)
+        return new_output
+
+    def end_of_stream(self) -> IncrementalOutput:
+        self.simuleval_agent.states.source_finished = True
+        action = self.simuleval_agent.policy(self.simuleval_agent.states)
+        prediction = self._process_action(action)
+        new_output = self._build_incremental_outputs(prediction)
+        return new_output
+
+    def clear(self) -> None:
+        """ In SimulEval, the agent is reset inside `simuleval_agent` """
+        self.simuleval_agent.reset()
+        self.emission_started = False