rasa-pro 3.13.0.dev5__py3-none-any.whl → 3.13.0.dev8__py3-none-any.whl

rasa/core/channels/inspector/src/theme/index.ts

@@ -4,61 +4,61 @@ import {
   useTheme,
   ChakraTheme,
   type ThemeConfig,
-} from "@chakra-ui/react";
-import { breakpoints, Breakpoints } from "./base/breakpoints";
-import { rasaColors, RasaColors } from "./base/colors";
-import { rasaRadii, RasaRadii } from "./base/radii";
-import { rasaShadows, RasaShadows } from "./base/shadows";
-import { rasaSizes, RasaSizes } from "./base/sizes";
-import { rasaSpace, RasaSpace } from "./base/space";
-import { rasaZIndices, RasaZIndices } from "./base/zIndices";
-import { styles } from "./base/styles";
+} from '@chakra-ui/react'
+import { breakpoints, Breakpoints } from './base/breakpoints'
+import { rasaColors, RasaColors } from './base/colors'
+import { rasaRadii, RasaRadii } from './base/radii'
+import { rasaShadows, RasaShadows } from './base/shadows'
+import { rasaSizes, RasaSizes } from './base/sizes'
+import { rasaSpace, RasaSpace } from './base/space'
+import { rasaZIndices, RasaZIndices } from './base/zIndices'
+import { styles } from './base/styles'
 import {
   fonts,
   rasaFontSizes,
   rasaFontWeights,
   RasaFontSizes,
   RasaFontWeights,
-} from "./base/typography";
+} from './base/typography'
 
 // Custom components
-import { Button } from "./Button/Button";
-import { Heading } from "./Heading/Heading";
-import { Input } from "./Input/Input";
-import { Link } from "./Link/Link";
-import { Table } from "./Table/Table";
-import { Modal } from "./Modal/Modal";
-import { Tooltip } from "./Tooltip/Tooltip";
+import { Button } from './Button/Button'
+import { Heading } from './Heading/Heading'
+import { Input } from './Input/Input'
+import { Link } from './Link/Link'
+import { Table } from './Table/Table'
+import { Modal } from './Modal/Modal'
+import { Tooltip } from './Tooltip/Tooltip'
 
 export interface CustomTheme {
   // default types
-  config: ThemeConfig;
-  semanticTokens: ChakraTheme["semanticTokens"];
-  direction: ChakraTheme["direction"];
-  transition: ChakraTheme["transition"];
+  config: ThemeConfig
+  semanticTokens: ChakraTheme['semanticTokens']
+  direction: ChakraTheme['direction']
+  transition: ChakraTheme['transition']
 
   // we merge & override
-  styles: ChakraTheme["styles"];
-  fonts: RasaFontSizes;
-  breakpoints: Breakpoints;
+  styles: ChakraTheme['styles']
+  fonts: RasaFontSizes
+  breakpoints: Breakpoints
 
   // we also merge & override, but use custom color names
-  colors: RasaColors;
+  colors: RasaColors
 
   // custom key & types
-  rasaFontSizes: RasaFontSizes;
-  rasaFontWeights: RasaFontWeights;
-  rasaRadii: RasaRadii;
-  rasaSpace: RasaSpace;
-  rasaShadows: RasaShadows;
-  rasaSizes: RasaSizes;
-  zIndices: ChakraTheme["zIndices"] & RasaZIndices;
+  rasaFontSizes: RasaFontSizes
+  rasaFontWeights: RasaFontWeights
+  rasaRadii: RasaRadii
+  rasaSpace: RasaSpace
+  rasaShadows: RasaShadows
+  rasaSizes: RasaSizes
+  zIndices: ChakraTheme['zIndices'] & RasaZIndices
 }
 
 const config: ThemeConfig = {
-  initialColorMode: "light",
+  initialColorMode: 'light',
   useSystemColorMode: false,
-};
+}
 
 // Extend theme deep merges with the default Chakra theme.
 // We try to keep many defaults in tact to support
