rasa-pro 3.12.0.dev9__py3-none-any.whl → 3.12.0.dev10__py3-none-any.whl

rasa/core/actions/action.py

@@ -72,10 +72,11 @@ from rasa.shared.core.constants import (
     ACTION_UNLIKELY_INTENT_NAME,
     ACTION_VALIDATE_SLOT_MAPPINGS,
     DEFAULT_SLOT_NAMES,
+    KEY_MAPPING_TYPE,
     KNOWLEDGE_BASE_SLOT_NAMES,
-    MAPPING_TYPE,
     REQUESTED_SLOT,
     USER_INTENT_OUT_OF_SCOPE,
+    SetSlotExtractor,
     SlotMappingType,
 )
 from rasa.shared.core.domain import Domain
@@ -118,6 +119,10 @@ logger = logging.getLogger(__name__)
 def default_actions(action_endpoint: Optional[EndpointConfig] = None) -> List["Action"]:
     """List default actions."""
     from rasa.core.actions.action_clean_stack import ActionCleanStack
+    from rasa.core.actions.action_handle_digressions import (
+        ActionBlockDigressions,
+        ActionContinueDigression,
+    )
     from rasa.core.actions.action_hangup import ActionHangup
     from rasa.core.actions.action_repeat_bot_messages import ActionRepeatBotMessages
     from rasa.core.actions.action_run_slot_rejections import ActionRunSlotRejections
@@ -152,6 +157,8 @@ def default_actions(action_endpoint: Optional[EndpointConfig] = None) -> List["A
         ActionResetRouting(),
         ActionHangup(),
         ActionRepeatBotMessages(),
+        ActionBlockDigressions(),
+        ActionContinueDigression(),
     ]
 
 
@@ -940,7 +947,14 @@ class RemoteAction(Action):
         )
 
         events = rasa.shared.core.events.deserialise_events(events_json)
-        return cast(List[Event], bot_messages) + events
+
+        processed_events = []
+        for event in events:
+            if isinstance(event, SlotSet) and event.filled_by is None:
+                event.filled_by = SetSlotExtractor.CUSTOM.value
+            processed_events.append(event)
+
+        return cast(List[Event], bot_messages) + processed_events
 
     def name(self) -> Text:
         return self._name
@@ -1317,7 +1331,7 @@ class ActionExtractSlots(Action):
                 slot_events.append(SlotSet(slot.name, slot_value))
 
             for mapping in slot.mappings:
-                mapping_type = SlotMappingType(mapping.get(MAPPING_TYPE))
+                mapping_type = SlotMappingType(mapping.get(KEY_MAPPING_TYPE))
                 should_fill_custom_slot = mapping_type == SlotMappingType.CUSTOM
 
                 if should_fill_custom_slot:

rasa/core/actions/action_handle_digressions.py

