rasa-pro 3.14.0.dev20250922__py3-none-any.whl → 3.14.0rc2__py3-none-any.whl

rasa/core/policies/flows/flow_executor.py

@@ -4,12 +4,11 @@ from typing import Any, Dict, List, Optional, Text
 
 import structlog
 from jinja2 import Template
-from structlog.contextvars import (
-    bound_contextvars,
-)
+from structlog.contextvars import bound_contextvars
 
-from rasa.core.available_endpoints import AvailableEndpoints
+from rasa.core.config.configuration import Configuration
 from rasa.core.constants import ACTIVE_FLOW_METADATA_KEY, STEP_ID_METADATA_KEY
+from rasa.core.policies.flows.agent_executor import run_agent
 from rasa.core.policies.flows.flow_exceptions import (
     FlowCircuitBreakerTrippedException,
     FlowException,
@@ -21,7 +20,7 @@ from rasa.core.policies.flows.flow_step_result import (
     FlowStepResult,
     PauseFlowReturnPrediction,
 )
-from rasa.dialogue_understanding.commands import CancelFlowCommand
+from rasa.core.policies.flows.mcp_tool_executor import call_mcp_tool
 from rasa.dialogue_understanding.patterns.cancel import CancelPatternFlowStackFrame
 from rasa.dialogue_understanding.patterns.collect_information import (
     FLOW_PATTERN_COLLECT_INFORMATION,
@@ -48,14 +47,18 @@ from rasa.dialogue_understanding.stack.frames import (
     UserFlowStackFrame,
 )
 from rasa.dialogue_understanding.stack.frames.flow_stack_frame import (
+    AgentStackFrame,
     FlowStackFrameType,
 )
 from rasa.dialogue_understanding.stack.utils import (
-    top_user_flow_frame,
+    user_frames_on_the_stack,
 )
+from rasa.dialogue_understanding.utils import assemble_options_string
 from rasa.shared.constants import RASA_PATTERN_HUMAN_HANDOFF
 from rasa.shared.core.constants import (
     ACTION_LISTEN_NAME,
+    GLOBAL_SILENCE_TIMEOUT_DEFAULT_VALUE,
+    SILENCE_TIMEOUT_CHANNEL_KEY,
     SILENCE_TIMEOUT_SLOT,
 )
 from rasa.shared.core.events import (
@@ -66,11 +69,7 @@ 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 import END_STEP, Flow, FlowStep
 from rasa.shared.core.flows.flow_step_links import (
     ElseFlowStepLink,
     IfFlowStepLink,
@@ -88,9 +87,7 @@ from rasa.shared.core.flows.steps import (
 )
 from rasa.shared.core.flows.steps.constants import START_STEP
 from rasa.shared.core.slots import Slot, SlotRejection
-from rasa.shared.core.trackers import (
-    DialogueStateTracker,
-)
+from rasa.shared.core.trackers import DialogueStateTracker
 from rasa.utils.pypred import Predicate
 
 structlogger = structlog.get_logger()
@@ -148,6 +145,13 @@ def select_next_step_id(
     tracker: DialogueStateTracker,
 ) -> Optional[Text]:
     """Selects the next step id based on the current step."""
+    # if the current step is a call step to an agent, and we already have an
+    # AgentStackFrame on top of the stack, we need to return the current
+    # step id again in order to loop back to the agent.
+    top_stack_frame = tracker.stack.top()
+    if top_stack_frame and isinstance(top_stack_frame, AgentStackFrame):
+        return current.id
+
     next_step = current.next
     if len(next_step.links) == 1 and isinstance(next_step.links[0], StaticFlowStepLink):
         return next_step.links[0].target
@@ -234,38 +238,58 @@ def trigger_pattern_continue_interrupted(
     stack: DialogueStack,
     flows: FlowsList,
     tracker: DialogueStateTracker,
-) -> List[Event]:
+) -> None:
     """Trigger the pattern to continue an interrupted flow if needed."""
-    events: List[Event] = []
-
-    # get previously started user flow that will be continued
-    interrupted_user_flow_frame = top_user_flow_frame(stack)
-    interrupted_user_flow_step = (
-        interrupted_user_flow_frame.step(flows) if interrupted_user_flow_frame else None
-    )
-    interrupted_user_flow = (
-        interrupted_user_flow_frame.flow(flows) if interrupted_user_flow_frame else None
-    )
-
+    # only trigger the pattern if the current frame is a user flow frame
+    # with a frame type of interrupt
     if (
-        isinstance(current_frame, UserFlowStackFrame)
-        and interrupted_user_flow_step is not None
-        and interrupted_user_flow is not None
-        and current_frame.frame_type == FlowStackFrameType.INTERRUPT
-        and not is_step_end_of_flow(interrupted_user_flow_step)
+        not isinstance(current_frame, UserFlowStackFrame)
+        or current_frame.frame_type != FlowStackFrameType.INTERRUPT
     ):
-        stack.push(
-            ContinueInterruptedPatternFlowStackFrame(
-                previous_flow_name=interrupted_user_flow.readable_name(
-                    language=tracker.current_language
-                ),
-            )
+        return None
+
+    # get all previously interrupted user flows
+    interrupted_user_flow_stack_frames = user_frames_on_the_stack(stack)
+
+    interrupted_user_flows_to_continue: List[UserFlowStackFrame] = []
+    # check if interrupted user flows can be continued
+    # i.e. the flow is not at the end of the flow
+    for frame in interrupted_user_flow_stack_frames:
+        interrupted_user_flow_step = frame.step(flows)
+        interrupted_user_flow = frame.flow(flows)
+        if (
+            interrupted_user_flow_step is not None
+            and interrupted_user_flow is not None
+            and not is_step_end_of_flow(interrupted_user_flow_step)
+        ):
+            interrupted_user_flows_to_continue.append(frame)
+
+    # if there are no interrupted user flows to continue,
+    # we don't need to trigger the pattern
+    if len(interrupted_user_flows_to_continue) == 0:
+        return None
+
+    # get the flow names and ids of the interrupted flows
+    # and assemble the options string
+    flow_names: List[str] = []
+    flow_ids: List[str] = []
+    for frame in interrupted_user_flows_to_continue:
+        flow_names.append(
+            frame.flow(flows).readable_name(language=tracker.current_language)
         )
-        events.append(
-            FlowResumed(interrupted_user_flow.id, interrupted_user_flow_step.id)
+        flow_ids.append(frame.flow_id)
+    options_string = assemble_options_string(flow_names)
+
+    # trigger the pattern to continue the interrupted flows
+    stack.push(
+        ContinueInterruptedPatternFlowStackFrame(
+            interrupted_flow_names=flow_names,
+            interrupted_flow_ids=flow_ids,
+            interrupted_flow_options=options_string,
         )
+    )
 
-    return events
+    return None
 
 
 def trigger_pattern_completed(
@@ -359,8 +383,11 @@ def reset_scoped_slots(
     return events
 
 
-def advance_flows(
-    tracker: DialogueStateTracker, available_actions: List[str], flows: FlowsList
+async def advance_flows(
+    tracker: DialogueStateTracker,
+    available_actions: List[str],
+    flows: FlowsList,
+    slots: List[Slot],
 ) -> FlowActionPrediction:
     """Advance the current flows until the next action.
 
@@ -368,6 +395,7 @@ def advance_flows(
         tracker: The tracker to get the next action for.
         available_actions: The actions that are available in the domain.
         flows: All flows.
+        slots: The slots that are available in the domain.
 
     Returns:
     The predicted action and the events to run.
@@ -377,13 +405,16 @@ def advance_flows(
         # if there are no flows, there is nothing to do
         return FlowActionPrediction(None, 0.0)
 
-    return advance_flows_until_next_action(tracker, available_actions, flows)
+    return await advance_flows_until_next_action(
+        tracker, available_actions, flows, slots
+    )
 
 
-def advance_flows_until_next_action(
+async def advance_flows_until_next_action(
     tracker: DialogueStateTracker,
     available_actions: List[str],
     flows: FlowsList,
+    slots: List[Slot],
 ) -> FlowActionPrediction:
     """Advance the flow and select the next action to execute.
 
@@ -441,7 +472,7 @@ def advance_flows_until_next_action(
 
             with bound_contextvars(step_id=next_step.id):
                 step_stack = tracker.stack
-                step_result = run_step(
+                step_result = await run_step(
                     next_step,
                     current_flow,
                     step_stack,
@@ -449,6 +480,7 @@ def advance_flows_until_next_action(
                     available_actions,
                     flows,
                     previous_step_id,
+                    slots,
                 )
                 new_events = step_result.events
                 if (
@@ -477,10 +509,9 @@ 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,
-        }
+        prediction.metadata = prediction.metadata or {}
+        prediction.metadata[ACTIVE_FLOW_METADATA_KEY] = tracker.active_flow
+        prediction.metadata[STEP_ID_METADATA_KEY] = tracker.current_step_id
         return prediction
     else:
         structlogger.warning("flow.step.execution.no_action")
@@ -522,6 +553,8 @@ def validate_collect_step(
 
 def cancel_flow_and_push_internal_error(stack: DialogueStack, flow_name: str) -> None:
     """Cancel the top user flow and push the internal error pattern."""
+    from rasa.dialogue_understanding.commands import CancelFlowCommand
+
     top_frame = stack.top()
 
     if isinstance(top_frame, BaseFlowStackFrame):
@@ -550,7 +583,7 @@ def attach_stack_metadata_to_events(
         event.metadata[ACTIVE_FLOW_METADATA_KEY] = flow_id
 
 
-def run_step(
+async def run_step(
     step: FlowStep,
     flow: Flow,
     stack: DialogueStack,
@@ -558,6 +591,7 @@ def run_step(
     available_actions: List[str],
     flows: FlowsList,
     previous_step_id: str,
+    slots: List[Slot],
 ) -> FlowStepResult:
     """Run a single step of a flow.
 
@@ -576,6 +610,7 @@ def run_step(
         available_actions: The actions that are available in the domain.
         flows: All flows.
         previous_step_id: The ID of the previous step.
+        slots: The slots that are available in the domain.
 
     Returns:
     A result of running the step describing where to transition to.
@@ -615,7 +650,7 @@ def run_step(
         return _run_link_step(initial_events, stack, step)
 
     elif isinstance(step, CallFlowStep):
-        return _run_call_step(initial_events, stack, step)
+        return await _run_call_step(initial_events, stack, step, tracker, slots)
 
     elif isinstance(step, SetSlotsFlowStep):
         return _run_set_slot_step(initial_events, step)
@@ -667,12 +702,10 @@ 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, tracker
-    )
+    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
+        events=initial_events + reset_events, has_flow_ended=True
     )
 
 
@@ -684,17 +717,26 @@ def _run_set_slot_step(
     return ContinueFlowWithNextStep(events=initial_events + slot_events)
 
 
-def _run_call_step(
-    initial_events: List[Event], stack: DialogueStack, step: CallFlowStep
+async def _run_call_step(
+    initial_events: List[Event],
+    stack: DialogueStack,
+    step: CallFlowStep,
+    tracker: DialogueStateTracker,
+    slots: List[Slot],
 ) -> FlowStepResult:
     structlogger.debug("flow.step.run.call")
-    stack.push(
-        UserFlowStackFrame(
-            flow_id=step.call,
-            frame_type=FlowStackFrameType.CALL,
-        ),
-    )
-    return ContinueFlowWithNextStep(events=initial_events)
+    if step.is_calling_mcp_tool():
+        return await call_mcp_tool(initial_events, stack, step, tracker)
+    elif step.is_calling_agent():
+        return await run_agent(initial_events, stack, step, tracker, slots)
+    else:
+        stack.push(
+            UserFlowStackFrame(
+                flow_id=step.call,
+                frame_type=FlowStackFrameType.CALL,
+            ),
+        )
+        return ContinueFlowWithNextStep(events=initial_events)
 
 
 def _run_link_step(
@@ -797,21 +839,41 @@ def _silence_timeout_events_for_collect_step(
 ) -> List[Event]:
     events: List[Event] = []
 
-    silence_timeout = (
-        AvailableEndpoints.get_instance().interaction_handling.global_silence_timeout
-    )
-
     if step.silence_timeout:
+        input_channel_name = tracker.get_latest_input_channel()
+
         structlogger.debug(
-            "flow.step.run.adjusting_silence_timeout",
+            "flow.step.run.using_step_silence_timeout",
             duration=step.silence_timeout,
             collect=step.collect,
         )
 
-        silence_timeout = step.silence_timeout
+        silence_timeout = step.silence_timeout.get_silence_for_channel(
+            input_channel_name
+        )
     else:
+        input_channel_name = tracker.get_latest_input_channel()
+        credentials_config = Configuration.get_instance().credentials
+
+        if credentials_config:
+            channel_config = (
+                credentials_config.channels.get(input_channel_name)
+                if input_channel_name
+                else None
+            )
+
+            silence_timeout = (
+                channel_config.get(
+                    SILENCE_TIMEOUT_CHANNEL_KEY, GLOBAL_SILENCE_TIMEOUT_DEFAULT_VALUE
+                )
+                if channel_config
+                else GLOBAL_SILENCE_TIMEOUT_DEFAULT_VALUE
+            )
+        else:
+            silence_timeout = GLOBAL_SILENCE_TIMEOUT_DEFAULT_VALUE
+
         structlogger.debug(
-            "flow.step.run.reset_silence_timeout_to_global",
+            "flow.step.run.use_channel_silence_timeout",
             duration=silence_timeout,
             collect=step.collect,
         )
@@ -828,14 +890,13 @@ def _append_global_silence_timeout_event(
     events: List[Event], tracker: DialogueStateTracker
 ) -> None:
     current_silence_timeout = tracker.get_slot(SILENCE_TIMEOUT_SLOT)
-    global_silence_timeout = (
-        AvailableEndpoints.get_instance().interaction_handling.global_silence_timeout
-    )
+    endpoints = Configuration.get_instance().endpoints
+    global_silence_timeout = endpoints.interaction_handling.global_silence_timeout
 
     if current_silence_timeout != global_silence_timeout:
         events.append(
             SlotSet(
                 SILENCE_TIMEOUT_SLOT,
-                AvailableEndpoints.get_instance().interaction_handling.global_silence_timeout,
+                global_silence_timeout,
             )
         )

rasa/core/policies/flows/mcp_tool_executor.py

@@ -0,0 +1,298 @@
+import json
+from typing import Any, Dict, List, Optional
+
+import structlog
+from jinja2.sandbox import SandboxedEnvironment
+from mcp.types import CallToolResult
+
+from rasa.core.config.configuration import Configuration
+from rasa.core.policies.flows.flow_step_result import (
+    ContinueFlowWithNextStep,
+    FlowStepResult,
+)
+from rasa.dialogue_understanding.patterns.internal_error import (
+    InternalErrorPatternFlowStackFrame,
+)
+from rasa.dialogue_understanding.stack.dialogue_stack import DialogueStack
+from rasa.shared.core.events import Event, SlotSet
+from rasa.shared.core.flows.steps import CallFlowStep
+from rasa.shared.core.trackers import DialogueStateTracker
+from rasa.shared.utils.mcp.server_connection import MCPServerConnection
+from rasa.utils.common import ensure_jsonified_iterable
+
+structlogger = structlog.get_logger()
+
+CONFIG_VALUE = "value"
+CONFIG_SLOT = "slot"
+
+
+async def call_mcp_tool(
+    initial_events: List[Event],
+    stack: DialogueStack,
+    step: CallFlowStep,
+    tracker: DialogueStateTracker,
+) -> FlowStepResult:
+    """Run an MCP tool call step."""
+    structlogger.debug(
+        "flow.step.call_mcp_tool",
+        tool_id=step.call,
+        mcp_server=step.mcp_server,
+        mapping=step.mapping,
+        step_id=step.id,
+        flow_id=step.flow_id,
+        json_formatting=["mapping"],
+    )
+
+    try:
+        return await _execute_mcp_tool_call(initial_events, stack, step, tracker)
+    except Exception as e:
+        return _handle_mcp_tool_error(
+            stack,
+            initial_events,
+            error_message=f"Failed to execute MCP tool call: {e}.",
+            tool_name=step.call,
+            mcp_server=step.mcp_server,
+        )
+
+
+async def _execute_mcp_tool_call(
+    initial_events: List[Event],
+    stack: DialogueStack,
+    step: CallFlowStep,
+    tracker: DialogueStateTracker,
+) -> FlowStepResult:
+    """Execute the MCP tool call with proper error handling."""
+    mcp_server_connection = None
+    try:
+        # Connect to the MCP server
+        mcp_server_connection = await _connect_to_mcp_server(step.mcp_server)
+
+        if not mcp_server_connection:
+            return _handle_mcp_tool_error(
+                stack,
+                initial_events,
+                f"Cannot connect to MCP server '{step.mcp_server}'.",
+                tool_name=step.call,
+                mcp_server=step.mcp_server,
+            )
+
+        # Validate tool availability
+        if not await _is_tool_available(mcp_server_connection, step.call):
+            return _handle_mcp_tool_error(
+                stack,
+                initial_events,
+                f"Tool '{step.call}' is not available on MCP server "
+                f"'{step.mcp_server}'.",
+                tool_name=step.call,
+                mcp_server=step.mcp_server,
+            )
+
+        # This should not happen, but we need to check for type checking to pass
+        if not step.mapping:
+            return _handle_mcp_tool_error(
+                stack,
+                initial_events,
+                f"No mapping found for tool '{step.call}'.",
+                tool_name=step.call,
+                mcp_server=step.mcp_server,
+            )
+
+        # Prepare arguments for the tool call
+        arguments = _prepare_tool_arguments(step.mapping["input"], tracker)
+
+        # Call the tool with parameters
+        mcp_server = await mcp_server_connection.ensure_active_session()
+        result = await mcp_server.call_tool(step.call, arguments)
+
+        # Handle tool execution result
+        if result is None or result.isError:
+            return _handle_mcp_tool_error(
+                stack,
+                initial_events,
+                f"Tool '{step.call}' execution failed: {result.content}.",
+                tool_name=step.call,
+                mcp_server=step.mcp_server,
+            )
+        elif not result.content:
+            structlogger.warning(
+                "call_mcp_tool.empty_tool_result",
+                tool_name=step.call,
+                mcp_server=step.mcp_server,
+            )
+        else:
+            structlogger.debug(
+                "call_mcp_tool.tool_execution_success",
+                tool_name=step.call,
+                mcp_server=step.mcp_server,
+                result_content=result.content,
+                result_structured_content=result.structuredContent,
+                json_formatting=["result_content", "result_structured_content"],
+            )
+
+            # Process successful result
+            if set_slot_event := _process_tool_result(result, step.mapping["output"]):
+                initial_events.extend(set_slot_event)
+            else:
+                return _handle_mcp_tool_error(
+                    stack,
+                    initial_events,
+                    f"Failed to process tool result for '{step.call}'.",
+                    tool_name=step.call,
+                    mcp_server=step.mcp_server,
+                )
+
+        return ContinueFlowWithNextStep(events=initial_events)
+
+    finally:
+        # Always clean up the connection to prevent resource leaks
+        if mcp_server_connection:
+            try:
+                await mcp_server_connection.close()
+            except Exception as e:
+                structlogger.warning(
+                    "call_mcp_tool.connection_cleanup_failed",
+                    tool_name=step.call,
+                    mcp_server=step.mcp_server,
+                    error=str(e),
+                )
+
+
+async def _is_tool_available(
+    mcp_server_connection: MCPServerConnection, tool_name: str
+) -> bool:
+    """Check if the specified tool is available on the MCP server."""
+    try:
+        # Get the active session from the connection
+        mcp_server = await mcp_server_connection.ensure_active_session()
+        available_tools = await mcp_server.list_tools()
+        tool_names = [tool.name for tool in available_tools.tools]
+        return tool_name in tool_names
+    except Exception as e:
+        structlogger.warning(
+            "call_mcp_tool.tool_availability_check_failed",
+            tool_name=tool_name,
+            error=str(e),
+        )
+        return False
+
+
+async def _connect_to_mcp_server(
+    mcp_server_name: Optional[str],
+) -> Optional[MCPServerConnection]:
+    """Connect to the MCP server."""
+    if not mcp_server_name:
+        return None
+
+    # get the MCP server config from the available endpoints
+    endpoints = Configuration.get_instance().endpoints
+    mcp_servers = endpoints.mcp_servers
+    if not mcp_servers:
+        return None
+
+    mcp_server_configs = [
+        mcp_server for mcp_server in mcp_servers if mcp_server.name == mcp_server_name
+    ]
+    if not mcp_server_configs or len(mcp_server_configs) != 1:
+        return None
+
+    mcp_server_config = mcp_server_configs[0]
+
+    mcp_server_connection = MCPServerConnection.from_config(
+        mcp_server_config.model_dump()
+    )
+
+    # Ensure the connection is established and return the connection object
+    await mcp_server_connection.ensure_active_session()
+    return mcp_server_connection
+
+
+def _prepare_tool_arguments(
+    input_mapping: List[Dict[str, str]], tracker: DialogueStateTracker
+) -> Dict[str, Any]:
+    """Prepare arguments for the tool call from slot values."""
+    arguments = {}
+    for argument in input_mapping:
+        slot_value = tracker.get_slot(argument["slot"])
+        arguments[argument["param"]] = slot_value
+    return arguments
+
+
+def _jsonify_slot_value(value: Any) -> str | int | float | bool | None:
+    """Prepare value for SlotSet: iterables -> JSON string, primitives -> as-is"""
+    if isinstance(value, (list, dict)) and len(value):
+        return json.dumps(ensure_jsonified_iterable(value))
+    return value
+
+
+def _get_slot_value_from_jinja2_expression(
+    result_expression: str,
+    result_as_dict: Dict[str, Any],
+) -> Any:
+    """Get the slot value from the Jinja2 expression"""
+    # Create a sandboxed environment to evaluate the expression
+    _env = SandboxedEnvironment()
+
+    # Compile the expression
+    compiled_expr = _env.compile_expression(result_expression)
+
+    # Evaluate the expression
+    return compiled_expr(result_as_dict)
+
+
+def _process_tool_result(
+    result: CallToolResult,
+    output_mapping: List[Dict[str, str]],
+) -> Optional[List[SlotSet]]:
+    """Create a SetSlot event for the tool result using Jinja2 expressions"""
+    try:
+        _result_as_dict = {"result": result.model_dump()}
+        slots = []
+        for mapping in output_mapping:
+            try:
+                result_expression = mapping[CONFIG_VALUE]
+
+                # Get the slot value from the Jinja2 expression
+                slot_value = _get_slot_value_from_jinja2_expression(
+                    result_expression, _result_as_dict
+                )
+
+                slots.append(
+                    SlotSet(mapping[CONFIG_SLOT], _jsonify_slot_value(slot_value))
+                )
+            except Exception as e:
+                structlogger.error(
+                    "call_mcp_tool.value_not_found_in_tool_result",
+                    slot=mapping[CONFIG_SLOT],
+                    value=mapping[CONFIG_VALUE],
+                    result=_result_as_dict,
+                    error=str(e),
+                    json_formatting=["result"],
+                )
+                return None
+        return slots
+    except Exception as e:
+        structlogger.error(
+            "call_mcp_tool.result_processing_failed",
+            error=str(e),
+            result=result,
+            json_formatting=["result"],
+        )
+        return None
+
+
+def _handle_mcp_tool_error(
+    stack: DialogueStack,
+    events: List[Event],
+    error_message: str,
+    tool_name: str,
+    mcp_server: Optional[str],
+) -> FlowStepResult:
+    """Handle MCP tool errors consistently."""
+    structlogger.error(
+        "call_mcp_tool.error",
+        error_message=error_message,
+        tool_name=tool_name,
+        mcp_server=mcp_server,
+    )
+    stack.push(InternalErrorPatternFlowStackFrame())
+    return ContinueFlowWithNextStep(events=events)

rasa/core/policies/intentless_policy.py

@@ -5,7 +5,7 @@ from typing import TYPE_CHECKING, Any, Dict, List, Optional, Text, Tuple
 
 import structlog
 import tiktoken
-from deprecated import deprecated  # type: ignore[import]
+from deprecated import deprecated  # type: ignore[import-untyped]
 from jinja2 import Template
 from langchain.docstore.document import Document
 from langchain.schema.embeddings import Embeddings