rasa-pro 3.14.0.dev20250818__py3-none-any.whl → 3.14.0.dev20250825__py3-none-any.whl

rasa/core/channels/channel.py

@@ -102,6 +102,9 @@ class UserMessage:
         return f"{self.__class__.__name__}({self.text})"
 
 
+OnNewMessageType = Callable[[UserMessage], Awaitable[Any]]
+
+
 def register(
     input_channels: List[InputChannel], app: Sanic, route: Optional[Text]
 ) -> None:
@@ -135,9 +138,7 @@ class InputChannel:
     def url_prefix(self) -> Text:
         return self.name()
 
-    def blueprint(
-        self, on_new_message: Callable[[UserMessage], Awaitable[Any]]
-    ) -> Blueprint:
+    def blueprint(self, on_new_message: OnNewMessageType) -> Blueprint:
         """Defines a Sanic blueprint.
 
         The blueprint will be attached to a running sanic server and handle

rasa/core/channels/constants.py

@@ -0,0 +1,3 @@
+USER_CONVERSATION_SESSION_END = "/session_end"
+USER_CONVERSATION_SESSION_START = "/session_start"
+USER_CONVERSATION_SILENCE_TIMEOUT = "/silence_timeout"

rasa/core/channels/development_inspector.py

@@ -195,7 +195,7 @@ class DevelopmentInspectProxy(InputChannel):
         self, on_new_message: Callable[[UserMessage], Awaitable[Any]]
     ) -> "Blueprint":
         """Defines a Sanic blueprint."""
-        self.sio = AsyncServer(async_mode="sanic", cors_allowed_origins=[])
+        self.sio_server = AsyncServer(async_mode="sanic", cors_allowed_origins=[])
         underlying_webhook: Blueprint = self.underlying.blueprint(
             partial(self.on_message_proxy, on_new_message)
         )

rasa/core/channels/socketio.py

@@ -1,34 +1,54 @@
+from __future__ import annotations
+
+import asyncio
 import inspect
 import json
-import logging
 import uuid
+from asyncio import Task
+from dataclasses import dataclass
 from typing import Any, Awaitable, Callable, Dict, Iterable, List, Optional, Text
 
+import structlog
 from sanic import Blueprint, Sanic, response
 from sanic.request import Request
 from sanic.response import HTTPResponse
 from socketio import AsyncServer
 
-import rasa.core.channels.channel
 import rasa.shared.utils.io
-from rasa.core.channels.channel import InputChannel, OutputChannel, UserMessage
+from rasa.core.channels.channel import (
+    InputChannel,
+    OnNewMessageType,
+    OutputChannel,
+    UserMessage,
+)
+from rasa.core.channels.constants import USER_CONVERSATION_SILENCE_TIMEOUT
+from rasa.shared.core.constants import SILENCE_TIMEOUT_SLOT
+
+logger = structlog.getLogger(__name__)
+
 
-logger = logging.getLogger(__name__)
+@dataclass
+class SilenceTimeout:
+    sender_id: str
+    timeout: float
+
+
+UserSilenceHandlerType = Callable[[SilenceTimeout], Awaitable[Any]]
 
 
 class SocketBlueprint(Blueprint):
     """Blueprint for socketio connections."""
 
     def __init__(
-        self, sio: AsyncServer, socketio_path: Text, *args: Any, **kwargs: Any
+        self, sio_server: AsyncServer, socketio_path: Text, *args: Any, **kwargs: Any
     ) -> None:
-        """Creates a :class:`sanic.Blueprint` for routing socketio connenctions.
+        """Creates a :class:`sanic.Blueprint` for routing socketio connections.
 
-        :param sio: Instance of :class:`socketio.AsyncServer` class
+        :param sio_server: Instance of :class:`socketio.AsyncServer` class
         :param socketio_path: string indicating the route to accept requests on.
         """
         super().__init__(*args, **kwargs)
-        self.ctx.sio = sio
+        self.ctx.sio_server = sio_server
         self.ctx.socketio_path = socketio_path
 
     def register(self, app: Sanic, options: Dict[Text, Any]) -> None:
@@ -42,7 +62,7 @@ class SocketBlueprint(Blueprint):
             path = self.ctx.socketio_path
         else:
             path = options.get("url_prefix", "/socket.io")
-        self.ctx.sio.attach(app, path)
+        self.ctx.sio_server.attach(app, path)
         super().register(app, options)
 
 
@@ -51,14 +71,45 @@ class SocketIOOutput(OutputChannel):
     def name(cls) -> Text:
         return "socketio"
 
-    def __init__(self, sio: AsyncServer, bot_message_evt: Text) -> None:
+    def __init__(
+        self,
+        input_channel: SocketIOInput,
+        sio_server: AsyncServer,
+        bot_message_evt: Text,
+    ) -> None:
         super().__init__()
-        self.sio = sio
+        self._input_channel = input_channel
+        self.sio_server = sio_server
         self.bot_message_evt = bot_message_evt
 
     async def _send_message(self, socket_id: Text, response: Any) -> None:
         """Sends a message to the recipient using the bot event."""