@@ -93,9 +93,9 @@ export const theme = extendTheme(
     rasaSizes,
     zIndices: rasaZIndices,
   },
-  withDefaultColorScheme({ colorScheme: "rasaPurple" })
-);
+  withDefaultColorScheme({ colorScheme: 'rasaPurple' }),
+)
 
 export const useOurTheme = () => {
-  return useTheme<CustomTheme>();
-};
+  return useTheme<CustomTheme>()
+}

rasa/core/channels/inspector/src/types.ts

@@ -1,84 +1,90 @@
 export interface Slot {
-  name: string;
+  name: string
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  value: any;
+  value: any
 }
 
 export interface Event {
-  event: "user" | "bot" | "flow_completed" | "flow_started" | "stack" | "restart" | "session_ended";
-  text?: string;
-  timestamp: string;
-  update?: string;
-  parse_data?: { commands: Command[] };
-  metadata?: { utter_action?: string };
+  event:
+    | 'user'
+    | 'bot'
+    | 'flow_completed'
+    | 'flow_started'
+    | 'stack'
+    | 'restart'
+    | 'session_ended'
+  text?: string
+  timestamp: string
+  update?: string
+  parse_data?: { commands: Command[] }
+  metadata?: { utter_action?: string }
 }
 
 export interface Command {
-  command: string;
-  flow?: string;
-  name?: string;
-  value?: string;
+  command: string
+  flow?: string
+  name?: string
+  value?: string
 }
 
 export interface SelectedStack {
-  stack: Stack;
-  activatedSteps: string[];
-  isUserSelected: boolean;
+  stack: Stack
+  activatedSteps: string[]
+  isUserSelected: boolean
 }
 
 export interface Stack {
-  frame_id: string;
-  flow_id: string;
-  step_id: string;
-  collect?: string;
-  utter?: string;
-  ended: boolean;
+  frame_id: string
+  flow_id: string
+  step_id: string
+  collect?: string
+  utter?: string
+  ended: boolean
 }
 
 export interface Tracker {
-  sender_id: string;
-  slots: { [key: string]: unknown };
-  events: Event[];
-  stack: Stack[];
+  sender_id: string
+  slots: { [key: string]: unknown }
+  events: Event[]
+  stack: Stack[]
 }
 
-
 export interface Flow {
-  id: string;
-  description: string;
-  name: string;
-  steps: Step[];
+  id: string
+  description: string
+  name: string
+  steps: Step[]
 }
 
 interface NextStepThen {
-  action: string;
-  id: string;
-  next: string;
-  set_slots: unknown[];
+  action: string
+  id: string
+  next: string
+  set_slots: unknown[]
 }
 
 interface NextStepIf {
-  if: string;
-  then: NextStepThen[];
+  if: string
+  then: NextStepThen[]
 }
 
 interface NextStepElse {
-  if: string;
-  then: NextStepThen[];
-  else: string;
+  if: string
+  then: NextStepThen[]
+  else: string
 }
 
-export type NextStep = NextStepIf | NextStepElse;
+export type NextStep = NextStepIf | NextStepElse
 
 interface Step {
-  ask_before_filling: boolean;
-  collect: string;
-  action: string;
-  link: string;
-  description: string;
-  id: string;
-  next: string | NextStep[];
-  reset_after_flow_ends: boolean;
-  utter: string;
-  set_slots?: unknown;
+  ask_before_filling: boolean
+  collect: string
+  action: string
+  link: string
+  description: string
+  id: string
+  next: string | NextStep[]
+  reset_after_flow_ends: boolean
+  utter: string
+  set_slots?: unknown
 }

rasa/core/channels/inspector/yarn.lock

@@ -5280,6 +5280,11 @@ prelude-ls@^1.2.1:
   resolved "https://registry.yarnpkg.com/prelude-ls/-/prelude-ls-1.2.1.tgz#debc6489d7a6e6b0e7611888cec880337d316396"
   integrity sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==
 