@@ -0,0 +1,142 @@
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional
+
+import structlog
+
+from rasa.core.actions.action import Action, create_bot_utterance
+from rasa.core.channels import OutputChannel
+from rasa.core.nlg import NaturalLanguageGenerator
+from rasa.core.utils import add_bot_utterance_metadata
+from rasa.dialogue_understanding.patterns.continue_interrupted import (
+    ContinueInterruptedPatternFlowStackFrame,
+)
+from rasa.dialogue_understanding.patterns.handle_digressions import (
+    HandleDigressionsPatternFlowStackFrame,
+)
+from rasa.dialogue_understanding.stack.frames.flow_stack_frame import (
+    FlowStackFrameType,
+    UserFlowStackFrame,
+)
+from rasa.shared.core.constants import (
+    ACTION_BLOCK_DIGRESSION,
+    ACTION_CONTINUE_DIGRESSION,
+)
+from rasa.shared.core.domain import Domain
+from rasa.shared.core.events import Event, FlowInterrupted
+from rasa.shared.core.trackers import DialogueStateTracker
+
+structlogger = structlog.get_logger()
+
+
+class ActionBlockDigressions(Action):
+    """Action which blocks an interruption and continues the current flow."""
+
+    def name(self) -> str:
+        """Return the action name."""
+        return ACTION_BLOCK_DIGRESSION
+
+    async def run(
+        self,
+        output_channel: OutputChannel,
+        nlg: NaturalLanguageGenerator,
+        tracker: DialogueStateTracker,
+        domain: Domain,
+        metadata: Optional[Dict[str, Any]] = None,
+    ) -> List[Event]:
+        """Update the stack."""
+        structlogger.debug("action_block_digressions.run")
+        top_frame = tracker.stack.top()
+
+        if not isinstance(top_frame, HandleDigressionsPatternFlowStackFrame):
+            return []
+
+        blocked_flow_id = top_frame.interrupting_flow_id
+        frame_type = FlowStackFrameType.REGULAR
+
+        stack = tracker.stack
+        stack.push(
+            UserFlowStackFrame(flow_id=blocked_flow_id, frame_type=frame_type), 0
+        )
+        stack.push(
+            ContinueInterruptedPatternFlowStackFrame(
+                previous_flow_name=blocked_flow_id
+            ),
+            1,
+        )
+        events = tracker.create_stack_updated_events(stack)
+
+        utterance = "utter_block_digressions"
+        message = await nlg.generate(
+            utterance,
+            tracker,
+            output_channel.name(),
+        )
+
+        if message is None:
+            structlogger.error(
+                "action_block_digressions.run.failed.finding.utter",
+                utterance=utterance,
+            )
+        else:
+            message = add_bot_utterance_metadata(
+                message, utterance, nlg, domain, tracker
+            )
+            events.append(create_bot_utterance(message))
+
+        return events
+
+
+class ActionContinueDigression(Action):
+    """Action which continues with an interruption."""
+
+    def name(self) -> str:
+        """Return the action name."""
+        return ACTION_CONTINUE_DIGRESSION
+
+    async def run(
+        self,
+        output_channel: OutputChannel,
+        nlg: NaturalLanguageGenerator,
+        tracker: DialogueStateTracker,
+        domain: Domain,
+        metadata: Optional[Dict[str, Any]] = None,
+    ) -> List[Event]:
+        """Update the stack."""
+        structlogger.debug("action_continue_digression.run")
+        top_frame = tracker.stack.top()
+
+        if not isinstance(top_frame, HandleDigressionsPatternFlowStackFrame):
+            return []
+
+        blocked_flow_id = top_frame.interrupting_flow_id
+        frame_type = FlowStackFrameType.INTERRUPT
+        stack = tracker.stack
+        stack.push(UserFlowStackFrame(flow_id=blocked_flow_id, frame_type=frame_type))
+
+        events = [
+            FlowInterrupted(
+                flow_id=top_frame.interrupted_flow_id,
+                step_id=top_frame.interrupted_step_id,
+            )
+        ] + tracker.create_stack_updated_events(stack)
+
+        utterance = "utter_continue_interruption"
+        message = await nlg.generate(
+            utterance,
+            tracker,
+            output_channel.name(),
+        )
+
+        if message is None:
+            structlogger.error(
+                "action_continue_digression.run.failed.finding.utter",
+                utterance=utterance,
+            )
+        else:
+            message = add_bot_utterance_metadata(
+                message, utterance, nlg, domain, tracker
+            )
+            events.append(create_bot_utterance(message))
+
+        return events

rasa/core/actions/forms.py