-        await self.sio.emit(self.bot_message_evt, response, room=socket_id)
+        await self.sio_server.emit(self.bot_message_evt, response, room=socket_id)
+        if self.tracker_state and self._input_channel.enable_silence_timeout:
+            silence_timeout = self.tracker_state["slots"][SILENCE_TIMEOUT_SLOT]
+
+            logger.debug(
+                "socketio_channel.silence_timeout_updated",
+                sender_id=socket_id,
+                silence_timeout=silence_timeout,
+            )
+
+            silence_timeout_counts = self.tracker_state["slots"][
+                "consecutive_silence_timeouts"
+            ]
+
+            logger.debug(
+                "socketio_channel.consecutive_silence_timeouts_updated",
+                sender_id=socket_id,
+                silence_timeout_counts=silence_timeout_counts,
+            )
+
+            self._input_channel.reset_silence_timeout(
+                SilenceTimeout(
+                    sender_id=socket_id,
+                    timeout=silence_timeout,
+                ),
+            )
 
     async def send_text_message(
         self, recipient_id: Text, text: Text, **kwargs: Any
@@ -123,9 +174,11 @@ class SocketIOOutput(OutputChannel):
         """Sends custom json to the output."""
         if "data" in json_message:
             json_message.setdefault("room", recipient_id)
-            await self.sio.emit(self.bot_message_evt, **json_message)
+            await self.sio_server.emit(self.bot_message_evt, **json_message)
         else:
-            await self.sio.emit(self.bot_message_evt, json_message, room=recipient_id)
+            await self.sio_server.emit(
+                self.bot_message_evt, json_message, room=recipient_id
+            )
 
     async def send_attachment(  # type: ignore[override]
         self, recipient_id: Text, attachment: Dict[Text, Any], **kwargs: Any
@@ -133,26 +186,38 @@ class SocketIOOutput(OutputChannel):
         """Sends an attachment to the user."""
         await self._send_message(recipient_id, {"attachment": attachment})
 
+    async def hangup(self, recipient_id: Text, **kwargs: Any) -> None:
+        """Hangs up the call for the given sender."""
+        # This method is not applicable for socket.io, but we implement it
+        # to satisfy the OutputChannel interface.
+        logger.debug(
+            "socketio_channel.output.hangup",
+            message=f"Hanging up call for user {recipient_id}.",
+        )
+
+        self._input_channel.disconnect(recipient_id)
+
 
 class SocketIOInput(InputChannel):
     """A socket.io input channel."""
 
     @classmethod
-    def name(cls) -> Text:
+    def name(cls) -> str:
         return "socketio"
 
     @classmethod
     def from_credentials(cls, credentials: Optional[Dict[Text, Any]]) -> InputChannel:
         credentials = credentials or {}
         return cls(
-            credentials.get("user_message_evt", "user_uttered"),
-            credentials.get("bot_message_evt", "bot_uttered"),
-            credentials.get("namespace"),
-            credentials.get("session_persistence", False),
-            credentials.get("socketio_path", "/socket.io"),
-            credentials.get("jwt_key"),
-            credentials.get("jwt_method", "HS256"),
-            credentials.get("metadata_key", "metadata"),
+            user_message_evt=credentials.get("user_message_evt", "user_uttered"),
+            bot_message_evt=credentials.get("bot_message_evt", "bot_uttered"),
+            namespace=credentials.get("namespace"),
+            session_persistence=credentials.get("session_persistence", False),
+            socketio_path=credentials.get("socketio_path", "/socket.io"),
+            jwt_key=credentials.get("jwt_key"),
+            jwt_method=credentials.get("jwt_method", "HS256"),
+            metadata_key=credentials.get("metadata_key", "metadata"),
+            enable_silence_timeout=credentials.get("enable_silence_timeout", False),
         )
 
     def __init__(
@@ -165,6 +230,7 @@ class SocketIOInput(InputChannel):
         jwt_key: Optional[Text] = None,
         jwt_method: Optional[Text] = "HS256",
         metadata_key: Optional[Text] = "metadata",
+        enable_silence_timeout: bool = False,
     ):
         """Creates a ``SocketIOInput`` object."""
         self.bot_message_evt = bot_message_evt
@@ -172,15 +238,18 @@ class SocketIOInput(InputChannel):
         self.user_message_evt = user_message_evt
         self.namespace = namespace
         self.socketio_path = socketio_path
-        self.sio: Optional[AsyncServer] = None
+        self.sio_server: Optional[AsyncServer] = None
         self.metadata_key = metadata_key
+        self.enable_silence_timeout = enable_silence_timeout
 
         self.jwt_key = jwt_key
         self.jwt_algorithm = jwt_method
+        self.on_new_message: Optional[OnNewMessageType] = None
+        self.sender_silence_map: Dict[str, Task] = {}
 
-    def get_output_channel(self) -> Optional["OutputChannel"]:
+    def get_output_channel(self) -> Optional[OutputChannel]:
         """Creates socket.io output channel object."""
-        if self.sio is None:
+        if self.sio_server is None:
             rasa.shared.utils.io.raise_warning(
                 "SocketIO output channel cannot be recreated. "
                 "This is expected behavior when using multiple Sanic "
@@ -189,7 +258,7 @@ class SocketIOInput(InputChannel):
                 "scenarios."
             )
             return None
-        return SocketIOOutput(self.sio, self.bot_message_evt)
+        return SocketIOOutput(self, self.sio_server, self.bot_message_evt)
 
     async def handle_session_request(
         self, sid: Text, data: Optional[Dict] = None
@@ -200,23 +269,26 @@ class SocketIOInput(InputChannel):
         if "session_id" not in data or data["session_id"] is None:
             data["session_id"] = uuid.uuid4().hex
         if self.session_persistence:
-            if inspect.iscoroutinefunction(self.sio.enter_room):  # type: ignore[union-attr]
-                await self.sio.enter_room(sid, data["session_id"])  # type: ignore[union-attr]
+            if inspect.iscoroutinefunction(self.sio_server.enter_room):  # type: ignore[union-attr]
+                await self.sio_server.enter_room(sid, data["session_id"])  # type: ignore[union-attr]
             else:
                 # for backwards compatibility with python-socketio < 5.10.
                 # previously, this function was NOT async.
-                self.sio.enter_room(sid, data["session_id"])  # type: ignore[union-attr]
-        await self.sio.emit("session_confirm", data["session_id"], room=sid)  # type: ignore[union-attr]
-        logger.debug(f"User {sid} connected to socketIO endpoint.")
+                self.sio_server.enter_room(sid, data["session_id"])  # type: ignore[union-attr]
+        await self.sio_server.emit("session_confirm", data["session_id"], room=sid)  # type: ignore[union-attr]
+        logger.debug(
+            "socketio_channel.input.handle_session_request",
+            message=f"User {sid} connected to socketIO endpoint.",
+        )
 
     async def handle_user_message(
         self,
         sid: Text,
         data: Dict,
-        on_new_message: Callable[[UserMessage], Awaitable[Any]],
+        on_new_message: OnNewMessageType,
     ) -> None:
         """Handles user messages received from the client."""
-        output_channel = SocketIOOutput(self.sio, self.bot_message_evt)
+        output_channel = self.get_output_channel()
 
         if self.session_persistence:
             if not data.get("session_id"):
@@ -232,38 +304,44 @@ class SocketIOInput(InputChannel):
         else:
             sender_id = sid
 
+        # We cancel silence timeout when a new message is received
+        # to prevent sending a silence timeout message
+        # if the user sends a message after the silence timeout
+        self._cancel_silence_timeout(sender_id)
+
         metadata = data.get(self.metadata_key, {})
         if isinstance(metadata, Text):
             metadata = json.loads(metadata)
 
         message = UserMessage(
-            data.get("message", ""),
-            output_channel,
-            sender_id,
+            text=data.get("message", ""),
+            output_channel=output_channel,
+            sender_id=sender_id,
             input_channel=self.name(),
             metadata=metadata,
         )
         await on_new_message(message)
 
-    def blueprint(
-        self, on_new_message: Callable[[UserMessage], Awaitable[Any]]
-    ) -> SocketBlueprint:
+    def blueprint(self, on_new_message: OnNewMessageType) -> SocketBlueprint:
         """Defines a Sanic blueprint."""
         # Workaround so that socketio works with requests from other origins.
         # https://github.com/miguelgrinberg/python-socketio/issues/205#issuecomment-493769183
-        sio = AsyncServer(async_mode="sanic", cors_allowed_origins=[])
+        sio_server = AsyncServer(async_mode="sanic", cors_allowed_origins=[])
         socketio_webhook = SocketBlueprint(
-            sio, self.socketio_path, "socketio_webhook", __name__
+            sio_server, self.socketio_path, "socketio_webhook", __name__
         )
 
-        # make sio object static to use in get_output_channel
-        self.sio = sio
+        # make sio_server object static to use in get_output_channel
+        self.sio_server = sio_server
+        # We need to store the on_new_message callback
+        # so that we can call it when a silence timeout occurs
+        self.on_new_message = on_new_message
 
         @socketio_webhook.route("/", methods=["GET"])
         async def health(_: Request) -> HTTPResponse:
             return response.json({"status": "ok"})
 
-        @sio.on("connect", namespace=self.namespace)
+        @sio_server.on("connect", namespace=self.namespace)
         async def connect(sid: Text, environ: Dict, auth: Optional[Dict]) -> bool:
             if self.jwt_key:
                 jwt_payload = None
@@ -273,24 +351,107 @@ class SocketIOInput(InputChannel):
                     )
 
                 if jwt_payload:
-                    logger.debug(f"User {sid} connected to socketIO endpoint.")
+                    logger.debug(
+                        "socketio_channel.input.connect.jwt",
+                        message=f"User {sid} connected to socketIO endpoint.",
+                    )
+                    # Store the chat state for this user
                     return True
                 else:
                     return False
             else:
-                logger.debug(f"User {sid} connected to socketIO endpoint.")
+                logger.debug(
+                    "socketio_channel.input.connect",
+                    message=f"User {sid} connected to socketIO endpoint.",
+                )
+                # Store the chat state for this user
                 return True
 
-        @sio.on("disconnect", namespace=self.namespace)
+        @sio_server.on("disconnect", namespace=self.namespace)
         async def disconnect(sid: Text) -> None:
-            logger.debug(f"User {sid} disconnected from socketIO endpoint.")
+            logger.debug(
+                "socketio_channel.input.disconnect",
+                message=f"User {sid} disconnected from socketIO endpoint.",
+            )
 
-        @sio.on("session_request", namespace=self.namespace)
+        @sio_server.on("session_request", namespace=self.namespace)
         async def session_request(sid: Text, data: Optional[Dict]) -> None:
+            logger.debug(
+                "socketio_channel.input.session_request",
+                message=f"User {sid} requested a session.",
+            )
             await self.handle_session_request(sid, data)
 
-        @sio.on(self.user_message_evt, namespace=self.namespace)
+        @sio_server.on(self.user_message_evt, namespace=self.namespace)
         async def handle_message(sid: Text, data: Dict) -> None:
+            logger.debug(
+                "socketio_channel.input.handle_message",
+                message=f"User {sid} sent a message.",
+                data=data,
+            )
             await self.handle_user_message(sid, data, on_new_message)
 
         return socketio_webhook
+
+    def reset_silence_timeout(self, silence_timeout: SilenceTimeout) -> None:
+        self._cancel_silence_timeout(silence_timeout.sender_id)
+
+        self.sender_silence_map[silence_timeout.sender_id] = (
+            asyncio.get_event_loop().create_task(
+                self._monitor_silence_timeout(
+                    silence_timeout,
+                )
+            )
+        )
+
+    def disconnect(self, sender_id: str) -> None:
+        """Disconnects the user with the given sender ID."""
+        self._cancel_silence_timeout(sender_id)
+        if self.sio_server:
+            asyncio.get_event_loop().create_task(self.sio_server.disconnect(sender_id))
+            logger.debug(
+                "socketio_channel.input.disconnect",
+                message=f"User {sender_id} disconnected from socketIO endpoint.",
+            )
+
+    async def _monitor_silence_timeout(self, silence_timeout: SilenceTimeout) -> None:
+        logger.debug(
+            "socketio_channel.input.silence_timeout_watch_started",
+            sender_id=silence_timeout.sender_id,
+            timeout=silence_timeout.timeout,
+        )
+        await asyncio.sleep(silence_timeout.timeout)
+
+        # once the timer is up, we call the handler
+        # to notify the user about the silence timeout
+        # this is important if monitoring trask is cancelled while handler is executed
+        asyncio.get_event_loop().create_task(
+            self._handle_silence_timeout(silence_timeout)
+        )
+
+        logger.debug(
+            "socketio_channel.input.silence_timeout_tripped",
+            sender_id=silence_timeout.sender_id,
+            silence_timeout=silence_timeout.timeout,
+        )
+
+    async def _handle_silence_timeout(self, event: SilenceTimeout) -> None:
+        if self.on_new_message:
+            output_channel = self.get_output_channel()
+            message = UserMessage(
+                text=USER_CONVERSATION_SILENCE_TIMEOUT,
+                output_channel=output_channel,
+                sender_id=event.sender_id,
+                input_channel=self.name(),
+            )
+            await self.on_new_message(message)
+
+    def _cancel_silence_timeout(self, sender_id: str) -> None:
+        """Cancels the silence timeout task for the given sender."""
+        task = self.sender_silence_map.pop(sender_id, None)
+        if task and not task.done():
+            logger.debug(
+                "socketio_channel.input.silence_timeout_cancelled",
+                sender_id=sender_id,
+            )
+            task.cancel()

rasa/core/channels/studio_chat.py

@@ -47,7 +47,6 @@ if TYPE_CHECKING:
     from sanic import Sanic, Websocket  # type: ignore[attr-defined]
     from socketio import AsyncServer
 
-    from rasa.core.channels.channel import UserMessage
     from rasa.shared.core.trackers import DialogueStateTracker
 
 
@@ -153,6 +152,7 @@ class StudioChatInput(SocketIOInput, VoiceInputChannel):
         jwt_key: Optional[Text] = None,
         jwt_method: Optional[Text] = "HS256",
         metadata_key: Optional[Text] = "metadata",
+        enable_silence_timeout: bool = False,
     ) -> None:
         """Creates a `StudioChatInput` object."""
         from rasa.core.agent import Agent
@@ -170,6 +170,7 @@ class StudioChatInput(SocketIOInput, VoiceInputChannel):
             jwt_key=jwt_key,
             jwt_method=jwt_method,
             metadata_key=metadata_key,
+            enable_silence_timeout=enable_silence_timeout,
         )
 
         # Initialize the Voice Input Channel