+prettier@^3.5.3:
+  version "3.5.3"
+  resolved "https://registry.yarnpkg.com/prettier/-/prettier-3.5.3.tgz#4fc2ce0d657e7a02e602549f053b239cb7dfe1b5"
+  integrity sha512-QQtaxnoDJeAkDvDKWCLiwIXkTgRhwYDEQCghU9Z6q03iyek/rxRh/2lC3HB7P8sWT2xC/y5JDctPLBIGzHKbhw==
+
 pretty-format@^27.0.2:
   version "27.5.1"
   resolved "https://registry.yarnpkg.com/pretty-format/-/pretty-format-27.5.1.tgz#2181879fdea51a7a5851fb39d920faa63f01d88e"

rasa/core/channels/mattermost.py

@@ -28,7 +28,7 @@ class MattermostBot(OutputChannel):
         if r.status_code == 200:
             return r.headers["Token"]
         else:
-            logger.error(f"Failed to login mattermost user {user}. Response: {r}")
+            logger.error(f"Failed to login mattermost user. Response: {r}")
             return None
 
     def __init__(

rasa/core/channels/rasa_chat.py

@@ -107,10 +107,8 @@ class RasaChatInput(RestInput):
                 return req.json[CONVERSATION_ID_KEY]
             else:
                 logger.error(
-                    "User '{}' does not have permissions to send messages to "
-                    "conversation '{}'.".format(
-                        jwt_payload[JWT_USERNAME_KEY], req.json[CONVERSATION_ID_KEY]
-                    )
+                    "User does not have permissions to send messages to "
+                    "conversation '{}'.".format(req.json[CONVERSATION_ID_KEY])
                 )
                 raise SanicException(status_code=401)
 

rasa/core/channels/rest.py

@@ -1,5 +1,4 @@
 import asyncio
-import copy
 import inspect
 import json
 import logging
@@ -166,11 +165,13 @@ class RestInput(InputChannel):
                 )
             except CancelledError:
                 structlogger.error(
-                    "rest.message.received.timeout", text=copy.deepcopy(text)
+                    "rest.message.received.timeout",
+                    event_info="Message processing was cancelled.",
                 )
-            except Exception:
+            except Exception as e:
                 structlogger.exception(
-                    "rest.message.received.failure", text=copy.deepcopy(text)
+                    "rest.message.received.failure",
+                    event_info=f"Message processing failed. Error: {e}",
                 )
 
             return response.json(collector.messages)

rasa/core/channels/studio_chat.py

@@ -83,7 +83,9 @@ class StudioTrackerUpdatePlugin:
 
     def handle_tracker_update(self, tracker: "DialogueStateTracker") -> None:
         """Handles a tracker update when triggered by a hook."""
-        structlogger.info("studio_chat.after_tracker_update", tracker=tracker)
+        structlogger.info(
+            "studio_chat.after_tracker_update", sender_id=tracker.sender_id
+        )
         # directly create a dump to avoid the tracker getting modified by another
         # function before it gets published (since the publishing is scheduled
         # as an async task)
@@ -185,7 +187,6 @@ class StudioChatInput(SocketIOInput):
                 output_channel = self.get_output_channel()
 
                 await processor._run_prediction_loop(output_channel, tracker)
-                await processor.run_anonymization_pipeline(tracker)
                 await self.agent.tracker_store.save(tracker)
 
         await self.on_tracker_updated(tracker)

rasa/core/channels/vier_cvg.py