@@ -16,7 +16,7 @@ from rasa.shared.constants import UTTER_PREFIX
 from rasa.shared.core.constants import (
     ACTION_EXTRACT_SLOTS,
     ACTION_LISTEN_NAME,
-    MAPPING_TYPE,
+    KEY_MAPPING_TYPE,
     REQUESTED_SLOT,
     SLOT_MAPPINGS,
     SlotMappingType,
@@ -158,7 +158,9 @@ class FormAction(LoopAction):
         domain_slots = domain.as_dict().get(KEY_SLOTS, {})
         for slot in domain.required_slots_for_form(self.name()):
             for slot_mapping in domain_slots.get(slot, {}).get(SLOT_MAPPINGS, []):
-                if slot_mapping.get(MAPPING_TYPE) == str(SlotMappingType.FROM_ENTITY):
+                if slot_mapping.get(KEY_MAPPING_TYPE) == str(
+                    SlotMappingType.FROM_ENTITY
+                ):
                     mapping_as_string = json.dumps(slot_mapping, sort_keys=True)
                     if mapping_as_string in unique_entity_slot_mappings:
                         unique_entity_slot_mappings.remove(mapping_as_string)

rasa/core/channels/voice_ready/audiocodes.py

@@ -1,9 +1,11 @@
+import asyncio
 import copy
 import json
 import uuid
+from collections import defaultdict
 from dataclasses import asdict
 from datetime import datetime, timedelta, timezone
-from typing import Any, Awaitable, Callable, Dict, List, Optional, Text, Union
+from typing import Any, Awaitable, Callable, Dict, List, Optional, Set, Text, Union
 
 import structlog
 from jsonschema import ValidationError, validate
@@ -223,6 +225,16 @@ class AudiocodesInput(InputChannel):
         self.scheduler_job = None
         self.keep_alive = keep_alive
         self.keep_alive_expiration_factor = keep_alive_expiration_factor
+        self.background_tasks: Dict[Text, Set[asyncio.Task]] = defaultdict(set)
+
+    def _create_task(self, conversation_id: Text, coro: Awaitable[Any]) -> asyncio.Task:
+        """Create and track an asyncio task for a conversation."""
+        task: asyncio.Task = asyncio.create_task(coro)
+        self.background_tasks[conversation_id].add(task)
+        task.add_done_callback(
+            lambda t: self.background_tasks[conversation_id].discard(t)
+        )
+        return task
 
     async def _set_scheduler_job(self) -> None:
         if self.scheduler_job:
@@ -251,11 +263,20 @@ class AudiocodesInput(InputChannel):
         )
         now = datetime.now(timezone.utc)
         delta = timedelta(seconds=self.keep_alive * self.keep_alive_expiration_factor)
-        self.conversations = {
-            k: v
-            for k, v in self.conversations.items()
-            if v.is_active_conversation(now, delta)
-        }
+
+        # clean up conversations
+        inactive = [
+            conv_id
+            for conv_id, conv in self.conversations.items()
+            if not conv.is_active_conversation(now, delta)
+        ]
+
+        # cancel tasks and remove conversations
+        for conv_id in inactive:
+            for task in self.background_tasks[conv_id]:
+                task.cancel()
+            self.background_tasks.pop(conv_id, None)
+            self.conversations.pop(conv_id, None)
 
     def handle_start_conversation(self, body: Dict[Text, Any]) -> Dict[Text, Any]:
         conversation_id = body["conversation"]
@@ -347,31 +368,29 @@ class AudiocodesInput(InputChannel):
             structlogger.debug("audiocodes.on_activities", conversation=conversation_id)
             conversation = self._get_conversation(request.token, conversation_id)
             if conversation is None:
+                structlogger.warning(
+                    "audiocodes.on_activities.no_conversation", request=request.json
+                )
                 return response.json({})
             elif conversation.ws:
                 ac_output: Union[WebsocketOutput, AudiocodesOutput] = WebsocketOutput(
                     conversation.ws, conversation_id
                 )
-                await conversation.handle_activities(
-                    request.json,
-                    output_channel=ac_output,
-                    on_new_message=on_new_message,
-                )
-                return response.json({})
+                response_json = {}
             else:
                 # handle non websocket case where messages get returned in json
                 ac_output = AudiocodesOutput()