@@ -210,14 +211,15 @@ class StudioChatInput(SocketIOInput, VoiceInputChannel):
             jwt_key=credentials.get("jwt_key"),
             jwt_method=credentials.get("jwt_method", "HS256"),
             metadata_key=credentials.get("metadata_key", "metadata"),
+            enable_silence_timeout=credentials.get("enable_silence_timeout", False),
         )
 
     async def emit(self, event: str, data: str, room: str) -> None:
         """Emits an event to the websocket."""
-        if not self.sio:
+        if not self.sio_server:
             structlogger.error("studio_chat.emit.sio_not_initialized")
             return
-        await self.sio.emit(event, data, room=room)
+        await self.sio_server.emit(event, data, room=room)
 
     def _register_tracker_update_hook(self) -> None:
         plugin_manager().register(StudioTrackerUpdatePlugin(self))
@@ -250,8 +252,8 @@ class StudioChatInput(SocketIOInput, VoiceInputChannel):
 
     async def on_message_proxy(
         self,
-        on_new_message: Callable[["UserMessage"], Awaitable[Any]],
-        message: "UserMessage",
+        on_new_message: Callable[[UserMessage], Awaitable[Any]],
+        message: UserMessage,
     ) -> None:
         """Proxies the on_new_message call to the underlying channel.
 
@@ -377,7 +379,7 @@ class StudioChatInput(SocketIOInput, VoiceInputChannel):
                 call_state.is_bot_speaking = True
         return ContinueConversationAction()
 
-    def create_output_channel(
+    def _create_output_channel(
         self, voice_websocket: "Websocket", tts_engine: TTSEngine
     ) -> VoiceOutputChannel:
         """Create a voice output channel."""
@@ -407,7 +409,7 @@ class StudioChatInput(SocketIOInput, VoiceInputChannel):
 
         # Create a websocket adapter for this connection
         ws_adapter = SocketIOVoiceWebsocketAdapter(
-            sio=self.sio,
+            sio_server=self.sio_server,
             session_id=session_id,
             sid=sid,
             bot_message_evt=self.bot_message_evt,
@@ -455,12 +457,12 @@ class StudioChatInput(SocketIOInput, VoiceInputChannel):
             task.cancel()
 
     def blueprint(
-        self, on_new_message: Callable[["UserMessage"], Awaitable[Any]]
+        self, on_new_message: Callable[[UserMessage], Awaitable[Any]]
     ) -> SocketBlueprint:
         proxied_on_message = partial(self.on_message_proxy, on_new_message)
         socket_blueprint = super().blueprint(proxied_on_message)
 
-        if not self.sio:
+        if not self.sio_server:
             structlogger.error("studio_chat.blueprint.sio_not_initialized")
             return socket_blueprint
 
@@ -470,12 +472,12 @@ class StudioChatInput(SocketIOInput, VoiceInputChannel):
         ) -> None:
             self.agent = app.ctx.agent
 
-        @self.sio.on("disconnect", namespace=self.namespace)
+        @self.sio_server.on("disconnect", namespace=self.namespace)
         async def disconnect(sid: Text) -> None:
             structlogger.debug("studio_chat.sio.disconnect", sid=sid)
             self._cleanup_tasks_for_sid(sid)
 
-        @self.sio.on("session_request", namespace=self.namespace)
+        @self.sio_server.on("session_request", namespace=self.namespace)
         async def session_request(sid: Text, data: Optional[Dict]) -> None:
             """Overrides the base SocketIOInput session_request handler.
 