@@ -129,9 +129,8 @@ class CVGOutput(OutputChannel):
                 )
 
             logger.info(
-                "Creating incoming UserMessage: {text=%s, output_channel=%s, sender_id=%s, metadata=%s}"  # noqa: E501
+                "Creating incoming UserMessage: {output_channel=%s, sender_id=%s, metadata=%s}"  # noqa: E501
                 % (
-                    user_message.text,
                     user_message.output_channel,
                     user_message.sender_id,
                     user_message.metadata,

rasa/core/channels/voice_ready/audiocodes.py

@@ -160,6 +160,12 @@ class Conversation:
                 structlogger.warning(
                     "audiocodes.handle.activities.duplicate_activity",
                     activity_id=activity[ACTIVITY_ID_KEY],
+                    event_info=(
+                        "Audiocodes might send duplicate activities if the bot has not "
+                        "responded to the previous one or responded too late. Please "
+                        "consider enabling the `use_websocket` option to use"
+                        " Audiocodes Asynchronous API."
+                    ),
                 )
                 continue
             self.activity_ids.append(activity[ACTIVITY_ID_KEY])
@@ -187,16 +193,9 @@ class Conversation:
             try:
                 await on_new_message(user_msg)
             except Exception as e:  # skipcq: PYL-W0703
-                if isinstance(user_msg.text, dict):
-                    anonymized_info = json.dumps(user_msg.text)
-                elif isinstance(user_msg.text, str):
-                    anonymized_info = user_msg.text
-                else:
-                    anonymized_info = INFO_UNKNOWN
-
                 structlogger.exception(
                     "audiocodes.handle.activities.failure",
-                    user_message=copy.deepcopy(anonymized_info),
+                    sender_id=self.conversation_id,
                     error=e,
                     exc_info=True,
                 )
@@ -415,30 +414,41 @@ class AudiocodesInput(InputChannel):
                     "audiocodes.on_activities.no_conversation", request=request.json
                 )
                 return response.json({})
-            elif conversation.ws:
+
+            if self.use_websocket:
+                # send an empty response for this request
+                # activities are processed in the background
+                # chat response is sent via the websocket
                 ac_output: Union[WebsocketOutput, AudiocodesOutput] = WebsocketOutput(
                     conversation.ws, conversation_id
                 )
-                response_json = {}
-            else:
-                # handle non websocket case where messages get returned in json
-                ac_output = AudiocodesOutput()
-                response_json = {
+                self._create_task(
+                    conversation_id,
+                    conversation.handle_activities(
+                        request.json,
+                        input_channel_name=self.name(),
+                        output_channel=ac_output,
+                        on_new_message=on_new_message,
+                    ),
+                )
+                return response.json({})
+
+            # without websockets, this becomes a blocking call
+            # and the response is sent back to the Audiocodes server
+            # after the activities are processed
+            ac_output = AudiocodesOutput()
+            await conversation.handle_activities(
+                request.json,
+                input_channel_name=self.name(),
+                output_channel=ac_output,
+                on_new_message=on_new_message,
+            )
+            return response.json(
+                {
                     "conversation": conversation_id,
                     "activities": ac_output.messages,
                 }
-
-            # start a background task to handle activities
-            self._create_task(
-                conversation_id,
-                conversation.handle_activities(
-                    request.json,
-                    input_channel_name=self.name(),
-                    output_channel=ac_output,
-                    on_new_message=on_new_message,
-                ),
             )
-            return response.json(response_json)
 
         @ac_webhook.route(
             "/conversation/<conversation_id>/disconnect", methods=["POST"]

rasa/core/channels/voice_stream/audiocodes.py

@@ -108,15 +108,19 @@ class AudiocodesVoiceInputChannel(VoiceInputChannel):
         server_url: str,
         asr_config: Dict,
         tts_config: Dict,
-        monitor_silence: bool = False,
     ):
         mark_as_beta_feature("Audiocodes (audiocodes_stream) Channel")
-        super().__init__(server_url, asr_config, tts_config, monitor_silence)
+        super().__init__(
+            server_url=server_url,
+            asr_config=asr_config,
+            tts_config=tts_config,
+        )
         self.token = token
 
     @classmethod
     def from_credentials(
-        cls, credentials: Optional[Dict[str, Any]]
+        cls,
+        credentials: Optional[Dict[str, Any]],
     ) -> VoiceInputChannel:
         if not credentials:
             raise ValueError("No credentials given for Audiocodes voice channel.")
@@ -126,7 +130,6 @@ class AudiocodesVoiceInputChannel(VoiceInputChannel):
             server_url=credentials["server_url"],
             asr_config=credentials["asr"],
             tts_config=credentials["tts"],
-            monitor_silence=credentials.get("monitor_silence", False),
         )
 
     def channel_bytes_to_rasa_audio_bytes(self, input_bytes: bytes) -> RasaAudioBytes:

rasa/core/channels/voice_stream/genesys.py

@@ -99,7 +99,8 @@ class GenesysInputChannel(VoiceInputChannel):
 
     @classmethod
     def from_credentials(
-        cls, credentials: Optional[Dict[str, Any]]
+        cls,
+        credentials: Optional[Dict[str, Any]],
     ) -> VoiceInputChannel:
         if not credentials:
             raise ValueError("No credentials given for Genesys voice channel.")
@@ -113,7 +114,6 @@ class GenesysInputChannel(VoiceInputChannel):
             server_url=credentials["server_url"],
             asr_config=credentials["asr"],
             tts_config=credentials["tts"],
-            monitor_silence=credentials.get("monitor_silence", False),
         )
 
     def _ensure_channel_data_initialized(self) -> None:

rasa/core/channels/voice_stream/twilio_media_streams.py

@@ -14,7 +14,7 @@ from sanic import (  # type: ignore[attr-defined]
     response,
 )
 
-from rasa.core.channels import InputChannel, UserMessage
+from rasa.core.channels import UserMessage
 from rasa.core.channels.channel import (
     create_auth_requested_response_provider,
     requires_basic_auth,
@@ -102,16 +102,22 @@ class TwilioMediaStreamsInputChannel(VoiceInputChannel):
         server_url: str,
         asr_config: Dict,
         tts_config: Dict,
-        monitor_silence: bool = False,
         username: Optional[Text] = None,
         password: Optional[Text] = None,
     ):
-        super().__init__(server_url, asr_config, tts_config, monitor_silence)
+        super().__init__(
+            server_url=server_url,
+            asr_config=asr_config,
+            tts_config=tts_config,
+        )
         self.username = username
         self.password = password
 
     @classmethod
-    def from_credentials(cls, credentials: Optional[Dict[str, Any]]) -> InputChannel:
+    def from_credentials(
+        cls,
+        credentials: Optional[Dict[str, Any]],
+    ) -> VoiceInputChannel:
         credentials = credentials or {}
 
         username = credentials.get("username")
@@ -126,7 +132,6 @@ class TwilioMediaStreamsInputChannel(VoiceInputChannel):
             credentials["server_url"],
             credentials["asr"],
             credentials["tts"],
-            credentials.get("monitor_silence", False),
             username=username,
             password=password,
         )

