rasa-pro 3.12.6.dev1__py3-none-any.whl → 3.12.7__py3-none-any.whl

rasa/core/channels/inspector/src/components/DiagramFlow.tsx

@@ -2,6 +2,7 @@ import { Box, Button, Flex, Heading, Text } from "@chakra-ui/react";
 import mermaid from "mermaid";
 import { useOurTheme } from "../theme";
 import { formatFlow } from "../helpers/formatters";
+import { restartConversation } from "../helpers/conversation";
 import { useEffect, useRef, useState } from "react";
 import { Flow, Slot, Stack } from "../types";
 import { NoActiveFlow } from "./NoActiveFlow";
@@ -51,11 +52,7 @@ export const DiagramFlow = ({ stackFrame, stepTrail, flows, slots }: Props) => {
   }, [text, flow, slots, stackFrame]);
 
   const handleRestartConversation = () => {
-    // unset the sender id from the query parameters
-    const url = new URL(window.location.href);
-    url.searchParams.delete("sender");
-    window.history.pushState(null, "", url.toString());
-    location.reload();
+    restartConversation();
   };
 
   const scrollSx = {

rasa/core/channels/inspector/src/helpers/conversation.ts

@@ -0,0 +1,16 @@
+export const restartConversation = () => {
+  // unset the sender id from the query parameters
+  const url = new URL(window.location.href);
+  url.searchParams.delete("sender");
+  window.history.pushState(null, "", url.toString());
+  location.reload();
+};
+
+// Make the function available on the window object
+declare global {
+  interface Window {
+    restartConversation: typeof restartConversation;
+  }
+}
+
+window.restartConversation = restartConversation;

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

@@ -5,7 +5,7 @@ export interface Slot {
 }
 
 export interface Event {
-  event: "user" | "bot" | "flow_completed" | "flow_started" | "stack" | "restart";
+  event: "user" | "bot" | "flow_completed" | "flow_started" | "stack" | "restart" | "session_ended";
   text?: string;
   timestamp: string;
   update?: string;

rasa/core/channels/voice_ready/audiocodes.py

@@ -96,10 +96,13 @@ class Conversation:
             event_params = {"value": event["value"]}
             text += json.dumps(event_params)
         else:
-            structlogger.warning(
-                "audiocodes.handle.event.unknown_event", event_payload=event
-            )
-            return ""
+            # handle other events described by Audiocodes
+            # https://techdocs.audiocodes.com/voice-ai-connect/#VAIG_Combined/inactivity-detection.htm?TocPath=Bot%2520integration%257CReceiving%2520notifications%257C_____3
+            text = f"{INTENT_MESSAGE_PREFIX}vaig_event_{event['name']}"
+            event_params = {**event.get("parameters", {})}
+            if "value" in event:
+                event_params["value"] = event["value"]
+            text += json.dumps(event_params)
 
         return text
 
@@ -115,11 +118,21 @@ class Conversation:
     async def handle_activities(
         self,
         message: Dict[Text, Any],
+        input_channel_name: str,
         output_channel: OutputChannel,
         on_new_message: Callable[[UserMessage], Awaitable[Any]],
     ) -> None:
         """Handle activities sent by Audiocodes."""
         structlogger.debug("audiocodes.handle.activities")
+        if input_channel_name == "":
+            structlogger.warning(
+                "audiocodes.handle.activities.empty_input_channel_name",
+                event_info=(
+                    "Audiocodes input channel name is empty "
+                    f"for conversation {self.conversation_id}"
+                ),
+            )
+
         for activity in message["activities"]:
             text = None
             if activity[ACTIVITY_ID_KEY] in self.activity_ids:
@@ -143,6 +156,7 @@ class Conversation:
             metadata = self.get_metadata(activity)
             user_msg = UserMessage(
                 text=text,
+                input_channel=input_channel_name,
                 output_channel=output_channel,
                 sender_id=self.conversation_id,
                 metadata=metadata,
@@ -394,7 +408,12 @@ class AudiocodesInput(InputChannel):
             # start a background task to handle activities
             self._create_task(
                 conversation_id,
-                conversation.handle_activities(request.json, ac_output, on_new_message),
+                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)
 
@@ -407,23 +426,9 @@ class AudiocodesInput(InputChannel):
             Example of payload:
             {"conversation": <conversation_id>, "reason": Optional[Text]}.
             """
-            self._get_conversation(request.token, conversation_id)
-            reason = {"reason": request.json.get("reason")}
-            await on_new_message(
-                UserMessage(
-                    text=f"{INTENT_MESSAGE_PREFIX}session_end",
-                    output_channel=None,
-                    sender_id=conversation_id,
-                    metadata=reason,
-                )
+            return await self._handle_disconnect(
+                request, conversation_id, on_new_message
             )
-            del self.conversations[conversation_id]
-            structlogger.debug(
-                "audiocodes.disconnect",
-                conversation=conversation_id,
-                request=request.json,
-            )
-            return response.json({})
 
         @ac_webhook.route("/conversation/<conversation_id>/keepalive", methods=["POST"])
         async def keepalive(request: Request, conversation_id: Text) -> HTTPResponse:
@@ -438,6 +443,32 @@ class AudiocodesInput(InputChannel):
 
         return ac_webhook
 
+    async def _handle_disconnect(
+        self,
+        request: Request,
+        conversation_id: Text,
+        on_new_message: Callable[[UserMessage], Awaitable[Any]],
+    ) -> HTTPResponse:
+        """Triggered when the call is disconnected."""
+        self._get_conversation(request.token, conversation_id)
+        reason = {"reason": request.json.get("reason")}
+        await on_new_message(
+            UserMessage(
+                text=f"{INTENT_MESSAGE_PREFIX}session_end",
+                input_channel=self.name(),
+                output_channel=None,
+                sender_id=conversation_id,
+                metadata=reason,
+            )
+        )
+        del self.conversations[conversation_id]
+        structlogger.debug(
+            "audiocodes.disconnect",
+            conversation=conversation_id,
+            request=request.json,
+        )
+        return response.json({})
+
 
 class AudiocodesOutput(OutputChannel):
     @classmethod
@@ -445,6 +476,7 @@ class AudiocodesOutput(OutputChannel):
         return CHANNEL_NAME
 
     def __init__(self) -> None:
+        super().__init__()
         self.messages: List[Dict] = []
 
     async def add_message(self, message: Dict) -> None:

rasa/core/channels/voice_ready/jambonz.py

@@ -5,8 +5,14 @@ from sanic import Blueprint, Websocket, response  # type: ignore[attr-defined]
 from sanic.request import Request
 from sanic.response import HTTPResponse
 
-from rasa.core.channels.channel import InputChannel, OutputChannel, UserMessage
+from rasa.core.channels.channel import (
+    InputChannel,
+    OutputChannel,
+    UserMessage,
+    requires_basic_auth,
+)
 from rasa.core.channels.voice_ready.jambonz_protocol import (
+    CHANNEL_NAME,
     send_ws_hangup_message,
     send_ws_text_message,
     websocket_message_handler,
@@ -18,8 +24,6 @@ from rasa.utils.io import remove_emojis
 
 structlogger = structlog.get_logger()
 
-CHANNEL_NAME = "jambonz"
-
 DEFAULT_HANGUP_DELAY_SECONDS = 1
 
 
@@ -32,12 +36,27 @@ class JambonzVoiceReadyInput(InputChannel):
 
     @classmethod
     def from_credentials(cls, credentials: Optional[Dict[Text, Any]]) -> InputChannel:
-        return cls()
+        if not credentials:
+            return cls()
+
+        username = credentials.get("username")
+        password = credentials.get("password")
+        if (username is None) != (password is None):
+            raise RasaException(
+                "In Jambonz channel, either both username and password "
+                "or neither should be provided. "
+            )
 
-    def __init__(self) -> None:
+        return cls(username, password)
+
+    def __init__(
+        self, username: Optional[Text] = None, password: Optional[Text] = None
+    ) -> None:
         """Initializes the JambonzVoiceReadyInput channel."""
         mark_as_beta_feature("Jambonz Channel")
         validate_voice_license_scope()
+        self.username = username
+        self.password = password
 
     def blueprint(
         self, on_new_message: Callable[[UserMessage], Awaitable[Any]]
@@ -50,6 +69,7 @@ class JambonzVoiceReadyInput(InputChannel):
             return response.json({"status": "ok"})
 
         @jambonz_webhook.websocket("/websocket", subprotocols=["ws.jambonz.org"])  # type: ignore
+        @requires_basic_auth(self.username, self.password)
         async def websocket(request: Request, ws: Websocket) -> None:
             """Triggered on new websocket connection."""
             async for message in ws:

rasa/core/channels/voice_ready/jambonz_protocol.py

@@ -10,6 +10,7 @@ from rasa.core.channels.channel import UserMessage
 from rasa.core.channels.voice_ready.utils import CallParameters
 
 structlogger = structlog.get_logger()
+CHANNEL_NAME = "jambonz"
 
 
 @dataclass
@@ -206,6 +207,7 @@ async def handle_new_session(
         output_channel=output_channel,
         sender_id=message.call_sid,
         metadata=asdict(message.call_params),
+        input_channel=CHANNEL_NAME,
     )
     await send_config_ack(message.message_id, ws)
     await on_new_message(user_msg)
@@ -238,6 +240,7 @@ async def handle_gather_completed(
         output_channel = JambonzWebsocketOutput(ws, transcript_result.call_sid)
         user_msg = UserMessage(
             text=most_likely_transcript.text,
+            input_channel=CHANNEL_NAME,
             output_channel=output_channel,
             sender_id=transcript_result.call_sid,
             metadata={},
@@ -288,6 +291,7 @@ async def handle_call_status(
         output_channel = JambonzWebsocketOutput(ws, call_status.call_sid)
         user_msg = UserMessage(
             text="/session_end",
+            input_channel=CHANNEL_NAME,
             output_channel=output_channel,
             sender_id=call_status.call_sid,
             metadata={},

rasa/core/channels/voice_ready/twilio_voice.py

@@ -13,14 +13,19 @@ from rasa.core.channels.channel import (
     CollectingOutputChannel,
     InputChannel,
     UserMessage,
+    create_auth_requested_response_provider,
+    requires_basic_auth,
 )
 from rasa.core.channels.voice_ready.utils import CallParameters
 from rasa.shared.core.events import BotUttered
-from rasa.shared.exceptions import InvalidConfigException
+from rasa.shared.exceptions import InvalidConfigException, RasaException
 
 logger = structlog.get_logger(__name__)
 
 
+TWILIO_VOICE_PATH = "webhooks/twilio_voice/webhook"
+
+
 def map_call_params(form: RequestParameters) -> CallParameters:
     """Map the Audiocodes parameters to the CallParameters dataclass."""
     return CallParameters(
@@ -120,6 +125,14 @@ class TwilioVoiceInput(InputChannel):
         """Load custom configurations."""
         credentials = credentials or {}
 
+        username = credentials.get("username")
+        password = credentials.get("password")
+        if (username is None) != (password is None):
+            raise RasaException(
+                "In TwilioVoice channel, either both username and password "
+                "or neither should be provided. "
+            )
+
         return cls(
             credentials.get(
                 "reprompt_fallback_phrase",
@@ -129,6 +142,8 @@ class TwilioVoiceInput(InputChannel):
             credentials.get("speech_timeout", "5"),
             credentials.get("speech_model", "default"),
             credentials.get("enhanced", "false"),
+            username=username,
+            password=password,
         )
 
     def __init__(
@@ -138,6 +153,8 @@ class TwilioVoiceInput(InputChannel):
         speech_timeout: Text = "5",
         speech_model: Text = "default",
         enhanced: Text = "false",
+        username: Optional[Text] = None,
+        password: Optional[Text] = None,
     ) -> None:
         """Creates a connection to Twilio voice.
 
@@ -153,6 +170,8 @@ class TwilioVoiceInput(InputChannel):
         self.speech_timeout = speech_timeout
         self.speech_model = speech_model
         self.enhanced = enhanced
+        self.username = username
+        self.password = password
 
         self._validate_configuration()
 
@@ -161,6 +180,9 @@ class TwilioVoiceInput(InputChannel):
         if self.assistant_voice not in self.SUPPORTED_VOICES:
             self._raise_invalid_voice_exception()
 
+        if (self.username is None) != (self.password is None):
+            self._raise_invalid_credentials_exception()
+
         try:
             int(self.speech_timeout)
         except ValueError:
@@ -246,6 +268,13 @@ class TwilioVoiceInput(InputChannel):
             return response.json({"status": "ok"})
 
         @twilio_voice_webhook.route("/webhook", methods=["POST"])
+        @requires_basic_auth(
+            username=self.username,
+            password=self.password,
+            auth_request_provider=create_auth_requested_response_provider(
+                TWILIO_VOICE_PATH
+            ),
+        )
         async def receive(request: Request) -> HTTPResponse:
             sender_id = request.form.get("From")
             text = request.form.get("SpeechResult")
@@ -310,6 +339,11 @@ class TwilioVoiceInput(InputChannel):
                 twilio_response = self._build_twilio_voice_response(
                     [{"text": last_response_text}]
                 )
+
+            logger.debug(
+                "twilio_voice.webhook.twilio_response",
+                twilio_response=str(twilio_response),
+            )
             return response.text(str(twilio_response), content_type="text/xml")
 
         return twilio_voice_webhook
@@ -329,6 +363,13 @@ class TwilioVoiceInput(InputChannel):
             enhanced=self.enhanced,
         )
 
+        if not messages:
+            # In case bot has a greet message disabled
+            # or if the bot is not configured to send an initial message
+            # we need to send a voice response with speech settings
+            voice_response.append(gather)
+            return voice_response
+
         # Add pauses between messages.
         # Add a listener to the last message to listen for user response.
         for i, message in enumerate(messages):
@@ -347,6 +388,12 @@ class TwilioVoiceInput(InputChannel):
 
         return voice_response
 
+    def _raise_invalid_credentials_exception(self) -> None:
+        raise InvalidConfigException(
+            "In TwilioVoice channel, either both username and password "
+            "or neither should be provided. "
+        )
+
 
 class TwilioVoiceCollectingOutputChannel(CollectingOutputChannel):
     """Output channel that collects send messages in a list.

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

@@ -54,13 +54,22 @@ class AzureTTS(TTSEngine[AzureTTSConfig]):
                     async for data in response.content.iter_chunked(1024):
                         yield self.engine_bytes_to_rasa_audio_bytes(data)
                     return
+                elif response.status == 401:
+                    structlogger.error(
+                        "azure.synthesize.rest.authentication_failed",
+                        status_code=response.status,
+                    )
+                    raise TTSError(
+                        f"Authentication failed. Please check your API key: {response.status}"  # noqa: E501
+                    )
                 else:
+                    response_text = await response.text()
                     structlogger.error(
                         "azure.synthesize.rest.failed",
                         status_code=response.status,
-                        msg=response.text(),
+                        msg=response_text,
                     )
-                    raise TTSError(f"TTS failed: {response.text()}")
+                    raise TTSError(f"TTS failed: {response_text}")
         except ClientConnectorError as e:
             raise TTSError(e)
         except TimeoutError as e:

rasa/core/channels/voice_stream/twilio_media_streams.py

@@ -1,7 +1,9 @@
+from __future__ import annotations
+
 import base64
 import json
 import uuid
-from typing import Any, Awaitable, Callable, Dict, Optional, Text, Tuple
+from typing import TYPE_CHECKING, Any, Awaitable, Callable, Dict, Optional, Text, Tuple
 
 import structlog
 from sanic import (  # type: ignore[attr-defined]
@@ -12,7 +14,11 @@ from sanic import (  # type: ignore[attr-defined]
     response,
 )
 
-from rasa.core.channels import UserMessage
+from rasa.core.channels import InputChannel, UserMessage
+from rasa.core.channels.channel import (
+    create_auth_requested_response_provider,
+    requires_basic_auth,
+)
 from rasa.core.channels.voice_ready.utils import CallParameters
 from rasa.core.channels.voice_stream.audio_bytes import RasaAudioBytes
 from rasa.core.channels.voice_stream.call_state import call_state
@@ -25,10 +31,24 @@ from rasa.core.channels.voice_stream.voice_channel import (
     VoiceInputChannel,
     VoiceOutputChannel,
 )
+from rasa.shared.exceptions import RasaException
+
+if TYPE_CHECKING:
+    from twilio.twiml.voice_response import VoiceResponse
 
 logger = structlog.get_logger(__name__)
 
 
+TWILIO_MEDIA_STREAMS_WEBHOOK_PATH = "webhooks/twilio_media_streams/webhook"
+TWILIO_MEDIA_STREAMS_WEBSOCKET_PATH = "webhooks/twilio_media_streams/websocket"
+
+
+CALL_SID_REQUEST_KEY = "CallSid"
+FROM_NUMBER_REQUEST_KEY = "From"
+TO_NUMBER_REQUEST_KEY = "To"
+DIRECTION_REQUEST_KEY = "Direction"
+
+
 def map_call_params(data: Dict[Text, Any]) -> CallParameters:
     """Map the twilio stream parameters to the CallParameters dataclass."""
     stream_sid = data["streamSid"]
@@ -77,6 +97,40 @@ class TwilioMediaStreamsOutputChannel(VoiceOutputChannel):
 
 
 class TwilioMediaStreamsInputChannel(VoiceInputChannel):
+    def __init__(
+        self,
+        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)
+        self.username = username
+        self.password = password
+
+    @classmethod
+    def from_credentials(cls, credentials: Optional[Dict[str, Any]]) -> InputChannel:
+        credentials = credentials or {}
+
+        username = credentials.get("username")
+        password = credentials.get("password")
+        if (username is None) != (password is None):
+            raise RasaException(
+                "In TwilioMediaStreams channel, either both username and password "
+                "or neither should be provided. "
+            )
+
+        return cls(
+            credentials["server_url"],
+            credentials["asr"],
+            credentials["tts"],
+            credentials.get("monitor_silence", False),
+            username=username,
+            password=password,
+        )
+
     @classmethod
     def name(cls) -> str:
         return "twilio_media_streams"
@@ -130,16 +184,6 @@ class TwilioMediaStreamsInputChannel(VoiceInputChannel):
             self.tts_cache,
         )
 
-    def websocket_stream_url(self) -> str:
-        """Returns the websocket stream URL."""
-        # depending on the config value, the url might contain http as a
-        # protocol or not - we'll make sure both work
-        if self.server_url.startswith("http"):
-            base_url = self.server_url.replace("http", "ws")
-        else:
-            base_url = f"wss://{self.server_url}"
-        return f"{base_url}/webhooks/twilio_media_streams/websocket"
-
     def blueprint(
         self, on_new_message: Callable[[UserMessage], Awaitable[Any]]
     ) -> Blueprint:
@@ -151,22 +195,20 @@ class TwilioMediaStreamsInputChannel(VoiceInputChannel):
             return response.json({"status": "ok"})
 
         @blueprint.route("/webhook", methods=["POST"])
+        @requires_basic_auth(
+            username=self.username,
+            password=self.password,
+            auth_request_provider=create_auth_requested_response_provider(
+                realm=TWILIO_MEDIA_STREAMS_WEBHOOK_PATH
+            ),
+        )
         async def receive(request: Request) -> HTTPResponse:
-            from twilio.twiml.voice_response import Connect, VoiceResponse
-
-            voice_response = VoiceResponse()
-            start = Connect()
-            stream = start.stream(url=self.websocket_stream_url())
-            # pass information about the call to the webhook - so we can
-            # store it in the input channel
-            stream.parameter(name="call_id", value=request.form.get("CallSid", None))
-            stream.parameter(name="user_phone", value=request.form.get("From", None))
-            stream.parameter(name="bot_phone", value=request.form.get("To", None))
-            stream.parameter(
-                name="direction", value=request.form.get("Direction", None)
-            )
+            voice_response = self._build_twilio_response(request)
 
-            voice_response.append(start)
+            logger.debug(
+                "twilio_media_streams.webhook.twilio_response",
+                twilio_response=str(voice_response),
+            )
 
             return response.text(str(voice_response), content_type="text/xml")
 
@@ -175,3 +217,36 @@ class TwilioMediaStreamsInputChannel(VoiceInputChannel):
             await self.run_audio_streaming(on_new_message, ws)
 
         return blueprint
+
+    def _websocket_stream_url(self) -> str:
+        """Returns the websocket stream URL."""
+        # depending on the config value, the url might contain http as a
+        # protocol or not - we'll make sure both work
+        if self.server_url.startswith("http"):
+            base_url = self.server_url.replace("http", "ws")
+        else:
+            base_url = f"wss://{self.server_url}"
+        return f"{base_url}/{TWILIO_MEDIA_STREAMS_WEBSOCKET_PATH}"
+
+    def _build_twilio_response(self, request: Request) -> VoiceResponse:
+        from twilio.twiml.voice_response import Connect, VoiceResponse
+
+        voice_response = VoiceResponse()
+        start = Connect()
+        stream = start.stream(url=self._websocket_stream_url())
+        # pass information about the call to the webhook - so we can
+        # store it in the input channel
+        stream.parameter(
+            name="call_id", value=request.form.get(CALL_SID_REQUEST_KEY, None)
+        )
+        stream.parameter(
+            name="user_phone", value=request.form.get(FROM_NUMBER_REQUEST_KEY, None)
+        )
+        stream.parameter(
+            name="bot_phone", value=request.form.get(TO_NUMBER_REQUEST_KEY, None)
+        )
+        stream.parameter(
+            name="direction", value=request.form.get(DIRECTION_REQUEST_KEY, None)
+        )
+        voice_response.append(start)
+        return voice_response

rasa/core/policies/flows/flow_executor.py

@@ -23,7 +23,6 @@ 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,
 )
@@ -51,7 +50,6 @@ 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 (
@@ -280,33 +278,6 @@ 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 in [
-        FlowStackFrameType.CALL,
-        FlowStackFrameType.INTERRUPT,
-    ]:
-        # we want to return to the flow that called
-        # the current flow or the flow that was interrupted
-        # by 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:
@@ -675,15 +646,9 @@ def _run_end_step(
     structlogger.debug("flow.step.run.flow_end")
     current_frame = stack.pop()
     trigger_pattern_completed(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, tracker
-        )
+    resumed_events = trigger_pattern_continue_interrupted(
+        current_frame, stack, flows, tracker
+    )
     reset_events: List[Event] = reset_scoped_slots(current_frame, flow, tracker)
     return ContinueFlowWithNextStep(
         events=initial_events + reset_events + resumed_events, has_flow_ended=True