rasa-pro 3.20.0.dev4__tar.gz → 3.20.0.dev5__tar.gz

{rasa_pro-3.20.0.dev4 → rasa_pro-3.20.0.dev5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: rasa-pro
-Version: 3.20.0.dev4
+Version: 3.20.0.dev5
 Summary: State-of-the-art open-core Conversational AI framework for Enterprises that natively leverages generative AI for effortless assistant development.
 Keywords: nlp,machine-learning,machine-learning-library,bot,bots,botkit,rasa conversational-agents,conversational-ai,chatbot,chatbot-framework,bot-framework
 Author: Rasa Technologies GmbH

{rasa_pro-3.20.0.dev4 → rasa_pro-3.20.0.dev5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "rasa-pro"
-version = "3.20.0.dev4"
+version = "3.20.0.dev5"
 description = "State-of-the-art open-core Conversational AI framework for Enterprises that natively leverages generative AI for effortless assistant development."
 authors = [ "Rasa Technologies GmbH <hi@rasa.com>",]
 maintainers = [ "Tom Bocklisch <tom@rasa.com>",]

{rasa_pro-3.20.0.dev4 → rasa_pro-3.20.0.dev5}/rasa/core/channels/voice_stream/tts/azure.py

@@ -115,12 +115,13 @@ class AzureTTS(TTSEngine[AzureTTSConfig]):
 
         self._speech_config: Optional[speechsdk.SpeechConfig] = None
         self._synthesizer: Optional[speechsdk.SpeechSynthesizer] = None
-        self._callback: Optional[speechsdk.audio.PushAudioOutputStreamCallback] = None
+        self._callback: Optional[_AudioOutputCallback] = None
         self._loop: Optional[asyncio.AbstractEventLoop] = None
 
         # Per-response streaming state
         self._tts_request: Optional[speechsdk.SpeechSynthesisRequest] = None
         self._tts_future: Optional[Any] = None
+        self._stop_future: Optional[Any] = None
 
     # ── Lifecycle ────────────────────────────────────────────────────
 
@@ -129,11 +130,15 @@ class AzureTTS(TTSEngine[AzureTTSConfig]):
     ) -> None:
         """Set per-response mode based on SSML content and SDK availability."""
         config = streaming_config or StreamingConfig()
+        self._audio_queue = asyncio.Queue()
+        if self._callback is not None:
+            self._callback.queue = self._audio_queue
         sdk_available = self._synthesizer is not None
         self._use_streaming = not config.response_text_contains_ssml and sdk_available
         self._text_buffer.clear()
         self._tts_request = None
         self._tts_future = None
+        self._stop_future = None
 
         if self._use_streaming:
             self._tts_request = speechsdk.SpeechSynthesisRequest(
@@ -240,25 +245,26 @@ class AzureTTS(TTSEngine[AzureTTSConfig]):
         Pushes a None sentinel to the audio queue when synthesis finishes.
         """
         self._tts_request.input_stream.close() if self._tts_request else None
-        if not self._tts_future:
+        future = self._tts_future
+        loop = self._loop
+        audio_queue = self._audio_queue
+        if not future:
             return
-        # Capture references for the closure; self._audio_queue and
-        # self._tts_future are reset on the next prepare_response().
 
         def _wait_and_signal() -> None:
             try:
-                self._tts_future.get() if self._tts_future else None
+                future.get()
             except Exception as e:
                 structlogger.error(
                     "azure.signal_text_done.future_error",
                     error=str(e),
                 )
             finally:
-                self._loop.call_soon_threadsafe(
-                    self._audio_queue.put_nowait, None
-                ) if self._loop else None
+                loop.call_soon_threadsafe(
+                    audio_queue.put_nowait, None
+                ) if loop else None
 
-        self._loop.run_in_executor(None, _wait_and_signal) if self._loop else None
+        loop.run_in_executor(None, _wait_and_signal) if loop else None
 
     async def _synthesize_buffered_text(self) -> None:
         """Synthesize all buffered text via REST and push to audio queue."""
@@ -419,22 +425,24 @@ class AzureTTS(TTSEngine[AzureTTSConfig]):
             additional_languages=additional_languages,
         )
 
-    async def stop_streaming(self) -> None:
-        """Clear the TTS engine buffer."""
-        structlogger.debug("azure_tts.stop_streaming")
-        await super().stop_streaming()
-        self._stop_speaking()
-
     async def signal_interrupt(self) -> None:
-        """Stop in-flight SDK synthesis when a stream ends without barge-in."""
+        """Stop in-flight SDK synthesis and close the current audio stream."""
         structlogger.debug("azure_tts.signal_interrupt")
         async with self._get_engine_lock():
-            self._stop_speaking()
+            await self._wait_until_stopped()
 
-    def _stop_speaking(self) -> None:
-        if self._synthesizer:
+    def _request_stop_speaking(self) -> Optional[Any]:
+        if self._synthesizer and self._stop_future is None:
             structlogger.debug("azure_tts.stop_speaking_async")
-            self._synthesizer.stop_speaking_async()
+            self._stop_future = self._synthesizer.stop_speaking_async()
+        return self._stop_future
+
+    async def _wait_until_stopped(self) -> None:
+        stop_future = self._request_stop_speaking()
+        if stop_future is not None:
+            loop = asyncio.get_running_loop()
+            await loop.run_in_executor(None, stop_future.get)
+        await self._audio_queue.put(None)
 
     def _get_azure_audio_format(self) -> "speechsdk.SpeechSynthesisOutputFormat":
         from azure.cognitiveservices.speech import SpeechSynthesisOutputFormat

{rasa_pro-3.20.0.dev4 → rasa_pro-3.20.0.dev5}/rasa/core/channels/voice_stream/tts/cartesia.py

@@ -1,7 +1,6 @@
 import base64
 import os
 from typing import Any, AsyncIterator, Dict, List, Optional
-from uuid import uuid4
 
 import aiohttp
 import structlog
@@ -47,10 +46,6 @@ class CartesiaTTS(TTSEngine[CartesiaTTSConfig]):
     ws: Optional[aiohttp.ClientWebSocketResponse] = None
     streaming_input: bool = True
 
-    # Each synthesis context has a unique ID
-    # gets reset in signal_text_done()
-    context_id = uuid4().hex
-
     @classmethod
     def name(cls) -> str:
         """Return the name identifier for this TTS engine."""
@@ -127,7 +122,7 @@ class CartesiaTTS(TTSEngine[CartesiaTTSConfig]):
                 "encoding": encoding,
                 "sample_rate": self.audio_format.sample_rate,
             },
-            "context_id": self.context_id,
+            "context_id": self._active_response_id(),
         }
 
         if flush:
@@ -154,7 +149,6 @@ class CartesiaTTS(TTSEngine[CartesiaTTSConfig]):
         This tells Cartesia that all text has been sent and to finish processing.
         """
         await self._send_tts_request("", flush=True, cancel=False)
-        self.context_id = uuid4().hex  # Reset context ID for next synthesis
 
     async def signal_interrupt(self) -> None:
         """Signal TTS engine to cancel any remaining buffered text.
@@ -163,17 +157,8 @@ class CartesiaTTS(TTSEngine[CartesiaTTSConfig]):
         text should be processed.
         """
         await self._send_tts_request("", flush=False, cancel=True)
-        self.context_id = uuid4().hex  # Reset context ID for next synthesis
         structlogger.debug("cartesia.tts.cancel")
 
-    async def stop_streaming(self) -> None:
-        await super().stop_streaming()
-        if self.stream_state == self.stream_state.SENDING_RESPONSE_CHUNKS:
-            self.stream_state = self.stream_state.INTERRUPTED
-        elif self.stream_state == self.stream_state.RESPONSE_CHUNKS_SENT:
-            self.stream_state = self.stream_state.NO_STREAMING
-            await self.signal_interrupt()
-
     async def stream_audio(self) -> AsyncIterator[RasaAudioBytes]:
         """Stream audio output from the TTS engine.
 
@@ -187,6 +172,12 @@ class CartesiaTTS(TTSEngine[CartesiaTTSConfig]):
             async for msg in self.ws:
                 data = msg.json()
                 msg_type = data.get("type")
+                message_context_id = data.get("context_id")
+                if (
+                    message_context_id is not None
+                    and message_context_id != self._active_response_id()
+                ):
+                    continue
 
                 if msg_type == "chunk":
                     # Audio data chunk - decode base64 and yield
@@ -217,10 +208,10 @@ class CartesiaTTS(TTSEngine[CartesiaTTSConfig]):
         if not self.ws or self.ws.closed:
             raise TTSError("WebSocket connection not established")
 
-        await self.send_text_chunk(text)
-        await self.signal_text_done()
-
-        async for audio_chunk in self.stream_audio():
+        response = await self.start_response()
+        await response.write(text)
+        await response.finish()
+        async for audio_chunk in response:
             yield audio_chunk
 
     def engine_bytes_to_rasa_audio_bytes(self, chunk: bytes) -> RasaAudioBytes:

{rasa_pro-3.20.0.dev4 → rasa_pro-3.20.0.dev5}/rasa/core/channels/voice_stream/tts/deepgram.py

@@ -136,14 +136,6 @@ class DeepgramTTS(TTSEngine[DeepgramTTSConfig]):
             await self.ws.send_json({"type": "Clear"})
             structlogger.debug("deepgram.tts.clear")
 
-    async def stop_streaming(self) -> None:
-        await super().stop_streaming()
-        if self.stream_state == self.stream_state.SENDING_RESPONSE_CHUNKS:
-            self.stream_state = self.stream_state.INTERRUPTED
-        elif self.stream_state == self.stream_state.RESPONSE_CHUNKS_SENT:
-            self.stream_state = self.stream_state.NO_STREAMING
-            await self.signal_interrupt()
-
     async def stream_audio(self) -> AsyncIterator[RasaAudioBytes]:
         """Stream audio output from the TTS engine.
 

{rasa_pro-3.20.0.dev4 → rasa_pro-3.20.0.dev5}/rasa/core/channels/voice_stream/tts/deepgram_flux.py

@@ -181,25 +181,10 @@ class DeepgramFluxTTS(TTSEngine[DeepgramFluxTTSConfig]):
         await self._send_message({"type": "Flush"})
 
     async def signal_interrupt(self) -> None:
-        """Interrupt the active turn without playback reconciliation.
-
-        Rasa does not provide the session-wide playback offset Flux needs to split
-        spoken and remaining text. The output channel can also cancel its socket
-        reader before this acknowledgement arrives, leaving ``SpeechInterrupted``
-        for the next reader. Correcting both limitations requires channel-level
-        ownership of interruption acknowledgements.
-        """
+        """Request interruption of the active Flux turn."""
         await self._send_message({"type": "Interrupt"})
         logger.debug("deepgram_flux.tts.interrupt")
 
-    async def stop_streaming(self) -> None:
-        await super().stop_streaming()
-        if self.stream_state == self.stream_state.SENDING_RESPONSE_CHUNKS:
-            self.stream_state = self.stream_state.INTERRUPTED
-        elif self.stream_state == self.stream_state.RESPONSE_CHUNKS_SENT:
-            self.stream_state = self.stream_state.NO_STREAMING
-            await self.signal_interrupt()
-
     async def stream_audio(self) -> AsyncIterator[RasaAudioBytes]:
         if self.ws is None or self.ws.closed:
             raise TTSError("Deepgram Flux WebSocket connection is not established")
@@ -239,6 +224,8 @@ class DeepgramFluxTTS(TTSEngine[DeepgramFluxTTSConfig]):
                             code=payload.get("code"),
                             description=payload.get("description"),
                         )
+                        if payload.get("code") == "NO_AUDIO_GENERATED":
+                            return
                     continue
 
                 if message.type in {

{rasa_pro-3.20.0.dev4 → rasa_pro-3.20.0.dev5}/rasa/core/channels/voice_stream/tts/rime.py

@@ -3,7 +3,6 @@ import base64
 import os
 from typing import Any, AsyncIterator, List, Optional
 from urllib.parse import urlencode
-from uuid import uuid4
 
 import aiohttp
 import structlog
@@ -70,10 +69,6 @@ class RimeTTS(TTSEngine[RimeTTSConfig]):
     ws: Optional[aiohttp.ClientWebSocketResponse] = None
     streaming_input: bool = True
 
-    # Each synthesis context has a unique ID
-    # gets reset in signal_text_done()
-    context_id = uuid4().hex
-
     @classmethod
     def name(cls) -> str:
         """Return the name identifier for this TTS engine."""
@@ -192,7 +187,9 @@ class RimeTTS(TTSEngine[RimeTTSConfig]):
         async with self._get_engine_lock():
             if not self.ws or self.ws.closed:
                 raise TTSError("WebSocket connection not established")
-            await self.ws.send_json({"text": text, "contextId": self.context_id})
+            await self.ws.send_json(
+                {"text": text, "contextId": self._active_response_id()}
+            )
 
     async def signal_text_done(self) -> None:
         """Signal TTS engine to process any remaining buffered text.
@@ -204,7 +201,6 @@ class RimeTTS(TTSEngine[RimeTTSConfig]):
             if not self.ws or self.ws.closed:
                 raise TTSError("WebSocket connection not established")
             await self.ws.send_json({"operation": "flush"})
-            self.context_id = uuid4().hex  # Reset context ID for next synthesis
 
     async def signal_interrupt(self) -> None:
         """Clear the TTS engine buffer."""
@@ -214,14 +210,6 @@ class RimeTTS(TTSEngine[RimeTTSConfig]):
             await self.ws.send_json({"operation": "clear"})
             structlogger.debug("rime.tts.clear")
 
-    async def stop_streaming(self) -> None:
-        await super().stop_streaming()
-        if self.stream_state == self.stream_state.SENDING_RESPONSE_CHUNKS:
-            self.stream_state = self.stream_state.INTERRUPTED
-        elif self.stream_state == self.stream_state.RESPONSE_CHUNKS_SENT:
-            self.stream_state = self.stream_state.NO_STREAMING
-            await self.signal_interrupt()
-
     async def stream_audio(self) -> AsyncIterator[RasaAudioBytes]:
         """Stream audio output from the TTS engine.
 
@@ -237,6 +225,12 @@ class RimeTTS(TTSEngine[RimeTTSConfig]):
             async for msg in self.ws:
                 data = msg.json()
                 msg_type = data.get("type")
+                message_context_id = data.get("contextId")
+                if (
+                    message_context_id is not None
+                    and message_context_id != self._active_response_id()
+                ):
+                    continue
 
                 if msg_type == "chunk":
                     # Audio data chunk - decode base64 and yield
@@ -298,10 +292,10 @@ class RimeTTS(TTSEngine[RimeTTSConfig]):
         if not self.ws or self.ws.closed:
             raise TTSError("WebSocket connection not established")
 
-        await self.send_text_chunk(text)
-        await self.signal_text_done()
-
-        async for audio_chunk in self.stream_audio():
+        response = await self.start_response()
+        await response.write(text)
+        await response.finish()
+        async for audio_chunk in response:
             yield audio_chunk
 
     def engine_bytes_to_rasa_audio_bytes(self, chunk: bytes) -> RasaAudioBytes:

{rasa_pro-3.20.0.dev4 → rasa_pro-3.20.0.dev5}/rasa/core/channels/voice_stream/tts/tts_engine.py

@@ -3,6 +3,7 @@ import enum
 from types import TracebackType
 from typing import (
     AsyncIterator,
+    Awaitable,
     Dict,
     Generic,
     List,
@@ -12,6 +13,7 @@ from typing import (
     TypeVar,
     cast,
 )
+from uuid import uuid4
 
 import structlog
 from pydantic import BaseModel, ConfigDict, ValidationInfo, model_validator
@@ -236,6 +238,138 @@ class StreamState(enum.Enum):
     INTERRUPTED = "interrupted"
 
 
+class _TTSResponseState(enum.Enum):
+    OPEN = "open"
+    FINISHING = "finishing"
+    INTERRUPTING = "interrupting"
+    FINISHED = "finished"
+    INTERRUPTED = "interrupted"
+
+
+_AUDIO_STREAM_END = object()
+
+
+class TTSResponse:
+    """Represent one streaming response produced by a TTS engine.
+
+    The engine owns the provider reader for the lifetime of the response. Cancelling
+    a consumer therefore does not cancel or abandon the provider stream.
+    """
+
+    def __init__(self, engine: "TTSEngine", response_id: str) -> None:
+        self._engine = engine
+        self._response_id = response_id
+        self._state = _TTSResponseState.OPEN
+        self._audio_queue: asyncio.Queue[object] = asyncio.Queue()
+        self._finished = asyncio.Event()
+        self._reader_task: Optional[asyncio.Task[None]] = None
+        self._interrupt_task: Optional[asyncio.Task[None]] = None
+        self._error: Optional[Exception] = None
+        self._audio_consumer_active = False
+
+    @property
+    def response_id(self) -> str:
+        """Return the response identifier."""
+        return self._response_id
+
+    async def write(self, text: str) -> None:
+        """Queue a text fragment for synthesis."""
+        if self._state is not _TTSResponseState.OPEN:
+            raise TTSError("TTS response no longer accepts text")
+        await self._engine.send_text_chunk(text)
+
+    async def finish(self) -> None:
+        """Signal that all text has been written without waiting for playback."""
+        if self._state is _TTSResponseState.OPEN:
+            self._state = _TTSResponseState.FINISHING
+            await self._engine.signal_text_done()
+
+    def interrupt(self) -> Awaitable[None]:
+        """Stop synthesis and return when stale provider output is reconciled.
+
+        Interruption begins synchronously: audio delivery is disabled and an
+        engine-owned cleanup task is created before this method returns. The cleanup
+        consequently survives cancellation of the caller awaiting the result.
+        """
+        if self._finished.is_set():
+            return asyncio.create_task(self.wait_until_finished())
+
+        if self._interrupt_task is None:
+            self._state = _TTSResponseState.INTERRUPTING
+            self._discard_queued_audio()
+            self._interrupt_task = asyncio.create_task(self._run_interrupt())
+        return asyncio.shield(self._interrupt_task)
+
+    async def wait_until_finished(self) -> None:
+        """Wait until the provider stream reaches a response boundary."""
+        await self._finished.wait()
+        if self._error is not None:
+            raise self._error
+
+    def __aiter__(self) -> AsyncIterator[RasaAudioBytes]:
+        """Iterate over audio that is still eligible for delivery."""
+        return self._iterate_audio()
+
+    def _start_reader(self) -> None:
+        self._reader_task = asyncio.create_task(self._engine._read_response_audio(self))
+
+    async def _run_interrupt(self) -> None:
+        try:
+            await self._engine.signal_interrupt()
+            await asyncio.wait_for(
+                asyncio.shield(self.wait_until_finished()),
+                timeout=float(self._engine.config.timeout),
+            )
+        except asyncio.TimeoutError as error:
+            await self._engine._recover_interrupted_response(self)
+            raise TTSError("Timed out waiting for TTS interruption") from error
+        except asyncio.CancelledError:
+            raise
+        except Exception:
+            await self._engine._recover_interrupted_response(self)
+            raise
+
+    async def _iterate_audio(self) -> AsyncIterator[RasaAudioBytes]:
+        if self._audio_consumer_active:
+            raise TTSError("TTS response already has an audio consumer")
+        self._audio_consumer_active = True
+        try:
+            while True:
+                item = await self._audio_queue.get()
+                if item is _AUDIO_STREAM_END:
+                    return
+                if isinstance(item, Exception):
+                    raise item
+                if not isinstance(item, RasaAudioBytes):
+                    raise TTSError("TTS engine returned an invalid audio item")
+                yield item
+        finally:
+            self._audio_consumer_active = False
+
+    def _accept_audio(self, audio: RasaAudioBytes) -> None:
+        if self._state is not _TTSResponseState.INTERRUPTING:
+            self._audio_queue.put_nowait(audio)
+
+    def _complete(self, error: Optional[Exception] = None) -> None:
+        if self._finished.is_set():
+            return
+        self._error = error
+        if error is not None:
+            self._audio_queue.put_nowait(error)
+        self._audio_queue.put_nowait(_AUDIO_STREAM_END)
+        self._state = (
+            _TTSResponseState.INTERRUPTED
+            if self._state is _TTSResponseState.INTERRUPTING
+            else _TTSResponseState.FINISHED
+        )
+        self._finished.set()
+        self._engine._response_finished(self)
+
+    def _discard_queued_audio(self) -> None:
+        while not self._audio_queue.empty():
+            self._audio_queue.get_nowait()
+
+
 class TTSEngine(Generic[T]):
     required_env_vars: Tuple[str, ...] = ()
     required_packages: Tuple[str, ...] = ()
@@ -274,6 +408,27 @@ class TTSEngine(Generic[T]):
         # signal_interrupt) against the close+reopen in ``set_language``.
         # Lazy so it binds to the running event loop on first use.
         self._engine_lock: Optional[asyncio.Lock] = None
+        self._initialize_response_runtime()
+
+    def _initialize_response_runtime(self) -> None:
+        self._response_lock: Optional[asyncio.Lock] = None
+        self._active_response: Optional[TTSResponse] = None
+
+    def _active_response_id(self) -> str:
+        if self._active_response is None:
+            raise TTSError("No active TTS response")
+        return self._active_response.response_id
+
+    def interrupt(self) -> Awaitable[None]:
+        """Interrupt the active response and reconcile its provider stream."""
+        self.stop_streaming_output_audio_chunks = True
+        self.stream_state = StreamState.INTERRUPTED
+        if self._active_response is not None:
+            return self._active_response.interrupt()
+
+        completed: asyncio.Future[None] = asyncio.get_running_loop().create_future()
+        completed.set_result(None)
+        return completed
 
     def _get_engine_lock(self) -> asyncio.Lock:
         if self._engine_lock is None:
@@ -295,6 +450,54 @@ class TTSEngine(Generic[T]):
         """
         pass
 
+    async def start_response(
+        self, streaming_config: Optional[StreamingConfig] = None
+    ) -> TTSResponse:
+        """Start a response using the engine's streaming provider primitives.
+
+        Subclasses only need to implement ``send_text_chunk``,
+        ``signal_text_done``, ``signal_interrupt``, and ``stream_audio``. The base
+        class owns reader lifetime, interruption draining, and response isolation.
+        """
+        if self._response_lock is None:
+            self._response_lock = asyncio.Lock()
+
+        async with self._response_lock:
+            if self._active_response is not None:
+                await self._active_response.interrupt()
+
+            await self.prepare_response(streaming_config)
+            response = TTSResponse(self, uuid4().hex)
+            self._active_response = response
+            response._start_reader()
+            return response
+
+    async def _read_response_audio(self, response: TTSResponse) -> None:
+        error: Optional[Exception] = None
+        try:
+            async for audio in self.stream_audio():
+                response._accept_audio(audio)
+        except asyncio.CancelledError:
+            raise
+        except Exception as caught_error:
+            error = caught_error
+        finally:
+            response._complete(error)
+
+    async def _recover_interrupted_response(self, response: TTSResponse) -> None:
+        try:
+            await self.close_connection()
+        finally:
+            if response._reader_task is not None and not response._reader_task.done():
+                response._reader_task.cancel()
+                await asyncio.gather(response._reader_task, return_exceptions=True)
+            response._complete()
+        await self.connect()
+
+    def _response_finished(self, response: TTSResponse) -> None:
+        if response is self._active_response:
+            self._active_response = None
+
     @voice_tracing.traced_tts_connect
     async def connect(self, config: Optional[T] = None) -> None:
         """Establish connection to the TTS engine if necessary."""
@@ -433,7 +636,3 @@ class TTSEngine(Generic[T]):
             voice=entry.voice,
             model=entry.model,
         )
-
-    async def stop_streaming(self) -> None:
-        """Clear the TTS engine buffer."""
-        self.stop_streaming_output_audio_chunks = True