rasa/core/channels/voice_stream/voice_channel.py

@@ -31,8 +31,10 @@ from rasa.core.channels.voice_stream.tts.azure import AzureTTS
 from rasa.core.channels.voice_stream.tts.cartesia import CartesiaTTS
 from rasa.core.channels.voice_stream.tts.tts_cache import TTSCache
 from rasa.core.channels.voice_stream.tts.tts_engine import TTSEngine, TTSError
-from rasa.core.channels.voice_stream.util import generate_silence
-from rasa.shared.core.constants import SLOT_SILENCE_TIMEOUT
+from rasa.core.channels.voice_stream.util import (
+    generate_silence,
+)
+from rasa.shared.core.constants import SILENCE_TIMEOUT_SLOT
 from rasa.shared.utils.cli import print_error_and_exit
 from rasa.shared.utils.common import (
     class_from_module_path,
@@ -171,8 +173,12 @@ class VoiceOutputChannel(OutputChannel):
     def update_silence_timeout(self) -> None:
         """Updates the silence timeout for the session."""
         if self.tracker_state:
-            call_state.silence_timeout = (  # type: ignore[attr-defined]
-                self.tracker_state["slots"][SLOT_SILENCE_TIMEOUT]
+            call_state.silence_timeout = self.tracker_state["slots"][  # type: ignore[attr-defined]
+                SILENCE_TIMEOUT_SLOT
+            ]
+            logger.debug(
+                "voice_channel.silence_timeout_updated",
+                silence_timeout=call_state.silence_timeout,
             )
 
     async def send_text_with_buttons(
@@ -285,21 +291,24 @@ class VoiceInputChannel(InputChannel):
         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))
 
+        logger.info(
+            "voice_channel.initialized",
+            server_url=self.server_url,
+            asr_config=self.asr_config,
+            tts_config=self.tts_config,
+        )
+
     async def monitor_silence_timeout(self, asr_event_queue: asyncio.Queue) -> None:
         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)
         await asr_event_queue.put(UserSilence())
