rasa-pro 3.11.0rc2__tar.gz → 3.11.0rc3__tar.gz

{rasa_pro-3.11.0rc2 → rasa_pro-3.11.0rc3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: rasa-pro
-Version: 3.11.0rc2
+Version: 3.11.0rc3
 Summary: State-of-the-art open-core Conversational AI framework for Enterprises that natively leverages generative AI for effortless assistant development.
 Home-page: https://rasa.com
 Keywords: nlp,machine-learning,machine-learning-library,bot,bots,botkit,rasa conversational-agents,conversational-ai,chatbot,chatbot-framework,bot-framework

{rasa_pro-3.11.0rc2 → rasa_pro-3.11.0rc3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "rasa-pro"
-version = "3.11.0rc2"
+version = "3.11.0rc3"
 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.11.0rc2 → rasa_pro-3.11.0rc3}/rasa/core/channels/development_inspector.py

@@ -187,5 +187,8 @@ class TrackerStream:
         if not self._connected_clients:
             return
         await asyncio.wait(
-            [self._send(websocket, message) for websocket in self._connected_clients]
+            [
+                asyncio.create_task(self._send(websocket, message))
+                for websocket in self._connected_clients
+            ]
         )

{rasa_pro-3.11.0rc2 → rasa_pro-3.11.0rc3}/rasa/core/channels/voice_ready/audiocodes.py

@@ -74,7 +74,7 @@ class Conversation:
     @staticmethod
     def get_metadata(activity: Dict[Text, Any]) -> Optional[Dict[Text, Any]]:
         """Get metadata from the activity."""
-        return activity.get("parameters")
+        return asdict(map_call_params(activity["parameters"]))
 
     @staticmethod
     def _handle_event(event: Dict[Text, Any]) -> Text:
@@ -88,17 +88,16 @@ class Conversation:
 
         if event["name"] == EVENT_START:
             text = f"{INTENT_MESSAGE_PREFIX}{USER_INTENT_SESSION_START}"
-            event_params = asdict(map_call_params(event["parameters"]))
         elif event["name"] == EVENT_DTMF:
             text = f"{INTENT_MESSAGE_PREFIX}vaig_event_DTMF"
             event_params = {"value": event["value"]}
+            text += json.dumps(event_params)
         else:
             structlogger.warning(
                 "audiocodes.handle.event.unknown_event", event_payload=event
             )
             return ""
 
-        text += json.dumps(event_params)
         return text
 
     def is_active_conversation(self, now: datetime, delta: timedelta) -> bool:
@@ -384,7 +383,7 @@ class AudiocodesInput(InputChannel):
             {"conversation": <conversation_id>, "reason": Optional[Text]}.
             """
             self._get_conversation(request.token, conversation_id)
-            reason = json.dumps({"reason": request.json.get("reason")})
+            reason = {"reason": request.json.get("reason")}
             await on_new_message(
                 UserMessage(
                     text=f"{INTENT_MESSAGE_PREFIX}session_end",

{rasa_pro-3.11.0rc2 → rasa_pro-3.11.0rc3}/rasa/core/channels/voice_stream/asr/asr_event.py

@@ -14,5 +14,5 @@ class NewTranscript(ASREvent):
 
 
 @dataclass
-class UserStartedSpeaking(ASREvent):
+class UserIsSpeaking(ASREvent):
     pass

{rasa_pro-3.11.0rc2 → rasa_pro-3.11.0rc3}/rasa/core/channels/voice_stream/asr/azure.py

@@ -7,7 +7,7 @@ from rasa.core.channels.voice_stream.asr.asr_engine import ASREngine, ASREngineC
 from rasa.core.channels.voice_stream.asr.asr_event import (
     ASREvent,
     NewTranscript,
-    UserStartedSpeaking,
+    UserIsSpeaking,
 )
 from rasa.core.channels.voice_stream.audio_bytes import HERTZ, RasaAudioBytes
 from rasa.shared.exceptions import ConnectionException
@@ -31,9 +31,9 @@ class AzureASR(ASREngine[AzureASRConfig]):
             asyncio.Queue()
         )
 
-    def signal_user_started_speaking(self, event: Any) -> None:
-        """Replace the unspecific azure event with a specific start event."""
-        self.fill_queue(UserStartedSpeaking())
+    def signal_user_is_speaking(self, event: Any) -> None:
+        """Replace the azure event with a generic is speaking event."""
+        self.fill_queue(UserIsSpeaking())
 
     def fill_queue(self, event: Any) -> None:
         """Either puts the event or a dedicated ASR Event into the queue."""
@@ -60,9 +60,7 @@ class AzureASR(ASREngine[AzureASRConfig]):
             audio_config=audio_config,
         )
         self.speech_recognizer.recognized.connect(self.fill_queue)
-        self.speech_recognizer.speech_start_detected.connect(
-            self.signal_user_started_speaking
-        )
+        self.speech_recognizer.recognizing.connect(self.signal_user_is_speaking)
         self.speech_recognizer.start_continuous_recognition_async()
         self.is_recognizing = True
 

{rasa_pro-3.11.0rc2 → rasa_pro-3.11.0rc3}/rasa/core/channels/voice_stream/asr/deepgram.py

@@ -10,7 +10,7 @@ from rasa.core.channels.voice_stream.asr.asr_engine import ASREngine, ASREngineC
 from rasa.core.channels.voice_stream.asr.asr_event import (
     ASREvent,
     NewTranscript,
-    UserStartedSpeaking,
+    UserIsSpeaking,
 )
 from rasa.core.channels.voice_stream.audio_bytes import HERTZ, RasaAudioBytes
 
@@ -49,7 +49,7 @@ class DeepgramASR(ASREngine[DeepgramASRConfig]):
     def _get_query_params(self) -> str:
         return (
             f"encoding=mulaw&sample_rate={HERTZ}&endpointing={self.config.endpointing}"
-            f"&vad_events=true&language={self.config.language}"
+            f"&vad_events=true&language={self.config.language}&interim_results=true"
             f"&model={self.config.model}&smart_format={str(self.config.smart_format).lower()}"
         )
 
@@ -66,16 +66,18 @@ class DeepgramASR(ASREngine[DeepgramASRConfig]):
     def engine_event_to_asr_event(self, e: Any) -> Optional[ASREvent]:
         """Translate an engine event to a common ASREvent."""
         data = json.loads(e)
-        if data.get("is_final"):
+        if "is_final" in data:
             transcript = data["channel"]["alternatives"][0]["transcript"]
-            if data.get("speech_final"):
-                full_transcript = self.accumulated_transcript + transcript
-                self.accumulated_transcript = ""
-                return NewTranscript(full_transcript)
-            else:
-                self.accumulated_transcript += transcript
-        elif data.get("type") == "SpeechStarted":
-            return UserStartedSpeaking()
+            if data["is_final"]:
+                if data.get("speech_final"):
+                    full_transcript = self.accumulated_transcript + transcript
+                    self.accumulated_transcript = ""
+                    if full_transcript:
+                        return NewTranscript(full_transcript)
+                else:
+                    self.accumulated_transcript += transcript
+            elif transcript:
+                return UserIsSpeaking()
         return None
 
     @staticmethod

{rasa_pro-3.11.0rc2 → rasa_pro-3.11.0rc3}/rasa/core/channels/voice_stream/voice_channel.py

@@ -5,10 +5,7 @@ from dataclasses import asdict, dataclass
 from typing import Any, AsyncIterator, Awaitable, Callable, Dict, List, Optional, Tuple
 
 from rasa.core.channels.voice_stream.util import generate_silence
-from rasa.shared.core.constants import (
-    SILENCE_TIMEOUT_DEFAULT_VALUE,
-    SLOT_SILENCE_TIMEOUT,
-)
+from rasa.shared.core.constants import SLOT_SILENCE_TIMEOUT
 from rasa.shared.utils.common import (
     class_from_module_path,
     mark_as_beta_feature,
@@ -24,7 +21,7 @@ from rasa.core.channels.voice_stream.asr.asr_engine import ASREngine
 from rasa.core.channels.voice_stream.asr.asr_event import (
     ASREvent,
     NewTranscript,
-    UserStartedSpeaking,
+    UserIsSpeaking,
 )
 from sanic import Websocket  # type: ignore
 
@@ -233,11 +230,18 @@ class VoiceOutputChannel(OutputChannel):
 
 
 class VoiceInputChannel(InputChannel):
-    def __init__(self, server_url: str, asr_config: Dict, tts_config: Dict):
+    def __init__(
+        self,
+        server_url: str,
+        asr_config: Dict,
+        tts_config: Dict,
+        monitor_silence: bool = False,
+    ):
         validate_voice_license_scope()
         self.server_url = server_url
         self.asr_config = asr_config
         self.tts_config = tts_config
+        self.monitor_silence = monitor_silence
         self.tts_cache = TTSCache(tts_config.get("cache_size", 1000))
 
     async def handle_silence_timeout(
@@ -247,10 +251,14 @@ class VoiceInputChannel(InputChannel):
         tts_engine: TTSEngine,
         call_parameters: CallParameters,
     ) -> None:
-        timeout = call_state.silence_timeout or SILENCE_TIMEOUT_DEFAULT_VALUE
-        logger.info("voice_channel.silence_timeout_watch_started", timeout=timeout)
+        timeout = call_state.silence_timeout
+        if not timeout:
+            return
+        if not self.monitor_silence:
+            return
+        logger.debug("voice_channel.silence_timeout_watch_started", timeout=timeout)
         await asyncio.sleep(timeout)
-        logger.info("voice_channel.silence_timeout_tripped")
+        logger.debug("voice_channel.silence_timeout_tripped")
         output_channel = self.create_output_channel(voice_websocket, tts_engine)
         message = UserMessage(
             "/silence_timeout",
@@ -261,10 +269,23 @@ class VoiceInputChannel(InputChannel):
         )
         await on_new_message(message)
 
+    @staticmethod
+    def _cancel_silence_timeout_watcher() -> None:
+        """Cancels the silent timeout task if it exists."""
+        if call_state.silence_timeout_watcher:
+            logger.debug("voice_channel.cancelling_current_timeout_watcher_task")
+            call_state.silence_timeout_watcher.cancel()
+            call_state.silence_timeout_watcher = None  # type: ignore[attr-defined]
+
     @classmethod
     def from_credentials(cls, credentials: Optional[Dict[str, Any]]) -> InputChannel:
         credentials = credentials or {}
-        return cls(credentials["server_url"], credentials["asr"], credentials["tts"])
+        return cls(
+            credentials["server_url"],
+            credentials["asr"],
+            credentials["tts"],
+            credentials.get("monitor_silence", False),
+        )
 
     def channel_bytes_to_rasa_audio_bytes(self, input_bytes: bytes) -> RasaAudioBytes:
         raise NotImplementedError
@@ -323,11 +344,14 @@ class VoiceInputChannel(InputChannel):
                 is_bot_speaking_after = call_state.is_bot_speaking
 
                 if not is_bot_speaking_before and is_bot_speaking_after:
-                    logger.info("voice_channel.bot_started_speaking")
+                    logger.debug("voice_channel.bot_started_speaking")
+                    # relevant when the bot speaks multiple messages in one turn
+                    self._cancel_silence_timeout_watcher()
 
                 # we just stopped speaking, starting a watcher for silence timeout
                 if is_bot_speaking_before and not is_bot_speaking_after:
-                    logger.info("voice_channel.bot_stopped_speaking")
+                    logger.debug("voice_channel.bot_stopped_speaking")
+                    self._cancel_silence_timeout_watcher()
                     call_state.silence_timeout_watcher = (  # type: ignore[attr-defined]
                         asyncio.create_task(
                             self.handle_silence_timeout(
@@ -354,12 +378,20 @@ class VoiceInputChannel(InputChannel):
                     call_parameters,
                 )
 
+        audio_forwarding_task = asyncio.create_task(consume_audio_bytes())
+        asr_event_task = asyncio.create_task(consume_asr_events())
         await asyncio.wait(
-            [consume_audio_bytes(), consume_asr_events()],
+            [audio_forwarding_task, asr_event_task],
             return_when=asyncio.FIRST_COMPLETED,
         )
+        if not audio_forwarding_task.done():
+            audio_forwarding_task.cancel()
+        if not asr_event_task.done():
+            asr_event_task.cancel()
         await tts_engine.close_connection()
         await asr_engine.close_connection()
+        await channel_websocket.close()
+        self._cancel_silence_timeout_watcher()
 
     def create_output_channel(
         self, voice_websocket: Websocket, tts_engine: TTSEngine
@@ -377,7 +409,7 @@ class VoiceInputChannel(InputChannel):
     ) -> None:
         """Handle a new event from the ASR system."""
         if isinstance(e, NewTranscript) and e.text:
-            logger.info(
+            logger.debug(
                 "VoiceInputChannel.handle_asr_event.new_transcript", transcript=e.text
             )
             call_state.is_user_speaking = False  # type: ignore[attr-defined]
@@ -390,8 +422,6 @@ class VoiceInputChannel(InputChannel):
                 metadata=asdict(call_parameters),
             )
             await on_new_message(message)
-        elif isinstance(e, UserStartedSpeaking):
-            if call_state.silence_timeout_watcher:
-                call_state.silence_timeout_watcher.cancel()
-                call_state.silence_timeout_watcher = None  # type: ignore[attr-defined]
+        elif isinstance(e, UserIsSpeaking):
+            self._cancel_silence_timeout_watcher()
             call_state.is_user_speaking = True  # type: ignore[attr-defined]

{rasa_pro-3.11.0rc2 → rasa_pro-3.11.0rc3}/rasa/core/nlg/contextual_response_rephraser.py

@@ -13,7 +13,7 @@ from rasa.shared.constants import (
     PROVIDER_CONFIG_KEY,
     OPENAI_PROVIDER,
     TIMEOUT_CONFIG_KEY,
-    MODEL_GROUP_CONFIG_KEY,
+    MODEL_GROUP_ID_CONFIG_KEY,
 )
 from rasa.shared.core.domain import KEY_RESPONSES_TEXT, Domain
 from rasa.shared.core.events import BotUttered, UserUttered
@@ -253,7 +253,7 @@ class ContextualResponseRephraser(
             llm_type=self.llm_property(PROVIDER_CONFIG_KEY),
             llm_model=self.llm_property(MODEL_CONFIG_KEY)
             or self.llm_property(MODEL_NAME_CONFIG_KEY),
-            llm_model_group_id=self.llm_property(MODEL_GROUP_CONFIG_KEY),
+            llm_model_group_id=self.llm_property(MODEL_GROUP_ID_CONFIG_KEY),
         )
         if not (updated_text := await self._generate_llm_response(prompt)):
             # If the LLM fails to generate a response, we

{rasa_pro-3.11.0rc2 → rasa_pro-3.11.0rc3}/rasa/core/policies/enterprise_search_policy.py

@@ -51,7 +51,7 @@ from rasa.shared.constants import (
     OPENAI_PROVIDER,
     TIMEOUT_CONFIG_KEY,
     MODEL_NAME_CONFIG_KEY,
-    MODEL_GROUP_CONFIG_KEY,
+    MODEL_GROUP_ID_CONFIG_KEY,
 )
 from rasa.shared.core.constants import (
     ACTION_CANCEL_FLOW,
@@ -337,12 +337,12 @@ class EnterpriseSearchPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Po
             embeddings_model=self.embeddings_config.get(MODEL_CONFIG_KEY)
             or self.embeddings_config.get(MODEL_NAME_CONFIG_KEY),
             embeddings_model_group_id=self.embeddings_config.get(
-                MODEL_GROUP_CONFIG_KEY
+                MODEL_GROUP_ID_CONFIG_KEY
             ),
             llm_type=self.llm_config.get(PROVIDER_CONFIG_KEY),
             llm_model=self.llm_config.get(MODEL_CONFIG_KEY)
             or self.llm_config.get(MODEL_NAME_CONFIG_KEY),
-            llm_model_group_id=self.llm_config.get(MODEL_GROUP_CONFIG_KEY),
+            llm_model_group_id=self.llm_config.get(MODEL_GROUP_ID_CONFIG_KEY),
             citation_enabled=self.citation_enabled,
         )
         self.persist()
@@ -538,12 +538,12 @@ class EnterpriseSearchPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Po
             embeddings_model=self.embeddings_config.get(MODEL_CONFIG_KEY)
             or self.embeddings_config.get(MODEL_NAME_CONFIG_KEY),
             embeddings_model_group_id=self.embeddings_config.get(
-                MODEL_GROUP_CONFIG_KEY
+                MODEL_GROUP_ID_CONFIG_KEY
             ),
             llm_type=self.llm_config.get(PROVIDER_CONFIG_KEY),
             llm_model=self.llm_config.get(MODEL_CONFIG_KEY)
             or self.llm_config.get(MODEL_NAME_CONFIG_KEY),
-            llm_model_group_id=self.llm_config.get(MODEL_GROUP_CONFIG_KEY),
+            llm_model_group_id=self.llm_config.get(MODEL_GROUP_ID_CONFIG_KEY),
             citation_enabled=self.citation_enabled,
         )
         return self._create_prediction(

{rasa_pro-3.11.0rc2 → rasa_pro-3.11.0rc3}/rasa/core/policies/intentless_policy.py

@@ -39,7 +39,7 @@ from rasa.shared.constants import (
     PROVIDER_CONFIG_KEY,
     OPENAI_PROVIDER,
     TIMEOUT_CONFIG_KEY,
-    MODEL_GROUP_CONFIG_KEY,
+    MODEL_GROUP_ID_CONFIG_KEY,
 )
 from rasa.shared.core.constants import ACTION_LISTEN_NAME
 from rasa.shared.core.constants import ACTION_TRIGGER_CHITCHAT
@@ -558,11 +558,13 @@ class IntentlessPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Policy):
             embeddings_type=self.embeddings_property(PROVIDER_CONFIG_KEY),
             embeddings_model=self.embeddings_property(MODEL_CONFIG_KEY)
             or self.embeddings_property(MODEL_NAME_CONFIG_KEY),
-            embeddings_model_group_id=self.embeddings_property(MODEL_GROUP_CONFIG_KEY),
+            embeddings_model_group_id=self.embeddings_property(
+                MODEL_GROUP_ID_CONFIG_KEY
+            ),
             llm_type=self.llm_property(PROVIDER_CONFIG_KEY),
             llm_model=self.llm_property(MODEL_CONFIG_KEY)
             or self.llm_property(MODEL_NAME_CONFIG_KEY),
-            llm_model_group_id=self.llm_property(MODEL_GROUP_CONFIG_KEY),
+            llm_model_group_id=self.llm_property(MODEL_GROUP_ID_CONFIG_KEY),
         )
 
         self.persist()
@@ -642,11 +644,13 @@ class IntentlessPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Policy):
             embeddings_type=self.embeddings_property(PROVIDER_CONFIG_KEY),
             embeddings_model=self.embeddings_property(MODEL_CONFIG_KEY)
             or self.embeddings_property(MODEL_NAME_CONFIG_KEY),
-            embeddings_model_group_id=self.embeddings_property(MODEL_GROUP_CONFIG_KEY),
+            embeddings_model_group_id=self.embeddings_property(
+                MODEL_GROUP_ID_CONFIG_KEY
+            ),
             llm_type=self.llm_property(PROVIDER_CONFIG_KEY),
             llm_model=self.llm_property(MODEL_CONFIG_KEY)
             or self.llm_property(MODEL_NAME_CONFIG_KEY),
-            llm_model_group_id=self.llm_property(MODEL_GROUP_CONFIG_KEY),
+            llm_model_group_id=self.llm_property(MODEL_GROUP_ID_CONFIG_KEY),
             score=score,
         )
 

{rasa_pro-3.11.0rc2 → rasa_pro-3.11.0rc3}/rasa/dialogue_understanding/generator/single_step/single_step_llm_command_generator.py

@@ -113,6 +113,7 @@ class SingleStepLLMCommandGenerator(LLMBasedCommandGenerator):
         )
 
         self.trace_prompt_tokens = self.config.get("trace_prompt_tokens", False)
+        self.repeat_command_enabled = self.is_repeat_command_enabled()
 
     ### Implementations of LLMBasedCommandGenerator parent
     @staticmethod
@@ -458,7 +459,7 @@ class SingleStepLLMCommandGenerator(LLMBasedCommandGenerator):
             "current_slot": current_slot,
             "current_slot_description": current_slot_description,
             "user_message": latest_user_message,
-            "is_repeat_command_enabled": self.is_repeat_command_enabled(),
+            "is_repeat_command_enabled": self.repeat_command_enabled,
         }
 
         return self.compile_template(self.prompt_template).render(**inputs)

{rasa_pro-3.11.0rc2 → rasa_pro-3.11.0rc3}/rasa/dialogue_understanding/patterns/default_flows_for_patterns.yml

@@ -111,6 +111,15 @@ slots:
     type: bool
     mappings:
       - type: from_llm
+  silence_timeout:
+    type: float
+    initial_value: 6.0
+    max_value: 1000000
+  consecutive_silence_timeouts:
+    type: float
+    initial_value: 0.0
+    max_value: 1000000
+
 
 flows:
   pattern_cancel_flow:

{rasa_pro-3.11.0rc2 → rasa_pro-3.11.0rc3}/rasa/engine/validation.py

@@ -67,11 +67,12 @@ from rasa.shared.constants import (
     ROUTER_CONFIG_KEY,
     MODELS_CONFIG_KEY,
     MODEL_GROUP_CONFIG_KEY,
-    ROUTER_STRATEGY_CONFIG_KEY,
-    VALID_ROUTER_STRATEGIES,
-    ROUTER_STRATEGIES_REQUIRING_REDIS_CACHE,
-    ROUTER_STRATEGIES_NOT_REQUIRING_CACHE,
+    ROUTING_STRATEGY_CONFIG_KEY,
+    VALID_ROUTING_STRATEGIES,
+    ROUTING_STRATEGIES_REQUIRING_REDIS_CACHE,
+    ROUTING_STRATEGIES_NOT_REQUIRING_CACHE,
     REDIS_HOST_CONFIG_KEY,
+    USE_CHAT_COMPLETIONS_ENDPOINT_CONFIG_KEY,
 )
 from rasa.shared.core.constants import ACTION_RESET_ROUTING, ACTION_TRIGGER_CHITCHAT
 from rasa.shared.core.domain import Domain
@@ -1053,31 +1054,42 @@ def _validate_model_group_router_setting(
         if ROUTER_CONFIG_KEY not in model_group:
             continue
 
+        for model_config in model_group.get(MODELS_CONFIG_KEY, []):
+            if USE_CHAT_COMPLETIONS_ENDPOINT_CONFIG_KEY in model_config:
+                print_error_and_exit(
+                    f"You defined the '{USE_CHAT_COMPLETIONS_ENDPOINT_CONFIG_KEY}' in "
+                    f"the model group '{model_group[MODEL_GROUP_ID_CONFIG_KEY]}'. This "
+                    f"key is not allowed in the model configuration as the router is "
+                    f"defined. Please remove this key from your model configuration "
+                    f"and update it in the '{ROUTER_CONFIG_KEY} configuration, as it "
+                    f"is a router level setting."
+                )
+
         router_config = model_group[ROUTER_CONFIG_KEY]
-        if ROUTER_STRATEGY_CONFIG_KEY in router_config:
-            router_strategy = router_config.get(ROUTER_STRATEGY_CONFIG_KEY)
-            if router_strategy and router_strategy not in VALID_ROUTER_STRATEGIES:
+        if ROUTING_STRATEGY_CONFIG_KEY in router_config:
+            routing_strategy = router_config.get(ROUTING_STRATEGY_CONFIG_KEY)
+            if routing_strategy and routing_strategy not in VALID_ROUTING_STRATEGIES:
                 print_error_and_exit(
-                    f"The router strategy you defined for the model group "
-                    f"'{model_group[MODEL_GROUP_ID_CONFIG_KEY]}' is not valid. "
-                    f"Valid router strategies are categorized as follows:\n"
+                    f"The routing strategy '{routing_strategy}' you defined for the "
+                    f"model group '{model_group[MODEL_GROUP_ID_CONFIG_KEY]}' is not "
+                    f"valid. Valid routing strategies are categorized as follows:\n"
                     f"- Strategies requiring Redis caching: "
-                    f"{', '.join(ROUTER_STRATEGIES_REQUIRING_REDIS_CACHE)}\n"
+                    f"{', '.join(ROUTING_STRATEGIES_REQUIRING_REDIS_CACHE)}\n"
                     f"- Strategies not requiring caching: "
-                    f"{', '.join(ROUTER_STRATEGIES_NOT_REQUIRING_CACHE)}"
+                    f"{', '.join(ROUTING_STRATEGIES_NOT_REQUIRING_CACHE)}"
                 )
             if (
-                router_strategy in ROUTER_STRATEGIES_REQUIRING_REDIS_CACHE
+                routing_strategy in ROUTING_STRATEGIES_REQUIRING_REDIS_CACHE
                 and REDIS_HOST_CONFIG_KEY not in router_config
             ):
                 structlogger.warning(
-                    "validation.router_strategy.redis_host_not_defined",
+                    "validation.routing_strategy.redis_host_not_defined",
                     event_info=(
-                        f"The router strategy '{router_strategy}' requires a Redis host"
-                        f" to be defined. Without a Redis host, the system defaults to "
-                        f"'in-memory' caching. Please add the '{REDIS_HOST_CONFIG_KEY}'"
-                        f" to the router configuration for the model group "
-                        f"'{model_group[MODEL_GROUP_ID_CONFIG_KEY]}'."
+                        f"The routing strategy '{routing_strategy}' requires a Redis "
+                        f"host to be defined. Without a Redis host, the system "
+                        f"defaults to 'in-memory' caching. Please add the "
+                        f"'{REDIS_HOST_CONFIG_KEY}' to the router configuration for "
+                        f"the model group '{model_group[MODEL_GROUP_ID_CONFIG_KEY]}'."
                     ),
                 )
 

{rasa_pro-3.11.0rc2 → rasa_pro-3.11.0rc3}/rasa/shared/constants.py

@@ -184,19 +184,19 @@ N_REPHRASES_CONFIG_KEY = "n"
 USE_CHAT_COMPLETIONS_ENDPOINT_CONFIG_KEY = "use_chat_completions_endpoint"
 
 ROUTER_CONFIG_KEY = "router"
-ROUTER_STRATEGY_CONFIG_KEY = "router_strategy"
+ROUTING_STRATEGY_CONFIG_KEY = "routing_strategy"
 REDIS_HOST_CONFIG_KEY = "redis_host"
-ROUTER_STRATEGIES_REQUIRING_REDIS_CACHE = [
+ROUTING_STRATEGIES_REQUIRING_REDIS_CACHE = [
     "cost-based-routing",
     "usage-based-routing",
 ]
-ROUTER_STRATEGIES_NOT_REQUIRING_CACHE = [
+ROUTING_STRATEGIES_NOT_REQUIRING_CACHE = [
     "latency-based-routing",
     "least-busy",
     "simple-shuffle",
 ]
-VALID_ROUTER_STRATEGIES = (
-    ROUTER_STRATEGIES_REQUIRING_REDIS_CACHE + ROUTER_STRATEGIES_NOT_REQUIRING_CACHE
+VALID_ROUTING_STRATEGIES = (
+    ROUTING_STRATEGIES_REQUIRING_REDIS_CACHE + ROUTING_STRATEGIES_NOT_REQUIRING_CACHE
 )
 
 MODELS_CONFIG_KEY = "models"

{rasa_pro-3.11.0rc2 → rasa_pro-3.11.0rc3}/rasa/shared/core/domain.py

@@ -3,7 +3,6 @@ from __future__ import annotations
 import collections
 import copy
 import json
-import math
 import os
 from dataclasses import dataclass
 from functools import cached_property
@@ -58,7 +57,6 @@ from rasa.shared.core.events import SlotSet, UserUttered
 from rasa.shared.core.slots import (
     AnySlot,
     CategoricalSlot,
-    FloatSlot,
     ListSlot,
     Slot,
     TextSlot,
@@ -1084,7 +1082,6 @@ class Domain:
         self._add_knowledge_base_slots()
         self._add_categorical_slot_default_value()
         self._add_session_metadata_slot()
-        self._add_audio_slots()
 
     def _add_categorical_slot_default_value(self) -> None:
         """Add a default value to all categorical slots.
@@ -1139,29 +1136,6 @@ class Domain:
                 )
             )
 
-    def _add_audio_slots(self) -> None:
-        """Add slots relevant for audio channels."""
-        self.slots.append(
-            FloatSlot(
-                rasa.shared.core.constants.SLOT_SILENCE_TIMEOUT,
-                mappings=[],
-                influence_conversation=False,
-                is_builtin=True,
-                initial_value=rasa.shared.core.constants.SILENCE_TIMEOUT_DEFAULT_VALUE,
-                max_value=math.inf,
-            )
-        )
-        self.slots.append(
-            FloatSlot(
-                rasa.shared.core.constants.SLOT_CONSECUTIVE_SILENCE_TIMEOUTS,
-                mappings=[],
-                influence_conversation=False,
-                is_builtin=True,
-                initial_value=0.0,
-                max_value=math.inf,
-            )
-        )
-
     def _add_knowledge_base_slots(self) -> None:
         """Add slots for the knowledge base action to slots.