rasa-pro 3.9.17__py3-none-any.whl → 3.10.3__py3-none-any.whl

rasa/core/policies/enterprise_search_policy.py

@@ -8,6 +8,11 @@ import structlog
 from jinja2 import Template
 from pydantic import ValidationError
 
+from rasa.shared.providers.embedding._langchain_embedding_client_adapter import (
+    _LangchainEmbeddingClientAdapter,
+)
+from rasa.shared.providers.llm.llm_client import LLMClient
+
 import rasa.shared.utils.io
 from rasa.telemetry import (
     track_enterprise_search_policy_predict,
@@ -19,6 +24,7 @@ from rasa.core.constants import (
     POLICY_MAX_HISTORY,
     POLICY_PRIORITY,
     SEARCH_POLICY_PRIORITY,
+    UTTER_SOURCE_METADATA_KEY,
 )
 from rasa.core.policies.policy import Policy, PolicyPrediction
 from rasa.core.utils import AvailableEndpoints
@@ -39,13 +45,23 @@ from rasa.engine.storage.resource import Resource
 from rasa.engine.storage.storage import ModelStorage
 from rasa.graph_components.providers.forms_provider import Forms
 from rasa.graph_components.providers.responses_provider import Responses
+from rasa.shared.constants import (
+    EMBEDDINGS_CONFIG_KEY,
+    LLM_CONFIG_KEY,
+    MODEL_CONFIG_KEY,
+    MODEL_NAME_CONFIG_KEY,
+    PROMPT_CONFIG_KEY,
+    PROVIDER_CONFIG_KEY,
+    OPENAI_PROVIDER,
+    TIMEOUT_CONFIG_KEY,
+)
 from rasa.shared.core.constants import (
     ACTION_CANCEL_FLOW,
     ACTION_SEND_TEXT_NAME,
     DEFAULT_SLOT_NAMES,
 )
 from rasa.shared.core.domain import Domain
-from rasa.shared.core.events import Event
+from rasa.shared.core.events import Event, UserUttered, BotUttered
 from rasa.shared.core.generator import TrackerWithCachedStates
 from rasa.shared.core.trackers import DialogueStateTracker, EventVerbosity
 from rasa.shared.nlu.training_data.training_data import TrainingData
@@ -59,6 +75,7 @@ from rasa.shared.utils.llm import (
     llm_factory,
     sanitize_message_for_prompt,
     tracker_as_readable_transcript,
+    try_instantiate_llm_client,
 )
 from rasa.core.information_retrieval.faiss import FAISS_Store
 from rasa.core.information_retrieval import (
@@ -70,7 +87,6 @@ from rasa.core.information_retrieval import (
 
 if TYPE_CHECKING:
     from langchain.schema.embeddings import Embeddings
-    from langchain.llms.base import BaseLLM
     from rasa.core.featurizers.tracker_featurizers import TrackerFeaturizer
 
 from rasa.utils.log_utils import log_llm
@@ -86,6 +102,7 @@ VECTOR_STORE_THRESHOLD_PROPERTY = "threshold"
 TRACE_TOKENS_PROPERTY = "trace_prompt_tokens"
 CITATION_ENABLED_PROPERTY = "citation_enabled"
 USE_LLM_PROPERTY = "use_generative_llm"
+MAX_MESSAGES_IN_QUERY_KEY = "max_messages_in_query"
 
 DEFAULT_VECTOR_STORE_TYPE = "faiss"
 DEFAULT_VECTOR_STORE_THRESHOLD = 0.0
@@ -96,23 +113,24 @@ DEFAULT_VECTOR_STORE = {
 }
 
 DEFAULT_LLM_CONFIG = {
-    "_type": "openai",
-    "request_timeout": 10,
+    PROVIDER_CONFIG_KEY: OPENAI_PROVIDER,
+    MODEL_CONFIG_KEY: DEFAULT_OPENAI_CHAT_MODEL_NAME,
+    TIMEOUT_CONFIG_KEY: 10,
     "temperature": 0.0,
     "max_tokens": 256,
-    "model_name": DEFAULT_OPENAI_CHAT_MODEL_NAME,
     "max_retries": 1,
 }
 
 DEFAULT_EMBEDDINGS_CONFIG = {
-    "_type": "openai",
+    PROVIDER_CONFIG_KEY: OPENAI_PROVIDER,
     "model": DEFAULT_OPENAI_EMBEDDING_MODEL_NAME,
 }
 
-EMBEDDINGS_CONFIG_KEY = "embeddings"
-LLM_CONFIG_KEY = "llm"
 ENTERPRISE_SEARCH_PROMPT_FILE_NAME = "enterprise_search_policy_prompt.jinja2"
 
+SEARCH_RESULTS_METADATA_KEY = "search_results"
+SEARCH_QUERY_METADATA_KEY = "search_query"
+
 DEFAULT_ENTERPRISE_SEARCH_PROMPT_TEMPLATE = importlib.resources.read_text(
     "rasa.core.policies", "enterprise_search_prompt_template.jinja2"
 )
@@ -179,26 +197,42 @@ class EnterpriseSearchPolicy(Policy):
         """Constructs a new Policy object."""
         super().__init__(config, model_storage, resource, execution_context, featurizer)
 
+        # Vector store object and configuration
         self.vector_store = vector_store
         self.vector_store_config = config.get(
             VECTOR_STORE_PROPERTY, DEFAULT_VECTOR_STORE
         )
-        self.llm_config = self.config.get(LLM_CONFIG_KEY, DEFAULT_LLM_CONFIG)
+        # Embeddings configuration for encoding the search query
         self.embeddings_config = self.config.get(
             EMBEDDINGS_CONFIG_KEY, DEFAULT_EMBEDDINGS_CONFIG
         )
+        # Maximum number of turns to include in the prompt
         self.max_history = self.config.get(POLICY_MAX_HISTORY)
-        self.prompt_template = prompt_template or get_prompt_template(
-            self.config.get("prompt"),
-            DEFAULT_ENTERPRISE_SEARCH_PROMPT_TEMPLATE,
-        )
+
+        # Maximum number of messages to include in the search query
+        self.max_messages_in_query = self.config.get(MAX_MESSAGES_IN_QUERY_KEY, 2)
+
+        # LLM Configuration for response generation
+        self.llm_config = self.config.get(LLM_CONFIG_KEY, DEFAULT_LLM_CONFIG)
+
+        # boolean to enable/disable tracing of prompt tokens
         self.trace_prompt_tokens = self.config.get(TRACE_TOKENS_PROPERTY, False)
+
+        # boolean to enable/disable the use of LLM for response generation
         self.use_llm = self.config.get(USE_LLM_PROPERTY, True)
+
+        # boolean to enable/disable citation generation
         self.citation_enabled = self.config.get(CITATION_ENABLED_PROPERTY, False)
+
+        self.prompt_template = prompt_template or get_prompt_template(
+            self.config.get(PROMPT_CONFIG_KEY),
+            DEFAULT_ENTERPRISE_SEARCH_PROMPT_TEMPLATE,
+        )
         self.citation_prompt_template = get_prompt_template(
-            self.config.get("prompt"),
+            self.config.get(PROMPT_CONFIG_KEY),
             DEFAULT_ENTERPRISE_SEARCH_PROMPT_WITH_CITATION_TEMPLATE,
         )
+        # If citation is enabled, use the citation prompt template
         if self.citation_enabled:
             self.prompt_template = self.citation_prompt_template
 
@@ -209,9 +243,10 @@ class EnterpriseSearchPolicy(Policy):
         Returns:
         The embedder.
         """
-        return embedder_factory(
+        client = embedder_factory(
             config.get(EMBEDDINGS_CONFIG_KEY), DEFAULT_EMBEDDINGS_CONFIG
         )
+        return _LangchainEmbeddingClientAdapter(client)
 
     def train(  # type: ignore[override]
         self,
@@ -245,20 +280,24 @@ class EnterpriseSearchPolicy(Policy):
         # validate embedding configuration
         try:
             embeddings = self._create_plain_embedder(self.config)
-        except ValidationError as e:
+        except (ValidationError, Exception) as e:
+            logger.error(
+                "enterprise_search_policy.train.embedder_instantiation_failed",
+                message="Unable to instantiate the embedding client.",
+                error=e,
+            )
             print_error_and_exit(
                 "Unable to create embedder. Please make sure you specified the "
                 f"required environment variables. Error: {e}"
             )
 
         # validate llm configuration
-        try:
-            llm_factory(self.config.get(LLM_CONFIG_KEY), DEFAULT_LLM_CONFIG)
-        except (ImportError, ValueError, ValidationError) as e:
-            # ImportError: llm library is likely not installed
-            # ValueError: llm config is likely invalid
-            # ValidationError: environment variables are likely not set
-            print_error_and_exit(f"Unable to create LLM. Error: {e}")
+        try_instantiate_llm_client(
+            self.config.get(LLM_CONFIG_KEY),
+            DEFAULT_LLM_CONFIG,
+            "enterprise_search_policy.train",
+            "EnterpriseSearchPolicy",
+        )
 
         if store_type == DEFAULT_VECTOR_STORE_TYPE:
             logger.info("enterprise_search_policy.train.faiss")
@@ -275,11 +314,12 @@ class EnterpriseSearchPolicy(Policy):
         # telemetry call to track training completion
         track_enterprise_search_policy_train_completed(
             vector_store_type=store_type,
-            embeddings_type=self.embeddings_config.get("_type"),
-            embeddings_model=self.embeddings_config.get("model")
-            or self.embeddings_config.get("model_name"),
-            llm_type=self.llm_config.get("_type"),
-            llm_model=self.llm_config.get("model") or self.llm_config.get("model_name"),
+            embeddings_type=self.embeddings_config.get(PROVIDER_CONFIG_KEY),
+            embeddings_model=self.embeddings_config.get(MODEL_CONFIG_KEY)
+            or self.embeddings_config.get(MODEL_NAME_CONFIG_KEY),
+            llm_type=self.llm_config.get(PROVIDER_CONFIG_KEY),
+            llm_model=self.llm_config.get(MODEL_CONFIG_KEY)
+            or self.llm_config.get(MODEL_NAME_CONFIG_KEY),
             citation_enabled=self.citation_enabled,
         )
         self.persist()
@@ -343,24 +383,31 @@ class EnterpriseSearchPolicy(Policy):
             logger.error(
                 "enterprise_search_policy._connect_vector_store_or_raise.connect_error",
                 error=e,
+                config=config,
             )
             raise VectorStoreConnectionError(
                 f"Unable to connect to the vector store. Error: {e}"
             )
 
-    def _get_last_user_message(self, tracker: DialogueStateTracker) -> str:
-        """Get the last user message from the tracker.
+    def _prepare_search_query(self, tracker: DialogueStateTracker, history: int) -> str:
+        """Prepares the search query.
+        The search query is the last N messages in the conversation history.
 
         Args:
             tracker: The tracker containing the conversation history up to now.
+            history: The number of messages to include in the search query.
 
         Returns:
-            The last user message.
+            The search query.
         """
-        for event in reversed(tracker.events):
-            if isinstance(event, rasa.shared.core.events.UserUttered):
-                return sanitize_message_for_prompt(event.text)
-        return ""
+        transcript = []
+        for event in tracker.applied_events():
+            if isinstance(event, UserUttered) or isinstance(event, BotUttered):
+                transcript.append(sanitize_message_for_prompt(event.text))
+
+        search_query = " ".join(transcript[-history:][::-1])
+        logger.debug("search_query", search_query=search_query)
+        return search_query
 
     async def predict_action_probabilities(  # type: ignore[override]
         self,
@@ -404,7 +451,9 @@ class EnterpriseSearchPolicy(Policy):
             logger.error(f"{logger_key}.connection_error", error=e)
             return self._create_prediction_internal_error(domain, tracker)
 
-        search_query = self._get_last_user_message(tracker)
+        search_query = self._prepare_search_query(
+            tracker, int(self.max_messages_in_query)
+        )
         tracker_state = tracker.current_state(EventVerbosity.AFTER_RESTART)
 
         try:
@@ -448,17 +497,23 @@ class EnterpriseSearchPolicy(Policy):
         action_metadata = {
             "message": {
                 "text": response,
+                SEARCH_RESULTS_METADATA_KEY: [
+                    result.text for result in documents.results
+                ],
+                UTTER_SOURCE_METADATA_KEY: self.__class__.__name__,
+                SEARCH_QUERY_METADATA_KEY: search_query,
             }
         }
 
         # telemetry call to track policy prediction
         track_enterprise_search_policy_predict(
             vector_store_type=self.vector_store_config.get(VECTOR_STORE_TYPE_PROPERTY),
-            embeddings_type=self.embeddings_config.get("_type"),
-            embeddings_model=self.embeddings_config.get("model")
-            or self.embeddings_config.get("model_name"),
-            llm_type=self.llm_config.get("_type"),
-            llm_model=self.llm_config.get("model") or self.llm_config.get("model_name"),
+            embeddings_type=self.embeddings_config.get(PROVIDER_CONFIG_KEY),
+            embeddings_model=self.embeddings_config.get(MODEL_CONFIG_KEY)
+            or self.embeddings_config.get(MODEL_NAME_CONFIG_KEY),
+            llm_type=self.llm_config.get(PROVIDER_CONFIG_KEY),
+            llm_model=self.llm_config.get(MODEL_CONFIG_KEY)
+            or self.llm_config.get(MODEL_NAME_CONFIG_KEY),
             citation_enabled=self.citation_enabled,
         )
         return self._create_prediction(
@@ -495,10 +550,11 @@ class EnterpriseSearchPolicy(Policy):
         return prompt
 
     async def _generate_llm_answer(
-        self, llm: "BaseLLM", prompt: Text
+        self, llm: LLMClient, prompt: Text
     ) -> Optional[Text]:
         try:
-            llm_answer = await llm.apredict(prompt)
+            llm_response = await llm.acompletion(prompt)
+            llm_answer = llm_response.choices[0]
         except Exception as e:
             # unfortunately, langchain does not wrap LLM exceptions which means
             # we have to catch all exceptions here
@@ -684,7 +740,7 @@ class EnterpriseSearchPolicy(Policy):
         local_knowledge_data = cls._get_local_knowledge_data(config)
 
         prompt_template = get_prompt_template(
-            config.get("prompt"),
+            config.get(PROMPT_CONFIG_KEY),
             DEFAULT_ENTERPRISE_SEARCH_PROMPT_TEMPLATE,
         )
         return deep_container_fingerprint([prompt_template, local_knowledge_data])

rasa/core/policies/flows/flow_executor.py

@@ -2,12 +2,14 @@ from __future__ import annotations
 
 from typing import Any, Dict, Text, List, Optional
 
+import structlog
 from jinja2 import Template
-from rasa.dialogue_understanding.commands import CancelFlowCommand
-from rasa.dialogue_understanding.patterns.cancel import CancelPatternFlowStackFrame
+from pypred import Predicate
 from structlog.contextvars import (
     bound_contextvars,
 )
+
+from rasa.core.constants import STEP_ID_METADATA_KEY, ACTIVE_FLOW_METADATA_KEY
 from rasa.core.policies.flows.flow_exceptions import (
     FlowCircuitBreakerTrippedException,
     FlowException,
@@ -19,6 +21,20 @@ from rasa.core.policies.flows.flow_step_result import (
     FlowStepResult,
     PauseFlowReturnPrediction,
 )
+from rasa.dialogue_understanding.commands import CancelFlowCommand
+from rasa.dialogue_understanding.patterns.cancel import CancelPatternFlowStackFrame
+from rasa.dialogue_understanding.patterns.collect_information import (
+    CollectInformationPatternFlowStackFrame,
+)
+from rasa.dialogue_understanding.patterns.completed import (
+    CompletedPatternFlowStackFrame,
+)
+from rasa.dialogue_understanding.patterns.continue_interrupted import (
+    ContinueInterruptedPatternFlowStackFrame,
+)
+from rasa.dialogue_understanding.patterns.human_handoff import (
+    HumanHandoffPatternFlowStackFrame,
+)
 from rasa.dialogue_understanding.patterns.internal_error import (
     InternalErrorPatternFlowStackFrame,
 )
@@ -29,24 +45,13 @@ from rasa.dialogue_understanding.stack.frames import (
     DialogueStackFrame,
     UserFlowStackFrame,
 )
-from rasa.dialogue_understanding.patterns.collect_information import (
-    CollectInformationPatternFlowStackFrame,
-)
-from rasa.dialogue_understanding.patterns.completed import (
-    CompletedPatternFlowStackFrame,
-)
-from rasa.dialogue_understanding.patterns.continue_interrupted import (
-    ContinueInterruptedPatternFlowStackFrame,
-)
 from rasa.dialogue_understanding.stack.frames.flow_stack_frame import (
     FlowStackFrameType,
 )
 from rasa.dialogue_understanding.stack.utils import (
     top_user_flow_frame,
 )
-
-from pypred import Predicate
-
+from rasa.shared.constants import RASA_PATTERN_HUMAN_HANDOFF
 from rasa.shared.core.constants import ACTION_LISTEN_NAME, SlotMappingType
 from rasa.shared.core.events import (
     Event,
@@ -56,6 +61,11 @@ from rasa.shared.core.events import (
     SlotSet,
 )
 from rasa.shared.core.flows import FlowsList
+from rasa.shared.core.flows.flow import (
+    END_STEP,
+    Flow,
+    FlowStep,
+)
 from rasa.shared.core.flows.flow_step_links import (
     StaticFlowStepLink,
     IfFlowStepLink,
@@ -71,17 +81,11 @@ from rasa.shared.core.flows.steps import (
     CollectInformationFlowStep,
     NoOperationFlowStep,
 )
-from rasa.shared.core.flows.flow import (
-    END_STEP,
-    Flow,
-    FlowStep,
-)
 from rasa.shared.core.flows.steps.collect import SlotRejection
 from rasa.shared.core.slots import Slot
 from rasa.shared.core.trackers import (
     DialogueStateTracker,
 )
-import structlog
 
 structlogger = structlog.get_logger()
 
@@ -466,6 +470,10 @@ def advance_flows_until_next_action(
         # make sure we really return all events that got created during the
         # step execution of all steps (not only the last one)
         prediction.events = gathered_events
+        prediction.metadata = {
+            ACTIVE_FLOW_METADATA_KEY: tracker.active_flow,
+            STEP_ID_METADATA_KEY: tracker.current_step_id,
+        }
         return prediction
     else:
         structlogger.warning("flow.step.execution.no_action")
@@ -483,7 +491,8 @@ def validate_collect_step(
     A collect step can be executed if either the `utter_ask` or the `action_ask` is
     defined in the domain. If neither is defined, the collect step can still be
     executed if the slot has an initial value defined in the domain, which would cause
-    the step to be skipped."""
+    the step to be skipped.
+    """
     slot = slots.get(step.collect)
     slot_has_initial_value_defined = slot and slot.initial_value is not None
     if (
@@ -583,102 +592,150 @@ def run_step(
     """
     initial_events: List[Event] = []
     if step == flow.first_step_in_flow():
-        initial_events.append(FlowStarted(flow.id))
+        initial_events.append(FlowStarted(flow.id, metadata=stack.current_context()))
 
     if isinstance(step, CollectInformationFlowStep):
-        is_step_valid = validate_collect_step(
-            step, stack, available_actions, tracker.slots
+        return _run_collect_information_step(
+            available_actions, initial_events, stack, step, tracker
         )
-        if not is_step_valid:
-            # if we return any other FlowStepResult, the assistant will stay silent
-            # instead of triggering the internal error pattern
-            return ContinueFlowWithNextStep(events=initial_events)
-
-        is_mapping_valid = validate_custom_slot_mappings(
-            step, stack, tracker, available_actions
-        )
-        if not is_mapping_valid:
-            # if we return any other FlowStepResult, the assistant will stay silent
-            # instead of triggering the internal error pattern
-            return ContinueFlowWithNextStep(events=initial_events)
-
-        structlogger.debug("flow.step.run.collect")
-        trigger_pattern_ask_collect_information(
-            step.collect, stack, step.rejections, step.utter, step.collect_action
-        )
-
-        events: List[Event] = events_for_collect_step_execution(step, tracker)
-        return ContinueFlowWithNextStep(events=initial_events + events)
 
     elif isinstance(step, ActionFlowStep):
         if not step.action:
             raise FlowException(f"Action not specified for step {step}")
-
-        context = {"context": stack.current_context()}
-        action_name = render_template_variables(step.action, context)
-
-        if action_name in available_actions:
-            structlogger.debug("flow.step.run.action", context=context)
-            return PauseFlowReturnPrediction(
-                FlowActionPrediction(action_name, 1.0, events=initial_events)
-            )
-        else:
-            if step.action != "validate_{{context.collect}}":
-                # do not log about non-existing validation actions of collect steps
-                utter_action_name = render_template_variables(
-                    "{{context.utter}}", context
-                )
-                if utter_action_name not in available_actions:
-                    structlogger.warning(
-                        "flow.step.run.action.unknown", action=action_name
-                    )
-            return ContinueFlowWithNextStep(events=initial_events)
+        return _run_action_step(available_actions, initial_events, stack, step)
 
     elif isinstance(step, LinkFlowStep):
-        structlogger.debug("flow.step.run.link")
-        stack.push(
-            UserFlowStackFrame(
-                flow_id=step.link,
-                frame_type=FlowStackFrameType.LINK,
-            ),
-            # push this below the current stack frame so that we can
-            # complete the current flow first and then continue with the
-            # linked flow
-            index=-1,
-        )
-        return ContinueFlowWithNextStep(events=initial_events)
+        return _run_link_step(initial_events, stack, step)
 
     elif isinstance(step, CallFlowStep):
-        structlogger.debug("flow.step.run.call")
-        stack.push(
-            UserFlowStackFrame(
-                flow_id=step.call,
-                frame_type=FlowStackFrameType.CALL,
-            ),
-        )
-        return ContinueFlowWithNextStep()
+        return _run_call_step(initial_events, stack, step)
 
     elif isinstance(step, SetSlotsFlowStep):
-        structlogger.debug("flow.step.run.slot")
-        slot_events: List[Event] = events_from_set_slots_step(step)
-        return ContinueFlowWithNextStep(events=initial_events + slot_events)
+        return _run_set_slot_step(initial_events, step)
 
     elif isinstance(step, NoOperationFlowStep):
         structlogger.debug("flow.step.run.no_operation")
         return ContinueFlowWithNextStep(events=initial_events)
 
     elif isinstance(step, EndFlowStep):
-        # this is the end of the flow, so we'll pop it from the stack
-        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
-        )
-        reset_events: List[Event] = reset_scoped_slots(current_frame, flow, tracker)
-        return ContinueFlowWithNextStep(
-            events=initial_events + reset_events + resumed_events, has_flow_ended=True
-        )
+        return _run_end_step(flow, flows, initial_events, stack, tracker)
 
     else:
         raise FlowException(f"Unknown flow step type {type(step)}")
+
+
+def _run_end_step(
+    flow: Flow,
+    flows: FlowsList,
+    initial_events: List[Event],
+    stack: DialogueStack,
+    tracker: DialogueStateTracker,
+) -> FlowStepResult:
+    # this is the end of the flow, so we'll pop it from the stack
+    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)
+    reset_events: List[Event] = reset_scoped_slots(current_frame, flow, tracker)
+    return ContinueFlowWithNextStep(
+        events=initial_events + reset_events + resumed_events, has_flow_ended=True
+    )
+
+
+def _run_set_slot_step(
+    initial_events: List[Event], step: SetSlotsFlowStep
+) -> FlowStepResult:
+    structlogger.debug("flow.step.run.slot")
+    slot_events: List[Event] = events_from_set_slots_step(step)
+    return ContinueFlowWithNextStep(events=initial_events + slot_events)
+
+
+def _run_call_step(
+    initial_events: List[Event], stack: DialogueStack, step: CallFlowStep
+) -> FlowStepResult:
+    structlogger.debug("flow.step.run.call")
+    stack.push(
+        UserFlowStackFrame(
+            flow_id=step.call,
+            frame_type=FlowStackFrameType.CALL,
+        ),
+    )
+    return ContinueFlowWithNextStep(events=initial_events)
+
+
+def _run_link_step(
+    initial_events: List[Event], stack: DialogueStack, step: LinkFlowStep
+) -> FlowStepResult:
+    structlogger.debug("flow.step.run.link")
+
+    if step.link == RASA_PATTERN_HUMAN_HANDOFF:
+        linked_stack_frame: DialogueStackFrame = HumanHandoffPatternFlowStackFrame()
+    else:
+        linked_stack_frame = UserFlowStackFrame(
+            flow_id=step.link,
+            frame_type=FlowStackFrameType.LINK,
+        )
+
+    stack.push(
+        linked_stack_frame,
+        # push this below the current stack frame so that we can
+        # complete the current flow first and then continue with the
+        # linked flow
+        index=-1,
+    )
+
+    return ContinueFlowWithNextStep(events=initial_events)
+
+
+def _run_action_step(
+    available_actions: List[str],
+    initial_events: List[Event],
+    stack: DialogueStack,
+    step: ActionFlowStep,
+) -> FlowStepResult:
+    context = {"context": stack.current_context()}
+    action_name = render_template_variables(step.action, context)
+
+    if action_name in available_actions:
+        structlogger.debug("flow.step.run.action", context=context)
+        return PauseFlowReturnPrediction(
+            FlowActionPrediction(action_name, 1.0, events=initial_events)
+        )
+    else:
+        if step.action != "validate_{{context.collect}}":
+            # do not log about non-existing validation actions of collect steps
+            utter_action_name = render_template_variables("{{context.utter}}", context)
+            if utter_action_name not in available_actions:
+                structlogger.warning("flow.step.run.action.unknown", action=action_name)
+        return ContinueFlowWithNextStep(events=initial_events)
+
+
+def _run_collect_information_step(
+    available_actions: List[str],
+    initial_events: List[Event],
+    stack: DialogueStack,
+    step: CollectInformationFlowStep,
+    tracker: DialogueStateTracker,
+) -> FlowStepResult:
+    is_step_valid = validate_collect_step(step, stack, available_actions, tracker.slots)
+
+    if not is_step_valid:
+        # if we return any other FlowStepResult, the assistant will stay silent
+        # instead of triggering the internal error pattern
+        return ContinueFlowWithNextStep(events=initial_events)
+    is_mapping_valid = validate_custom_slot_mappings(
+        step, stack, tracker, available_actions
+    )
+
+    if not is_mapping_valid:
+        # if we return any other FlowStepResult, the assistant will stay silent
+        # instead of triggering the internal error pattern
+        return ContinueFlowWithNextStep(events=initial_events)
+
+    structlogger.debug("flow.step.run.collect")
+    trigger_pattern_ask_collect_information(
+        step.collect, stack, step.rejections, step.utter, step.collect_action
+    )
+
+    events: List[Event] = events_for_collect_step_execution(step, tracker)
+    return ContinueFlowWithNextStep(events=initial_events + events)