@@ -495,7 +497,7 @@ class StudioChatInput(SocketIOInput, VoiceInputChannel):
             if data and data.get("is_voice", False):
                 self._start_voice_session(data["session_id"], sid, proxied_on_message)
 
-        @self.sio.on(self.user_message_evt, namespace=self.namespace)
+        @self.sio_server.on(self.user_message_evt, namespace=self.namespace)
         async def handle_message(sid: Text, data: Dict) -> None:
             """Overrides the base SocketIOInput handle_message handler."""
             # Handle voice messages
@@ -509,7 +511,7 @@ class StudioChatInput(SocketIOInput, VoiceInputChannel):
             # Handle text messages
             await self.handle_user_message(sid, data, proxied_on_message)
 
-        @self.sio.on("update_tracker", namespace=self.namespace)
+        @self.sio_server.on("update_tracker", namespace=self.namespace)
         async def on_update_tracker(sid: Text, data: Dict) -> None:
             await self.handle_tracker_update(sid, data)
 
@@ -555,9 +557,9 @@ class SocketIOVoiceWebsocketAdapter:
     """Adapter to make Socket.IO work like a Sanic WebSocket for voice channels."""
 
     def __init__(
-        self, sio: "AsyncServer", session_id: str, sid: str, bot_message_evt: str
+        self, sio_server: "AsyncServer", session_id: str, sid: str, bot_message_evt: str
     ) -> None:
-        self.sio = sio
+        self.sio_server = sio_server
         self.bot_message_evt = bot_message_evt
         self._closed = False
         self._receive_queue: asyncio.Queue[Any] = asyncio.Queue()
@@ -576,7 +578,7 @@ class SocketIOVoiceWebsocketAdapter:
     async def send(self, data: Any) -> None:
         """Send data to the client."""
         if not self.closed:
-            await self.sio.emit(self.bot_message_evt, data, room=self.sid)
+            await self.sio_server.emit(self.bot_message_evt, data, room=self.sid)
 
     async def recv(self) -> Any:
         """Receive data from the client."""

rasa/core/channels/voice_stream/voice_channel.py

@@ -11,6 +11,11 @@ from sanic import Websocket  # type: ignore
 from sanic.exceptions import ServerError, WebsocketClosed
 
 from rasa.core.channels import InputChannel, OutputChannel, UserMessage