-                await conversation.handle_activities(
-                    request.json,
-                    output_channel=ac_output,
-                    on_new_message=on_new_message,
-                )
-                return response.json(
-                    {
-                        "conversation": conversation_id,
-                        "activities": ac_output.messages,
-                    }
-                )
+                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, ac_output, on_new_message),
+            )
+            return response.json(response_json)
 
         @ac_webhook.route(
             "/conversation/<conversation_id>/disconnect", methods=["POST"]

rasa/core/channels/voice_stream/tts/azure.py

@@ -81,7 +81,8 @@ class AzureTTS(TTSEngine[AzureTTSConfig]):
     @staticmethod
     def create_request_body(text: str, conf: AzureTTSConfig) -> str:
         return f"""
-        <speak version='1.0' xml:lang='{conf.language}'>
+        <speak version='1.0' xml:lang='{conf.language}' xmlns:mstts='http://www.w3.org/2001/mstts'
+                xmlns='http://www.w3.org/2001/10/synthesis'>
             <voice xml:lang='{conf.language}' name='{conf.voice}'>
                 {text}
             </voice>

rasa/core/migrate.py

@@ -14,7 +14,7 @@ from rasa.shared.constants import (
 )
 from rasa.shared.core.constants import (
     ACTIVE_LOOP,
-    MAPPING_TYPE,
+    KEY_MAPPING_TYPE,
     REQUESTED_SLOT,
     SLOT_MAPPINGS,
     SlotMappingType,
@@ -43,7 +43,7 @@ def _create_back_up(domain_file: Path, backup_location: Path) -> Dict[Text, Any]
 def _get_updated_mapping_condition(
     condition: Dict[Text, Text], mapping: Dict[Text, Any], slot_name: Text
 ) -> Dict[Text, Text]:
-    if mapping.get(MAPPING_TYPE) not in [
+    if mapping.get(KEY_MAPPING_TYPE) not in [
         str(SlotMappingType.FROM_ENTITY),
         str(SlotMappingType.FROM_TRIGGER_INTENT),
     ]:

rasa/core/policies/flows/flow_executor.py

@@ -23,6 +23,7 @@ from rasa.core.policies.flows.flow_step_result import (
 )
 from rasa.dialogue_understanding.commands import CancelFlowCommand
 from rasa.dialogue_understanding.patterns.cancel import CancelPatternFlowStackFrame
+from rasa.dialogue_understanding.patterns.clarify import ClarifyPatternFlowStackFrame
 from rasa.dialogue_understanding.patterns.collect_information import (
     CollectInformationPatternFlowStackFrame,
 )
@@ -50,6 +51,7 @@ from rasa.dialogue_understanding.stack.frames.flow_stack_frame import (
 )
 from rasa.dialogue_understanding.stack.utils import (
     top_user_flow_frame,
+    user_flows_on_the_stack,
 )
 from rasa.shared.constants import RASA_PATTERN_HUMAN_HANDOFF
 from rasa.shared.core.constants import ACTION_LISTEN_NAME, SlotMappingType
@@ -272,6 +274,28 @@ def trigger_pattern_continue_interrupted(
     return events
 
 
+def trigger_pattern_clarification(
+    current_frame: DialogueStackFrame, stack: DialogueStack, flows: FlowsList
+) -> None:
+    """Trigger the pattern to clarify which topic to continue if needed."""
+    if not isinstance(current_frame, UserFlowStackFrame):
+        return None
+
+    if current_frame.frame_type == FlowStackFrameType.CALL:
+        # we want to return to the flow that called the current flow
+        return None
+
+    pending_flows = [
+        flows.flow_by_id(frame.flow_id)
+        for frame in stack.frames
+        if isinstance(frame, UserFlowStackFrame)
+        and frame.flow_id != current_frame.flow_id
+    ]
+
+    flow_names = [flow.readable_name() for flow in pending_flows if flow is not None]
+    stack.push(ClarifyPatternFlowStackFrame(names=flow_names))
+
+
 def trigger_pattern_completed(
     current_frame: DialogueStackFrame, stack: DialogueStack, flows: FlowsList
 ) -> None:
@@ -669,7 +693,15 @@ def _run_end_step(
     structlogger.debug("flow.step.run.flow_end")
     current_frame = stack.pop()
     trigger_pattern_completed(current_frame, stack, flows)
-    resumed_events = trigger_pattern_continue_interrupted(current_frame, stack, flows)
+    resumed_events = []
+    if len(user_flows_on_the_stack(stack)) > 1:
+        # if there are more user flows on the stack,
+        # we need to trigger the pattern clarify
+        trigger_pattern_clarification(current_frame, stack, flows)
+    else:
+        resumed_events = trigger_pattern_continue_interrupted(
+            current_frame, stack, flows
+        )
     reset_events: List[Event] = reset_scoped_slots(current_frame, flow, tracker)
     return ContinueFlowWithNextStep(
         events=initial_events + reset_events + resumed_events, has_flow_ended=True

rasa/dialogue_understanding/commands/can_not_handle_command.py

@@ -74,7 +74,7 @@ class CannotHandleCommand(Command):
 
     def to_dsl(self) -> str:
         """Converts the command to a DSL string."""
-        return "cannot handle"
+        return "CannotHandle()"
 
     @classmethod
     def from_dsl(cls, match: re.Match, **kwargs: Any) -> CannotHandleCommand:
@@ -86,4 +86,4 @@ class CannotHandleCommand(Command):
 
     @staticmethod
     def regex_pattern() -> str:
-        return r"^cannot handle$"
+        return r"CannotHandle\(\)"

rasa/dialogue_understanding/commands/cancel_flow_command.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import copy
 import re
 from dataclasses import dataclass
 from typing import Any, Dict, List
@@ -8,8 +9,11 @@ import structlog
 
 from rasa.dialogue_understanding.commands.command import Command
 from rasa.dialogue_understanding.patterns.cancel import CancelPatternFlowStackFrame
+from rasa.dialogue_understanding.patterns.clarify import ClarifyPatternFlowStackFrame
 from rasa.dialogue_understanding.stack.dialogue_stack import DialogueStack
-from rasa.dialogue_understanding.stack.frames import UserFlowStackFrame
+from rasa.dialogue_understanding.stack.frames import (
+    UserFlowStackFrame,
+)
 from rasa.dialogue_understanding.stack.frames.flow_stack_frame import FlowStackFrameType
 from rasa.dialogue_understanding.stack.utils import top_user_flow_frame
 from rasa.shared.core.events import Event, FlowCancelled
@@ -89,7 +93,8 @@ class CancelFlowCommand(Command):
         original_stack = original_tracker.stack
 
         applied_events: List[Event] = []
-
+        # capture the top frame before we push new frames onto the stack
+        initial_top_frame = stack.top()
         user_frame = top_user_flow_frame(original_stack)
         current_flow = user_frame.flow(all_flows) if user_frame else None
 
@@ -114,6 +119,21 @@ class CancelFlowCommand(Command):
         if user_frame:
             applied_events.append(FlowCancelled(user_frame.flow_id, user_frame.step_id))
 
+        if initial_top_frame and isinstance(
+            initial_top_frame, ClarifyPatternFlowStackFrame
+        ):
+            structlogger.debug(
+                "command_executor.cancel_flow.cancel_clarification_options",
+                clarification_options=initial_top_frame.clarification_options,
+            )
+            applied_events += cancel_all_pending_clarification_options(
+                initial_top_frame,
+                original_stack,
+                canceled_frames,
+                all_flows,
+                stack,
+            )
+
         return applied_events + tracker.create_stack_updated_events(stack)
 
     def __hash__(self) -> int:
@@ -124,7 +144,7 @@ class CancelFlowCommand(Command):
 
     def to_dsl(self) -> str:
         """Converts the command to a DSL string."""
-        return "cancel"
+        return "CancelFlow()"
 
     @classmethod
     def from_dsl(cls, match: re.Match, **kwargs: Any) -> CancelFlowCommand:
@@ -133,4 +153,42 @@ class CancelFlowCommand(Command):
 
     @staticmethod
     def regex_pattern() -> str:
-        return r"^cancel$"
+        return r"CancelFlow\(\)"
+
+
+def cancel_all_pending_clarification_options(
+    initial_top_frame: ClarifyPatternFlowStackFrame,
+    original_stack: DialogueStack,
+    canceled_frames: List[str],
+    all_flows: FlowsList,
+    stack: DialogueStack,
+) -> List[FlowCancelled]:
+    """Cancel all pending clarification options.
+
+    This is a special case when the assistant asks the user to clarify
+    which pending digression flow to start after the completion of an active flow.
+    If the user chooses to cancel all options, this function takes care of
+    updating the stack by removing all pending flow stack frames
+    listed as clarification options.
+    """
+    clarification_names = set(initial_top_frame.names)
+    to_be_canceled_frames = []
+    applied_events = []
+    for frame in reversed(original_stack.frames):
+        if frame.frame_id in canceled_frames:
+            continue
+
+        to_be_canceled_frames.append(frame.frame_id)
+        if isinstance(frame, UserFlowStackFrame):
+            readable_flow_name = frame.flow(all_flows).readable_name()
+            if readable_flow_name in clarification_names:
+                stack.push(
+                    CancelPatternFlowStackFrame(
+                        canceled_name=readable_flow_name,
+                        canceled_frames=copy.deepcopy(to_be_canceled_frames),
+                    )
+                )
+                applied_events.append(FlowCancelled(frame.flow_id, frame.step_id))
+                to_be_canceled_frames.clear()
+
+    return applied_events

rasa/dialogue_understanding/commands/change_flow_command.py

@@ -48,7 +48,7 @@ class ChangeFlowCommand(Command):
 
     def to_dsl(self) -> str:
         """Converts the command to a DSL string."""
-        return "change"
+        return "ChangeFlow()"
 
     @staticmethod
     def from_dsl(match: re.Match, **kwargs: Any) -> ChangeFlowCommand:
@@ -57,4 +57,4 @@ class ChangeFlowCommand(Command):
 
     @staticmethod
     def regex_pattern() -> str:
-        return r"^change"
+        return r"ChangeFlow\(\)"

rasa/dialogue_understanding/commands/chit_chat_answer_command.py

@@ -59,7 +59,7 @@ class ChitChatAnswerCommand(FreeFormAnswerCommand):
 
     def to_dsl(self) -> str:
         """Converts the command to a DSL string."""
-        return "chat"
+        return "ChitChat()"
 
     @classmethod
     def from_dsl(cls, match: re.Match, **kwargs: Any) -> ChitChatAnswerCommand:
@@ -68,4 +68,4 @@ class ChitChatAnswerCommand(FreeFormAnswerCommand):
 
     @staticmethod
     def regex_pattern() -> str:
-        return r"^chat$"
+        return r"ChitChat\(\)"

rasa/dialogue_understanding/commands/clarify_command.py

@@ -89,7 +89,7 @@ class ClarifyCommand(Command):
 
     def to_dsl(self) -> str:
         """Converts the command to a DSL string."""
-        return f"clarify {' '.join(self.options)}"
+        return f"Clarify({', '.join(self.options)})"
 
     @classmethod
     def from_dsl(cls, match: re.Match, **kwargs: Any) -> Optional[ClarifyCommand]:
@@ -99,4 +99,4 @@ class ClarifyCommand(Command):
 
     @staticmethod
     def regex_pattern() -> str:
-        return r"^clarify([\"\'a-zA-Z0-9_, ]*)$"
+        return r"Clarify\(([\"\'a-zA-Z0-9_, ]*)\)"

rasa/dialogue_understanding/commands/correct_slots_command.py

@@ -31,6 +31,7 @@ class CorrectedSlot:
 
     name: str
     value: Any
+    filled_by: Optional[str] = None
 
 
 @dataclass
@@ -54,7 +55,9 @@ class CorrectSlotsCommand(Command):
         try:
             return CorrectSlotsCommand(
                 corrected_slots=[
-                    CorrectedSlot(s["name"], value=s["value"])
+                    CorrectedSlot(
+                        s["name"], value=s["value"], filled_by=s.get("filled_by", None)
+                    )
                     for s in data["corrected_slots"]
                 ]
             )
@@ -135,7 +138,10 @@ class CorrectSlotsCommand(Command):
         proposed_slots = {}
         for corrected_slot in self.corrected_slots:
             if tracker.get_slot(corrected_slot.name) != corrected_slot.value:
-                proposed_slots[corrected_slot.name] = corrected_slot.value
+                proposed_slots[corrected_slot.name] = {
+                    "value": corrected_slot.value,
+                    "filled_by": corrected_slot.filled_by,
+                }
             else:
                 structlogger.debug(
                     "command_executor.skip_correction.slot_already_set", command=self
@@ -240,6 +246,9 @@ class CorrectSlotsCommand(Command):
             corrected_slots=proposed_slots,
             reset_flow_id=earliest_collect.flow_id if earliest_collect else None,
             reset_step_id=earliest_collect.step.id if earliest_collect else None,
+            new_slot_values=[
+                value.get("value") for slot, value in proposed_slots.items()
+            ],
         )
 
     def run_command_on_tracker(