@@ -314,13 +323,15 @@ class VoiceInputChannel(InputChannel):
             call_state.silence_timeout_watcher = None  # type: ignore[attr-defined]
 
     @classmethod
-    def from_credentials(cls, credentials: Optional[Dict[str, Any]]) -> InputChannel:
+    def from_credentials(
+        cls,
+        credentials: Optional[Dict[str, Any]],
+    ) -> InputChannel:
         credentials = credentials or {}
         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:
@@ -340,9 +351,9 @@ class VoiceInputChannel(InputChannel):
     ) -> None:
         output_channel = self.create_output_channel(channel_websocket, tts_engine)
         message = UserMessage(
-            USER_CONVERSATION_SESSION_START,
-            output_channel,
-            call_parameters.stream_id,
+            text=USER_CONVERSATION_SESSION_START,
+            output_channel=output_channel,
+            sender_id=call_parameters.stream_id,
             input_channel=self.name(),
             metadata=asdict(call_parameters),
         )
@@ -377,17 +388,17 @@ class VoiceInputChannel(InputChannel):
 
         async def consume_audio_bytes() -> None:
             async for message in channel_websocket:
-                is_bot_speaking_before = call_state.is_bot_speaking
+                was_bot_speaking_before = call_state.is_bot_speaking
                 channel_action = self.map_input_message(message, channel_websocket)
                 is_bot_speaking_after = call_state.is_bot_speaking
 
-                if not is_bot_speaking_before and is_bot_speaking_after:
+                if not was_bot_speaking_before and is_bot_speaking_after:
                     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:
+                if was_bot_speaking_before and not is_bot_speaking_after:
                     logger.debug("voice_channel.bot_stopped_speaking")
                     self._cancel_silence_timeout_watcher()
                     call_state.silence_timeout_watcher = (  # type: ignore[attr-defined]
@@ -458,9 +469,9 @@ class VoiceInputChannel(InputChannel):
             call_state.is_user_speaking = False  # type: ignore[attr-defined]
             output_channel = self.create_output_channel(voice_websocket, tts_engine)
             message = UserMessage(
-                e.text,
-                output_channel,
-                call_parameters.stream_id,
+                text=e.text,
+                output_channel=output_channel,
+                sender_id=call_parameters.stream_id,
                 input_channel=self.name(),
                 metadata=asdict(call_parameters),
             )
@@ -471,9 +482,9 @@ class VoiceInputChannel(InputChannel):
         elif isinstance(e, UserSilence):
             output_channel = self.create_output_channel(voice_websocket, tts_engine)
             message = UserMessage(
-                USER_CONVERSATION_SILENCE_TIMEOUT,
-                output_channel,
-                call_parameters.stream_id,
+                text=USER_CONVERSATION_SILENCE_TIMEOUT,
+                output_channel=output_channel,
+                sender_id=call_parameters.stream_id,
                 input_channel=self.name(),
                 metadata=asdict(call_parameters),
             )

rasa/core/evaluation/marker_tracker_loader.py

@@ -2,7 +2,7 @@ import random
 from typing import Any, AsyncIterator, Iterable, List, Optional, Text
 
 import rasa.shared.utils.io
-from rasa.core.tracker_store import TrackerStore
+from rasa.core.tracker_stores.tracker_store import TrackerStore
 from rasa.shared.core.trackers import DialogueStateTracker
 from rasa.shared.exceptions import RasaException