+from rasa.core.channels.constants import (
+    USER_CONVERSATION_SESSION_END,
+    USER_CONVERSATION_SESSION_START,
+    USER_CONVERSATION_SILENCE_TIMEOUT,
+)
 from rasa.core.channels.voice_ready.utils import (
     CallParameters,
     validate_voice_license_scope,
@@ -48,9 +53,6 @@ from rasa.utils.io import remove_emojis
 logger = structlog.get_logger(__name__)
 
 # define constants for the voice channel
-USER_CONVERSATION_SESSION_END = "/session_end"
-USER_CONVERSATION_SESSION_START = "/session_start"
-USER_CONVERSATION_SILENCE_TIMEOUT = "/silence_timeout"
 
 
 @dataclass

rasa/core/run.py

@@ -42,10 +42,20 @@ from rasa.utils import licensing
 logger = logging.getLogger()  # get the root logger
 
 
-def create_http_input_channels(
+def create_input_channels(
     channel: Optional[Text], credentials_file: Optional[Text]
 ) -> List[InputChannel]:
-    """Instantiate the chosen input channel."""
+    """Instantiate the chosen input channel.
+
+    Args:
+        channel (optional): The name of the specific input channel to create.
+        credentials_file: Path to the credentials file containing channel credentials.
+
+    Returns:
+        A list of instantiated input channels. If a specific channel is provided,
+        it returns a list with that single channel. If no channel is specified,
+        it returns a list of all channels defined in the credentials file.
+    """
     if credentials_file:
         all_credentials = read_config_file(credentials_file)
     else:
@@ -253,7 +263,7 @@ def serve_application(
     if not channel and not credentials:
         channel = "cmdline"
 
-    input_channels = create_http_input_channels(channel, credentials)
+    input_channels = create_input_channels(channel, credentials)
 
     if inspect:
         logger.info("Starting development inspector.")

rasa/dialogue_understanding/patterns/default_flows_for_patterns.yml

@@ -81,7 +81,7 @@ responses:
         rephrase: True
 
   utter_inform_hangup:
-    - text: It seems you are not there anymore. I will hang up shortly.
+    - text: I haven’t heard from you, so I’ll end our conversation shortly.
       metadata:
         rephrase: True
 

rasa/model_manager/model_api.py

@@ -571,10 +571,10 @@ def external_blueprint() -> Blueprint:
     """Create a blueprint for the model manager API."""
     from rasa.core.channels.socketio import SocketBlueprint
 
-    sio = AsyncServer(async_mode="sanic", cors_allowed_origins="*")
-    bp = SocketBlueprint(sio, "", "model_api_external")
+    sio_server = AsyncServer(async_mode="sanic", cors_allowed_origins="*")
+    bp = SocketBlueprint(sio_server, "", "model_api_external")
 
-    create_bridge_server(sio, running_bots)
+    create_bridge_server(sio_server, running_bots)
 
     @bp.get("/health")
     async def health(request: Request) -> response.HTTPResponse:

rasa/model_manager/socket_bridge.py

@@ -19,7 +19,7 @@ socket_proxy_clients = {}
 
 
 async def socketio_websocket_traffic_wrapper(
-    sio: AsyncServer,
+    sio_server: AsyncServer,
     running_bots: Dict[str, BotSession],
     sid: str,
     auth: Optional[Dict],
@@ -55,7 +55,9 @@ async def socketio_websocket_traffic_wrapper(
         structlogger.error("model_runner.bot_not_alive", deployment_id=deployment_id)
         raise ConnectionRefusedError("model_runner.bot_not_alive")
 
-    client = await create_bridge_client(sio, bot.internal_url, sid, deployment_id)
+    client = await create_bridge_client(
+        sio_server, bot.internal_url, sid, deployment_id
+    )
 
     if client.sid is not None:
         structlogger.debug(
@@ -70,20 +72,24 @@ async def socketio_websocket_traffic_wrapper(
         raise ConnectionRefusedError("model_runner.bot_connection_failed")
 
 
-def create_bridge_server(sio: AsyncServer, running_bots: Dict[str, BotSession]) -> None:
+def create_bridge_server(
+    sio_server: AsyncServer, running_bots: Dict[str, BotSession]
+) -> None:
     """Create handlers for the socket server side.
 
     Forwards messages coming from the user to the bot.
     """
 
-    @sio.on("connect")
+    @sio_server.on("connect")
     async def socketio_websocket_traffic(
         sid: str, environ: Dict, auth: Optional[Dict]
     ) -> bool:
         """Bridge websockets between user chat socket and bot server."""
-        return await socketio_websocket_traffic_wrapper(sio, running_bots, sid, auth)
+        return await socketio_websocket_traffic_wrapper(
+            sio_server, running_bots, sid, auth
+        )
 
-    @sio.on("disconnect")
+    @sio_server.on("disconnect")
     async def disconnect(sid: str) -> None:
         """Disconnect the bot connection."""
         structlogger.debug("model_runner.bot_disconnect", sid=sid)
@@ -91,7 +97,7 @@ def create_bridge_server(sio: AsyncServer, running_bots: Dict[str, BotSession])
             await socket_proxy_clients[sid].disconnect()
             del socket_proxy_clients[sid]
 
-    @sio.on("*")
+    @sio_server.on("*")
     async def handle_message(event: str, sid: str, data: Dict[str, Any]) -> None:
         """Bridge messages between user and bot.
 
@@ -108,7 +114,7 @@ def create_bridge_server(sio: AsyncServer, running_bots: Dict[str, BotSession])
 
 
 async def create_bridge_client(
-    sio: AsyncServer, url: str, sid: str, deployment_id: str
+    sio_server: AsyncServer, url: str, sid: str, deployment_id: str
 ) -> AsyncClient:
     """Create a new socket bridge client.
 
@@ -123,36 +129,36 @@ async def create_bridge_client(
         structlogger.debug(
             "model_runner.bot_session_confirmed", deployment_id=deployment_id
         )
-        await sio.emit("session_confirm", room=sid)
+        await sio_server.emit("session_confirm", room=sid)
 
     @client.event  # type: ignore[misc]
     async def bot_message(data: Dict[str, Any]) -> None:
         structlogger.debug("model_runner.bot_message", deployment_id=deployment_id)
-        await sio.emit("bot_message", data, room=sid)
+        await sio_server.emit("bot_message", data, room=sid)
 
     @client.event  # type: ignore[misc]
     async def error(data: Dict[str, Any]) -> None:
         structlogger.debug(
             "model_runner.bot_error", deployment_id=deployment_id, data=data
         )
-        await sio.emit("error", data, room=sid)
+        await sio_server.emit("error", data, room=sid)
 
     @client.event  # type: ignore[misc]
     async def tracker(data: Dict[str, Any]) -> None:
-        await sio.emit("tracker", json.loads(data), room=sid)
+        await sio_server.emit("tracker", json.loads(data), room=sid)
 
     @client.event  # type: ignore[misc]
     async def disconnect() -> None:
         structlogger.debug(
             "model_runner.bot_connection_closed", deployment_id=deployment_id
         )
-        await sio.emit("disconnect", room=sid)
+        await sio_server.emit("disconnect", room=sid)
 
     @client.event  # type: ignore[misc]
     async def connect_error() -> None:
         structlogger.error(
             "model_runner.bot_connection_error", deployment_id=deployment_id
         )
-        await sio.emit("disconnect", room=sid)
+        await sio_server.emit("disconnect", room=sid)
 
     return client

rasa/shared/providers/_utils.py

@@ -1,87 +1,103 @@
 from typing import Any, Dict, Optional
 
+import boto3
 import structlog
-from litellm import validate_environment
+from botocore.exceptions import BotoCoreError, ClientError
 
 from rasa.shared.constants import (
     API_BASE_CONFIG_KEY,
     API_VERSION_CONFIG_KEY,
     AWS_ACCESS_KEY_ID_CONFIG_KEY,
-    AWS_ACCESS_KEY_ID_ENV_VAR,
+    AWS_BEDROCK_PROVIDER,
     AWS_REGION_NAME_CONFIG_KEY,
-    AWS_REGION_NAME_ENV_VAR,
+    AWS_SAGEMAKER_CHAT_PROVIDER,
+    AWS_SAGEMAKER_PROVIDER,
     AWS_SECRET_ACCESS_KEY_CONFIG_KEY,
-    AWS_SECRET_ACCESS_KEY_ENV_VAR,
     AWS_SESSION_TOKEN_CONFIG_KEY,
-    AWS_SESSION_TOKEN_ENV_VAR,
     AZURE_API_BASE_ENV_VAR,
     AZURE_API_VERSION_ENV_VAR,
     DEPLOYMENT_CONFIG_KEY,
 )
 from rasa.shared.exceptions import ProviderClientValidationError
-from rasa.shared.providers.embedding._base_litellm_embedding_client import (
-    _VALIDATE_ENVIRONMENT_MISSING_KEYS_KEY,
-)
+from rasa.shared.utils.io import resolve_environment_variables
 
 structlogger = structlog.get_logger()
 
 
 def validate_aws_setup_for_litellm_clients(
-    litellm_model_name: str, litellm_call_kwargs: dict, source_log: str
+    litellm_model_name: str, litellm_call_kwargs: Dict, source_log: str, provider: str
 ) -> None:
-    """Validates the AWS setup for LiteLLM clients to ensure all required
-    environment variables or corresponding call kwargs are set.
+    """Validates the AWS setup for LiteLLM clients to ensure credentials are set.
 
     Args:
         litellm_model_name (str): The name of the LiteLLM model being validated.
         litellm_call_kwargs (dict): Additional keyword arguments passed to the client,
             which may include configuration values for AWS credentials.
         source_log (str): The source log identifier for structured logging.
+        provider (str): The provider for which the validation is being performed.
 
     Raises:
         ProviderClientValidationError: If any required AWS environment variable
             or corresponding configuration key is missing.
     """
-
-    # Mapping of environment variable names to their corresponding config keys
-    envs_to_args = {
-        AWS_ACCESS_KEY_ID_ENV_VAR: AWS_ACCESS_KEY_ID_CONFIG_KEY,
-        AWS_SECRET_ACCESS_KEY_ENV_VAR: AWS_SECRET_ACCESS_KEY_CONFIG_KEY,
-        AWS_REGION_NAME_ENV_VAR: AWS_REGION_NAME_CONFIG_KEY,
-        AWS_SESSION_TOKEN_ENV_VAR: AWS_SESSION_TOKEN_CONFIG_KEY,
-    }
-
-    # Validate the environment setup for the model
-    validation_info = validate_environment(litellm_model_name)
-    missing_environment_variables = validation_info.get(
-        _VALIDATE_ENVIRONMENT_MISSING_KEYS_KEY, []
+    # expand environment variables if referenced in the config
+    resolved_litellm_call_kwargs: Dict = resolve_environment_variables(
+        litellm_call_kwargs
+    )  # type: ignore[assignment]
+
+    # boto3 only accepts bedrock and sagemaker as valid clients
+    # therefore we need to convert the provider name if it is defined
+    # as sagemaker_chat
+    provider = (
+        AWS_SAGEMAKER_PROVIDER if provider == AWS_SAGEMAKER_CHAT_PROVIDER else provider
     )
-    # Filter out missing environment variables that have been set trough arguments
-    # in extra parameters
-    missing_environment_variables = [
-        missing_env_var
-        for missing_env_var in missing_environment_variables
-        if litellm_call_kwargs.get(envs_to_args.get(missing_env_var)) is None
-    ]
 
-    if missing_environment_variables:
-        missing_environment_details = [
-            (
-                f"'{missing_env_var}' environment variable or "
-                f"'{envs_to_args.get(missing_env_var)}' config key"
-            )
-            for missing_env_var in missing_environment_variables
+    # if the AWS credentials are defined in the endpoints yaml model config,
+    # either as referenced secret env vars or direct values, we need to pass them
+    # to the boto3 client to ensure that the client can connect to the AWS service.
+    additional_kwargs: Dict[str, Any] = {}
+    if AWS_ACCESS_KEY_ID_CONFIG_KEY in resolved_litellm_call_kwargs:
+        additional_kwargs[AWS_ACCESS_KEY_ID_CONFIG_KEY] = resolved_litellm_call_kwargs[
+            AWS_ACCESS_KEY_ID_CONFIG_KEY
         ]
+    if AWS_SECRET_ACCESS_KEY_CONFIG_KEY in resolved_litellm_call_kwargs:
+        additional_kwargs[AWS_SECRET_ACCESS_KEY_CONFIG_KEY] = (
+            resolved_litellm_call_kwargs[AWS_SECRET_ACCESS_KEY_CONFIG_KEY]
+        )
+    if AWS_SESSION_TOKEN_CONFIG_KEY in resolved_litellm_call_kwargs:
+        additional_kwargs[AWS_SESSION_TOKEN_CONFIG_KEY] = resolved_litellm_call_kwargs[
+            AWS_SESSION_TOKEN_CONFIG_KEY
+        ]
+    if AWS_REGION_NAME_CONFIG_KEY in resolved_litellm_call_kwargs:
+        additional_kwargs["region_name"] = resolved_litellm_call_kwargs[
+            AWS_REGION_NAME_CONFIG_KEY
+        ]
+
+    try:
+        # We are using the boto3 client because it can discover the AWS credentials
+        # from the environment variables, credentials file, or IAM roles.
+        # This is necessary to ensure that the client can connect to the AWS service.
+        aws_client = boto3.client(provider, **additional_kwargs)
+
+        # Using different method calls available to different AWS clients
+        # to test the connection
+        if provider == AWS_SAGEMAKER_PROVIDER:
+            aws_client.list_models()
+        elif provider == AWS_BEDROCK_PROVIDER:
+            aws_client.get_model_invocation_logging_configuration()
+
+    except (ClientError, BotoCoreError) as exc:
         event_info = (
-            f"The following environment variables or configuration keys are "
-            f"missing: "
-            f"{', '.join(missing_environment_details)}. "
-            f"These settings are required for API calls."
+            f"Failed to validate AWS setup for LiteLLM clients: {exc}. "
+            f"Ensure that you are using one of the available authentication methods:"
+            f"credentials file, environment variables, or IAM roles. "
+            f"Also, ensure that the AWS region is set correctly. "
         )
         structlogger.error(
-            f"{source_log}.validate_aws_environment_variables",
+            f"{source_log}.validate_aws_credentials_for_litellm_clients",
             event_info=event_info,
-            missing_environment_variables=missing_environment_variables,
+            exception=str(exc),
+            model_name=litellm_model_name,
         )
         raise ProviderClientValidationError(event_info)
 

rasa/shared/providers/embedding/default_litellm_embedding_client.py

@@ -37,6 +37,7 @@ class DefaultLiteLLMEmbeddingClient(_BaseLiteLLMEmbeddingClient):
 
     @classmethod
     def from_config(cls, config: Dict[str, Any]) -> "DefaultLiteLLMEmbeddingClient":
+        """Creates a DefaultLiteLLMEmbeddingClient instance from a config dict."""
         default_config = DefaultLiteLLMClientConfig.from_dict(config)
         return cls(
             model=default_config.model,
@@ -121,6 +122,7 @@ class DefaultLiteLLMEmbeddingClient(_BaseLiteLLMEmbeddingClient):
                 self._litellm_model_name,
                 self._litellm_extra_parameters,
                 "default_litellm_embedding_client",
+                provider=self.provider,
             )
         else:
             super().validate_client_setup()

rasa/shared/providers/llm/default_litellm_llm_client.py

@@ -39,6 +39,7 @@ class DefaultLiteLLMClient(_BaseLiteLLMClient):
 
     @classmethod
     def from_config(cls, config: Dict[str, Any]) -> DefaultLiteLLMClient:
+        """Creates a DefaultLiteLLMClient instance from a configuration dictionary."""
         default_config = DefaultLiteLLMClientConfig.from_dict(config)
         return cls(
             model=default_config.model,
@@ -110,6 +111,7 @@ class DefaultLiteLLMClient(_BaseLiteLLMClient):
                 self._litellm_model_name,
                 self._litellm_extra_parameters,
                 "default_litellm_llm_client",
+                provider=self.provider,
             )
         else:
             super().validate_client_setup()

rasa/version.py

@@ -1,3 +1,3 @@
 # this file will automatically be changed,
 # do not add anything but the version number here!
-__version__ = "3.14.0.dev20250818"
+__version__ = "3.14.0.dev20250825"

{rasa_pro-3.14.0.dev20250818.dist-info → rasa_pro-3.14.0.dev20250825.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: rasa-pro
-Version: 3.14.0.dev20250818
+Version: 3.14.0.dev20250825
 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.14.0.dev20250818.dist-info → rasa_pro-3.14.0.dev20250825.dist-info}/RECORD

@@ -108,9 +108,10 @@ rasa/core/brokers/sql.py,sha256=SZ-ZFVaPnkCPNNKnISf3KQ-HnG4mQhZ4AoLJrkrIfUE,2748
 rasa/core/channels/__init__.py,sha256=cK3Yk6BChYPd01LIt-XPftaN5obucxTQTEpNuzkdKSs,2624
 rasa/core/channels/botframework.py,sha256=yMtg-xIsH8t_26dCOpR7V4eCrRPYumM5KhGvdNhHYl4,11668
 rasa/core/channels/callback.py,sha256=Llt5TGimf_5P29s2KxEPOZUX6_df7u8uBCsNSFy7CQA,2750
-rasa/core/channels/channel.py,sha256=m51H4YD-CS2e1jYCDBvyWC4l1bu70_19TGP7EF4VLUY,18706
+rasa/core/channels/channel.py,sha256=q8zq9n86kb9iccXoGv_Vj4vcwB75AlXnoK5vg_3evhE,18730
 rasa/core/channels/console.py,sha256=13bjhsmnuKoShYVdtt2VHzzt9xylER-hDTONC1MiQG0,8075
-rasa/core/channels/development_inspector.py,sha256=vOE-2h3bvkn3Xy3sIJCqFSMYLY5JXKRCJdbf7DcaADo,10787
+rasa/core/channels/constants.py,sha256=HWLmyE1kuq9veQFVfAJuGLm3I3Y_IvzEHAJ7PoSxbLQ,153
+rasa/core/channels/development_inspector.py,sha256=J4Ip9B7TuUjbqutoS7fBRH0cFfIpqoBjlpdFn7xvKAM,10794
 rasa/core/channels/facebook.py,sha256=7DTNz2hKLG7sm0U6UjqPgedZthZXrWFnLEW40c8OrCg,15742
 rasa/core/channels/hangouts.py,sha256=MlHX-KKhF0D-f4EtPAN56e7N1ZuvupTxLl4MXMsCbQg,11732
 rasa/core/channels/inspector/.eslintrc.cjs,sha256=FAnPE1mm-eiGeQb9JLMVxDtxX4YOQG4wEFM6OFHB74Y,721
@@ -253,8 +254,8 @@ rasa/core/channels/rasa_chat.py,sha256=pRXn4NLHUCW0_D1FH2B87p7Lnf-xMfPxkjrpbnFXn
 rasa/core/channels/rest.py,sha256=LWBYBdVzOz5Vv5tZCkB1QA7LxXJFTeC87CQLAi_ZGeI,7310
 rasa/core/channels/rocketchat.py,sha256=hajaH6549CjEYFM5jSapw1DQKBPKTXbn7cVSuZzknmI,5999
 rasa/core/channels/slack.py,sha256=jVsTTUu9wUjukPoIsAhbee9o0QFUMCNlQHbR8LTcMBc,24406
-rasa/core/channels/socketio.py,sha256=ZEavmx2on9AH73cuIFSGMKn1LHJhzcQVaqrFz7SH-CE,11348
-rasa/core/channels/studio_chat.py,sha256=oHNUPxND3zJN2SO3HLhZM-aOjpPdddNNCyBW1or79oc,22686
+rasa/core/channels/socketio.py,sha256=N3aldDMzXotO85lX5pkmVtVq7g6gh9YpUpQpbAH3ogs,17560
+rasa/core/channels/studio_chat.py,sha256=g_whnLDmPdGxR63dX2AmJWnPhRnrMxaJsnGz--cDen0,22907
 rasa/core/channels/telegram.py,sha256=TKVknsk3U9tYeY1a8bzlhqkltWmZfGSOvrcmwa9qozc,12499
 rasa/core/channels/twilio.py,sha256=2BTQpyx0b0yPpc0A2BHYfxLPgodrLGLs8nq6i3lVGAM,5906
 rasa/core/channels/vier_cvg.py,sha256=5O4yx0TDQIMppvlCxTOzmPB60CA-vqQXqWQ7upfrTO0,13496
@@ -283,7 +284,7 @@ rasa/core/channels/voice_stream/tts/tts_cache.py,sha256=K4S2d8zWX2h2ylYALp7IdqFS
 rasa/core/channels/voice_stream/tts/tts_engine.py,sha256=JMCWGHxT8QiqKoBeI6F4RX_-Q9EEqG3vUtkgOUnlt-w,1812
 rasa/core/channels/voice_stream/twilio_media_streams.py,sha256=UbaSTaB0tUTf7ryToK6epxb5p31SpFk3tMNnFFo4q_E,9074
 rasa/core/channels/voice_stream/util.py,sha256=nbr0yUl0NIn4-94VUYjPEg_NB2kadcFCq-i9rRJMv4U,2323
-rasa/core/channels/voice_stream/voice_channel.py,sha256=PqULi5aul0TA4zfjFKAa9rInA04i03ylHO7mLam_ld4,23996
+rasa/core/channels/voice_stream/voice_channel.py,sha256=loflCjR9nCZEtlpnR49jofOWsx7buhRyOsgc27rss-Q,23999
 rasa/core/channels/webexteams.py,sha256=z_o_jnc6B7hsHpd6XorImFkF43wB4yx_kiTPKAjPSuo,4805
 rasa/core/concurrent_lock_store.py,sha256=aAZDAYUVffCx2J8wbJ05vTE3Xd9bQ4Dx13RZmCy3ohw,8285
 rasa/core/constants.py,sha256=dEokmEf6XkOFA_xpuwjqwNtlZv-a5Tz5dLMRc7Vu4CU,4070
@@ -339,7 +340,7 @@ rasa/core/policies/rule_policy.py,sha256=EItfUn07JIBLRIbriPKDprsvWq_-xzZTGrlTS2e
 rasa/core/policies/ted_policy.py,sha256=0RzIuyrtt4PxLcqQ-bfaExkZvU-TnsMbgmDcwh2SakY,87710
 rasa/core/policies/unexpected_intent_policy.py,sha256=ZXvbswf2NDy00kHmBQcyXa1OVYFyc79HQKrFkQ4gCfM,39609
 rasa/core/processor.py,sha256=9bFLV7Thgde1XXsvkKbXqwsSz8QxaC2E88qAYmpEBuI,62314
-rasa/core/run.py,sha256=Md-Pl9xjfRA_7VgFcqpT9wpmY-ZceDB0nieMSMadpYA,12124
+rasa/core/run.py,sha256=zwRHM0iXguU1HR___SnOUIwTsCVvSj3FEeiijEiO4Hw,12546
 rasa/core/secrets_manager/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 rasa/core/secrets_manager/constants.py,sha256=dTDHenvG1JBVi34QIR6FpdO5RDOXQwAjAxLlgJ2ZNEI,1193
 rasa/core/secrets_manager/endpoints.py,sha256=4b7KXB9amdF23eYGsx8215bOjE5-TQ73qD2hdI8Sm9c,12662
@@ -432,7 +433,7 @@ rasa/dialogue_understanding/patterns/collect_information.py,sha256=8YWvhFTt8CJML
 rasa/dialogue_understanding/patterns/completed.py,sha256=7qkyUj2d__2R3mpwWVmQpfwCCbJruBrjRZbmbDr3Zbo,1278
 rasa/dialogue_understanding/patterns/continue_interrupted.py,sha256=OSTbe5l0B0ECNIYWpYB0pdzIeaqM3m3UZskNNjL5vrw,1682
 rasa/dialogue_understanding/patterns/correction.py,sha256=7fQ02-JU1CGZiTjTi9YqmD1F4o-9Tv5WCAXnFgZlvtY,11380
-rasa/dialogue_understanding/patterns/default_flows_for_patterns.yml,sha256=NwNXqrodwOTgDPYtu6L5n6epBLzXjnnRCzH_oBPLMnc,11030
+rasa/dialogue_understanding/patterns/default_flows_for_patterns.yml,sha256=2rAErw1D6i_m7cxd2kbxf24xg5Y1duE3Kpx6O7j_Xdc,11038
 rasa/dialogue_understanding/patterns/domain_for_patterns.py,sha256=Zv_lCJn4nbkxeNYOPGsR0V8tmYAUsM_Ho_9to8hku-o,6493
 rasa/dialogue_understanding/patterns/human_handoff.py,sha256=1hkSdL6kui42rZc7zERZ9R7nLyvRHi_tHgNU7FyrhAQ,1132
 rasa/dialogue_understanding/patterns/internal_error.py,sha256=APCKVv16M6mSQ4upu4UwG0yIaaKTyr7uB2yV8ZtpMzo,1609
@@ -563,9 +564,9 @@ rasa/markers/validate.py,sha256=dZvMTcDK_sji9OP8JY4kUcjeIScLF93C3CKTWK8DplI,708
 rasa/model.py,sha256=cAbQXvfZXBKHAj79Z0-mCy29hSSWp2KaroScgDeTfJw,3489
 rasa/model_manager/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 rasa/model_manager/config.py,sha256=8upZP4CokMBy0imiiPvINJuLW4JOQ326dPiJ041jJUI,1231
-rasa/model_manager/model_api.py,sha256=uY8gC4xSwb7OxnMU0hcT5fx6bGgoTURA3r6bhpxNJdk,23855
+rasa/model_manager/model_api.py,sha256=RZqQLFqlbcao0gnqpjN8EG6E29Ls2pxZiDnCPKoIhKw,23876
 rasa/model_manager/runner_service.py,sha256=CfvkmCqk-syCqTxb4u3N44WvzXuWFlpomR9SvgzIFKs,9514
-rasa/model_manager/socket_bridge.py,sha256=g_cxeFDrvl0u6a7g-Ap55hx4-G3dfxtUpxtSH4Ah9ec,5549
+rasa/model_manager/socket_bridge.py,sha256=S_7aijsXuqHSlSscJfNw2Kt_iWXGfhwn6WhKA3FBLr0,5689
 rasa/model_manager/studio_jwt_auth.py,sha256=uls2QiHUlUrR3fOzZssW4UaAMJMfnPMZeV1aDmZIT0E,2645
 rasa/model_manager/trainer_service.py,sha256=aw3tp2736fILT5bYunkERPcWR5TjjyhThBXIktJfhqU,10628
 rasa/model_manager/utils.py,sha256=rS0ST-rJMuZOna90r_Ioz7gOkZ8r8vm4XAhzI0iUZOA,2643
@@ -739,13 +740,13 @@ rasa/shared/providers/_configs/rasa_llm_client_config.py,sha256=UiEVmjkoS3a0AHLQ
 rasa/shared/providers/_configs/self_hosted_llm_client_config.py,sha256=rxUFj8s4HAukjhILlOs7vrgXL9WNlfvGEcfMVEa-LrA,5952
 rasa/shared/providers/_configs/utils.py,sha256=AUnvh4qF9VfLoXpTPoZfwYQ9YsVW8HPMbWa-vG6wOHw,453
 rasa/shared/providers/_ssl_verification_utils.py,sha256=vUnP0vocf0GQ0wG8IQpPcCet4c1C9-wQWQNckNWbDBk,4165
-rasa/shared/providers/_utils.py,sha256=EZIrz3ugcI-9PWgC7v0VMUNYondAAOeeRLIE8ZmResw,5886
+rasa/shared/providers/_utils.py,sha256=LVPsZbl6zzF4hZE6bNVwgY4BkbeIWnRD0dhEqA-kWkk,6975
 rasa/shared/providers/constants.py,sha256=hgV8yNGxIbID_2h65OoSfSjIE4UkazrsqRg4SdkPAmI,234
 rasa/shared/providers/embedding/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 rasa/shared/providers/embedding/_base_litellm_embedding_client.py,sha256=1CUYxps_TrLVyPsPfOw7iDS502fDePseBIKnqc3ncwQ,9005
 rasa/shared/providers/embedding/_langchain_embedding_client_adapter.py,sha256=IR2Rb3ReJ9C9sxOoOGRXgtz8STWdMREs_4AeSMKFjl4,2135
 rasa/shared/providers/embedding/azure_openai_embedding_client.py,sha256=HKHMx6m669CC19u6GPnpSLzA0PwvHlquhaK3QhqHI78,12469
-rasa/shared/providers/embedding/default_litellm_embedding_client.py,sha256=da17WeHjZp95Uv9jmTKxklNRcNpn-qRsRPcwDQusElg,4397
+rasa/shared/providers/embedding/default_litellm_embedding_client.py,sha256=FQUFglXN9Ty-FnUaA80itdyutDxLk7HRZwzULG02k8s,4520
 rasa/shared/providers/embedding/embedding_client.py,sha256=LGFlnsf5B0XDn8GRn_mLfCJ5erhf2p3zXiKTdG9jNXY,2839
 rasa/shared/providers/embedding/embedding_response.py,sha256=H55mSAL3LfVvDlBklaCCQ4AnNwCsQSQ1f2D0oPrx3FY,1204
 rasa/shared/providers/embedding/huggingface_local_embedding_client.py,sha256=Zo3gyj49h4LxXV7bx39TXpIPKlernG-5xzqXczTCbig,6913
@@ -754,7 +755,7 @@ rasa/shared/providers/embedding/openai_embedding_client.py,sha256=XNRGE7apo2v3kW
 rasa/shared/providers/llm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 rasa/shared/providers/llm/_base_litellm_client.py,sha256=Ua5Kt6VGe5vRzSzWWWx2Q3LH2PCDd8V7V4zfYD464yU,11634
 rasa/shared/providers/llm/azure_openai_llm_client.py,sha256=ui85vothxR2P_-eLc4nLgbpjnpEKY2BXnIjLxBZoYz8,12504
-rasa/shared/providers/llm/default_litellm_llm_client.py,sha256=mPDehyLxt3Q9fPSyaMArkVAMkMTf5lfSzhgv--pMTt4,4083
+rasa/shared/providers/llm/default_litellm_llm_client.py,sha256=q6QoyPPq0K7V9aeD0zr08ZK69xlH4GseGFdhUxpWcG8,4210
 rasa/shared/providers/llm/litellm_router_llm_client.py,sha256=_6vAdPLAVSI_sBJLaXLnE87M-0ip_klfQ78fQ_pyoyI,7947
 rasa/shared/providers/llm/llm_client.py,sha256=-hTCRsL-A3GCMRHtcyCgcCyra-9OJ8GUC-mURoRXH0k,3242
 rasa/shared/providers/llm/llm_response.py,sha256=8mOpZdmh4-3yM7aOmNO0yEYUmRDErfoP7ZDMUuHr2Cc,3504
@@ -847,9 +848,9 @@ rasa/utils/train_utils.py,sha256=ClJx-6x3-h3Vt6mskacgkcCUJTMXjFPe3zAcy_DfmaU,212
 rasa/utils/url_tools.py,sha256=dZ1HGkVdWTJB7zYEdwoDIrEuyX9HE5WsxKKFVsXBLE0,1218
 rasa/utils/yaml.py,sha256=KjbZq5C94ZP7Jdsw8bYYF7HASI6K4-C_kdHfrnPLpSI,2000
 rasa/validator.py,sha256=fhRlHQvuBkiup0FnNYmwRmqQwC3QpdCJt0TuvW4jMaI,83125
-rasa/version.py,sha256=ahOxjS-ZcfByCTpKZeJQpy8Nz8tWQSofg4M4o09jjXc,129
-rasa_pro-3.14.0.dev20250818.dist-info/METADATA,sha256=yh-5sm-77YpUXPMLIH0myQPyO4Df4mSRMkUNWcqJifI,10585
-rasa_pro-3.14.0.dev20250818.dist-info/NOTICE,sha256=7HlBoMHJY9CL2GlYSfTQ-PZsVmLmVkYmMiPlTjhuCqA,218
-rasa_pro-3.14.0.dev20250818.dist-info/WHEEL,sha256=fGIA9gx4Qxk2KDKeNJCbOEwSrmLtjWCwzBz351GyrPQ,88
-rasa_pro-3.14.0.dev20250818.dist-info/entry_points.txt,sha256=ckJ2SfEyTPgBqj_I6vm_tqY9dZF_LAPJZA335Xp0Q9U,43
-rasa_pro-3.14.0.dev20250818.dist-info/RECORD,,
+rasa/version.py,sha256=Ky7QZgOki_d2qRC7Z1GAZctbe6IxA52vhVkvPpQ_8pc,129
+rasa_pro-3.14.0.dev20250825.dist-info/METADATA,sha256=V3KjozHtsQb15IjlJK2CYfppD_oVL17uPhmIx7pXJ18,10585
+rasa_pro-3.14.0.dev20250825.dist-info/NOTICE,sha256=7HlBoMHJY9CL2GlYSfTQ-PZsVmLmVkYmMiPlTjhuCqA,218
+rasa_pro-3.14.0.dev20250825.dist-info/WHEEL,sha256=fGIA9gx4Qxk2KDKeNJCbOEwSrmLtjWCwzBz351GyrPQ,88
+rasa_pro-3.14.0.dev20250825.dist-info/entry_points.txt,sha256=ckJ2SfEyTPgBqj_I6vm_tqY9dZF_LAPJZA335Xp0Q9U,43
+rasa_pro-3.14.0.dev20250825.dist-info/RECORD,,