rasa-pro 3.14.0.dev9__py3-none-any.whl → 3.14.0.dev11__py3-none-any.whl

rasa/core/policies/flows/flow_executor.py

@@ -1,27 +1,15 @@
 from __future__ import annotations
 
-import asyncio
-from typing import Any, Dict, List, Optional, Text, cast
+from typing import Any, Dict, List, Optional, Text
 
 import structlog
 from jinja2 import Template
 from pypred import Predicate
 from structlog.contextvars import bound_contextvars
 
-from rasa.agents.agent_manager import AgentManager
-from rasa.agents.constants import (
-    A2A_AGENT_CONTEXT_ID_KEY,
-    AGENT_METADATA_AGENT_RESPONSE_KEY,
-    AGENT_METADATA_EXIT_IF_KEY,
-    AGENT_METADATA_STRUCTURED_RESULTS_KEY,
-    MAX_AGENT_RETRY_DELAY_SECONDS,
-)
-from rasa.agents.core.types import AgentStatus, ProtocolType
-from rasa.agents.schemas import AgentInput, AgentOutput
-from rasa.agents.schemas.agent_input import AgentInputSlot
-from rasa.core.available_agents import AvailableAgents
 from rasa.core.available_endpoints import AvailableEndpoints
 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,
@@ -34,7 +22,6 @@ from rasa.core.policies.flows.flow_step_result import (
     PauseFlowReturnPrediction,
 )
 from rasa.core.policies.flows.mcp_tool_executor import call_mcp_tool
-from rasa.core.utils import get_slot_names_from_exit_conditions
 from rasa.dialogue_understanding.patterns.cancel import CancelPatternFlowStackFrame
 from rasa.dialogue_understanding.patterns.collect_information import (
     FLOW_PATTERN_COLLECT_INFORMATION,
@@ -62,29 +49,18 @@ from rasa.dialogue_understanding.stack.frames import (
 )
 from rasa.dialogue_understanding.stack.frames.flow_stack_frame import (
     AgentStackFrame,
-    AgentState,
     FlowStackFrameType,
 )
 from rasa.dialogue_understanding.stack.utils import (
     user_frames_on_the_stack,
 )
 from rasa.dialogue_understanding.utils import assemble_options_string
-from rasa.shared.agents.utils import get_protocol_type
 from rasa.shared.constants import RASA_PATTERN_HUMAN_HANDOFF
 from rasa.shared.core.constants import (
-    ACTION_AGENT_REQUEST_USER_INPUT_NAME,
     ACTION_LISTEN_NAME,
-    ACTION_METADATA_MESSAGE_KEY,
-    ACTION_METADATA_TEXT_KEY,
-    ACTION_SEND_TEXT_NAME,
-    FLOW_HASHES_SLOT,
     SILENCE_TIMEOUT_SLOT,
 )
 from rasa.shared.core.events import (
-    AgentCancelled,
-    AgentCompleted,
-    AgentResumed,
-    AgentStarted,
     Event,
     FlowCompleted,
     FlowResumed,
@@ -109,19 +85,13 @@ from rasa.shared.core.flows.steps import (
     SetSlotsFlowStep,
 )
 from rasa.shared.core.flows.steps.constants import START_STEP
-from rasa.shared.core.slots import CategoricalSlot, Slot, SlotRejection
+from rasa.shared.core.slots import Slot, SlotRejection
 from rasa.shared.core.trackers import DialogueStateTracker
-from rasa.shared.utils.llm import tracker_as_readable_transcript
 
 structlogger = structlog.get_logger()
 
 MAX_NUMBER_OF_STEPS = 250
 
-MAX_AGENT_RETRIES = 3
-
-# Slots that should not be forwarded to sub-agents via AgentInput
-SLOTS_EXCLUDED_FOR_AGENT = [FLOW_HASHES_SLOT]
-
 
 def render_template_variables(text: str, context: Dict[Text, Any]) -> str:
     """Replace context variables in a text."""
@@ -909,388 +879,3 @@ def _append_global_silence_timeout_event(
                 AvailableEndpoints.get_instance().interaction_handling.global_silence_timeout,
             )
         )
-
-
-def _reset_slots_covered_by_exit_if(
-    exit_conditions: List[str], tracker: DialogueStateTracker
-) -> None:
-    """Reset the slots covered by the exit_if condition."""
-    reset_slot_names = get_slot_names_from_exit_conditions(exit_conditions)
-    for slot_name in reset_slot_names:
-        if tracker.slots.get(slot_name) is not None:
-            tracker.update(SlotSet(slot_name, None))
-
-
-async def run_agent(
-    initial_events: List[Event],
-    stack: DialogueStack,
-    step: CallFlowStep,
-    tracker: DialogueStateTracker,
-    slots: List[Slot],
-) -> FlowStepResult:
-    """Run an agent call step."""
-    structlogger.debug(
-        "flow.step.run_agent", agent_id=step.call, step_id=step.id, flow_id=step.flow_id
-    )
-
-    final_events = initial_events
-    agent_stack_frame = tracker.stack.find_agent_stack_frame_by_agent(
-        agent_id=step.call
-    )
-
-    if (
-        agent_stack_frame
-        and agent_stack_frame == stack.top()
-        and agent_stack_frame.state == AgentState.INTERRUPTED
-    ):
-        structlogger.debug(
-            "flow.step.run_agent.resume_interrupted_agent",
-            agent_id=step.call,
-            step_id=step.id,
-            flow_id=step.flow_id,
-        )
-        # The agent was previously interrupted when waiting for user input.
-        # Now we're back to the agent execution step and need to output the last message
-        # from the agent (user input request) again and wait for user input
-        cast(AgentStackFrame, stack.top()).state = AgentState.WAITING_FOR_INPUT
-        tracker.update_stack(stack)
-        utterance = (
-            agent_stack_frame.metadata.get(AGENT_METADATA_AGENT_RESPONSE_KEY, "")
-            if agent_stack_frame.metadata
-            else ""
-        )
-        final_events.append(AgentResumed(agent_id=step.call, flow_id=step.flow_id))
-        return PauseFlowReturnPrediction(
-            _create_agent_request_user_input_prediction(utterance, final_events)
-        )
-
-    agent_input_metadata = (
-        agent_stack_frame.metadata
-        if agent_stack_frame and agent_stack_frame.metadata
-        else {}
-    )
-    _update_agent_input_metadata_with_events(
-        agent_input_metadata, step.call, step.flow_id, tracker
-    )
-    if step.exit_if:
-        # TODO: this is a temporary fix to reset the slots covered by the exit_if
-        if (
-            agent_stack_frame
-            and agent_stack_frame.frame_id == f"restart_agent_{step.call}"
-        ):
-            # when restarting an agent, we need to reset the slots covered by the
-            # exit_if condition so that the agent can run again.
-            _reset_slots_covered_by_exit_if(step.exit_if, tracker)
-        agent_input_metadata[AGENT_METADATA_EXIT_IF_KEY] = step.exit_if
-    agent_input = AgentInput(
-        id=step.call,
-        user_message=tracker.latest_message.text or ""
-        if tracker.latest_message
-        else "",
-        slots=_prepare_slots_for_agent(tracker.current_slot_values(), slots),
-        conversation_history=tracker_as_readable_transcript(tracker),
-        events=tracker.current_state().get("events") or [],
-        metadata=agent_input_metadata,
-    )
-
-    final_events.append(AgentStarted(step.call, step.flow_id))
-
-    protocol_type = get_protocol_type(step, AvailableAgents.get_agent_config(step.call))
-    # send the input to the agent and wait for a response
-    structlogger.debug(
-        "flow.step.run_agent.agent_input",
-        agent_name=step.call,
-        step_id=step.id,
-        flow_id=step.flow_id,
-        agent_input=agent_input,
-    )
-    output: AgentOutput = await _call_agent_with_retry(
-        agent_name=step.call,
-        protocol_type=protocol_type,
-        agent_input=agent_input,
-        max_retries=MAX_AGENT_RETRIES,
-    )
-    structlogger.debug(
-        "flow.step.run_agent.agent_response",
-        agent_name=step.call,
-        step_id=step.id,
-        flow_id=step.flow_id,
-        agent_response=output,
-    )
-
-    # add the set slot events returned by the agent to the list of final events
-    if output.events:
-        final_events.extend(output.events)
-
-    if output.status == AgentStatus.INPUT_REQUIRED:
-        output.metadata = output.metadata or {}
-        output.metadata[AGENT_METADATA_AGENT_RESPONSE_KEY] = (
-            output.response_message or ""
-        )
-        output.metadata[AGENT_METADATA_STRUCTURED_RESULTS_KEY] = (
-            output.structured_results or []
-        )
-        _update_agent_events(final_events, output.metadata)
-
-        top_stack_frame = stack.top()
-        # update the agent stack frame if it is already on the stack
-        # otherwise push a new one
-        if isinstance(top_stack_frame, AgentStackFrame):
-            top_stack_frame.state = AgentState.WAITING_FOR_INPUT
-            top_stack_frame.metadata = output.metadata
-            top_stack_frame.step_id = step.id
-            top_stack_frame.agent_id = step.call
-            top_stack_frame.flow_id = step.flow_id
-        else:
-            stack.push(
-                AgentStackFrame(
-                    flow_id=step.flow_id,
-                    agent_id=step.call,
-                    state=AgentState.WAITING_FOR_INPUT,
-                    step_id=step.id,
-                    metadata=output.metadata,
-                )
-            )
-
-        action_prediction = _create_agent_request_user_input_prediction(
-            output.response_message, final_events
-        )
-        return PauseFlowReturnPrediction(action_prediction)
-    elif output.status == AgentStatus.COMPLETED:
-        output.metadata = output.metadata or {}
-        _update_agent_events(final_events, output.metadata)
-        structlogger.debug(
-            "flow.step.run_agent.completed",
-            agent_name=step.call,
-            step_id=step.id,
-            flow_id=step.flow_id,
-        )
-        remove_agent_stack_frame(stack, step.call)
-        agent_completed_event = AgentCompleted(agent_id=step.call, flow_id=step.flow_id)
-        final_events.append(agent_completed_event)
-        if output.response_message:
-            # for open-ended agents we want to utter the last agent message
-
-            return PauseFlowReturnPrediction(
-                _create_send_text_prediction(output.response_message, final_events)
-            )
-        else:
-            return ContinueFlowWithNextStep(events=final_events)
-    elif output.status == AgentStatus.FATAL_ERROR:
-        output.metadata = output.metadata or {}
-        _update_agent_events(final_events, output.metadata)
-        # the agent failed, trigger pattern_internal_error
-        structlogger.error(
-            "flow.step.run_agent.fatal_error",
-            agent_name=step.call,
-            step_id=step.id,
-            flow_id=step.flow_id,
-            error_message=output.error_message,
-        )
-        remove_agent_stack_frame(stack, step.call)
-        final_events.append(
-            AgentCancelled(
-                agent_id=step.call, flow_id=step.flow_id, reason=output.error_message
-            )
-        )
-        stack.push(InternalErrorPatternFlowStackFrame())
-        return ContinueFlowWithNextStep(events=final_events)
-    else:
-        output.metadata = output.metadata or {}
-        _update_agent_events(final_events, output.metadata)
-        structlogger.error(
-            "flow.step.run_agent.unknown_status",
-            agent_name=step.call,
-            step_id=step.id,
-            flow_id=step.flow_id,
-            status=output.status,
-        )
-        remove_agent_stack_frame(stack, step.call)
-        final_events.append(AgentCancelled(agent_id=step.call, flow_id=step.flow_id))
-        stack.push(InternalErrorPatternFlowStackFrame())
-        return ContinueFlowWithNextStep(events=final_events)
-
-
-def remove_agent_stack_frame(stack: DialogueStack, agent_id: str) -> None:
-    """Finishes the agentic loop by popping the agent stack frame from the
-    provided `stack`. The `tracker.stack` is NOT modified.
-    """
-    agent_stack_frame = stack.find_agent_stack_frame_by_agent(agent_id)
-    if not agent_stack_frame:
-        return
-
-    while removed_frame := stack.pop():
-        structlogger.debug(
-            "flow_executor.remove_agent_stack_frame",
-            removed_frame=removed_frame,
-        )
-        if removed_frame == agent_stack_frame:
-            break
-
-
-def _create_action_prediction(
-    action_name: str, message: Optional[str], events: Optional[List[Event]]
-) -> FlowActionPrediction:
-    """Create a prediction for an action with a text message."""
-    action_metadata = {
-        ACTION_METADATA_MESSAGE_KEY: {
-            ACTION_METADATA_TEXT_KEY: message,
-        }
-    }
-    return FlowActionPrediction(
-        action_name,
-        1.0,
-        events=events if events else [],
-        metadata=action_metadata,
-    )
-
-
-def _create_agent_request_user_input_prediction(
-    message: Optional[str], events: Optional[List[Event]]
-) -> FlowActionPrediction:
-    """Create a prediction for requesting user input from the agent
-    and waiting for it.
-    """
-    return _create_action_prediction(
-        ACTION_AGENT_REQUEST_USER_INPUT_NAME, message, events
-    )
-
-
-def _create_send_text_prediction(
-    message: Optional[str], events: Optional[List[Event]]
-) -> FlowActionPrediction:
-    """Create a prediction for sending a text message to the user."""
-    return _create_action_prediction(ACTION_SEND_TEXT_NAME, message, events)
-
-
-async def _call_agent_with_retry(
-    agent_name: str,
-    protocol_type: ProtocolType,
-    agent_input: AgentInput,
-    max_retries: int,
-) -> AgentOutput:
-    """Call an agent with retries in case of recoverable errors."""
-    for attempt in range(max_retries):
-        if attempt > 0:
-            structlogger.debug(
-                "flow_executor.call_agent_with_retry.retrying",
-                agent_name=agent_name,
-                attempt=attempt + 1,
-                num_retries=max_retries,
-            )
-        try:
-            agent_response: AgentOutput = await AgentManager().run_agent(
-                agent_name=agent_name, protocol_type=protocol_type, context=agent_input
-            )
-        except Exception as e:
-            # We don't have a vaild agent response at this time to act based
-            # on the agent status, so we return a fatal error.
-            structlogger.error(
-                "flow_executor.call_agent_with_retry.exception",
-                agent_name=agent_name,
-                error_message=str(e),
-            )
-            return AgentOutput(
-                id=agent_name,
-                status=AgentStatus.FATAL_ERROR,
-                error_message=str(e),
-            )
-
-        if agent_response.status != AgentStatus.RECOVERABLE_ERROR:
-            return agent_response
-
-        structlogger.warning(
-            "flow_executor.call_agent_with_retry.recoverable_error",
-            agent_name=agent_name,
-            attempt=attempt + 1,
-            num_retries=max_retries,
-            error_message=agent_response.error_message,
-        )
-        if attempt < max_retries - 1:
-            # exponential backoff - wait longer with each retry
-            # 1 second, 2 seconds, 4 seconds, etc.
-            await asyncio.sleep(min(2**attempt, MAX_AGENT_RETRY_DELAY_SECONDS))
-
-    # we exhausted all retries, return fatal error
-    structlogger.warning(
-        "flow_executor.call_agent_with_retry.exhausted_retries",
-        agent_name=agent_name,
-        num_retries=max_retries,
-    )
-    return AgentOutput(
-        id=agent_name,
-        status=AgentStatus.FATAL_ERROR,
-        error_message="Exhausted all retries for agent call.",
-    )
-
-
-def _prepare_slots_for_agent(
-    slot_values: Dict[str, Any], slot_definitions: List[Slot]
-) -> List[AgentInputSlot]:
-    """Prepare the slots for the agent.
-
-    Filter out slots that should not be forwarded to agents.
-    Add the slot type and allowed values to the slot dictionary.
-
-    Args:
-        slot_values: The full slot dictionary from the tracker.
-        slot_definitions: The slot definitions from the domain.
-
-    Returns:
-        A list of slots containing the name, current value, type, and allowed values.
-    """
-
-    def _get_slot_definition(slot_name: str) -> Optional[Slot]:
-        for slot in slot_definitions:
-            if slot.name == slot_name:
-                return slot
-        return None
-
-    filtered_slots: List[AgentInputSlot] = []
-    for key, value in slot_values.items():
-        if key in SLOTS_EXCLUDED_FOR_AGENT:
-            continue
-        slot_definition = _get_slot_definition(key)
-        if slot_definition:
-            filtered_slots.append(
-                AgentInputSlot(
-                    name=key,
-                    value=value,
-                    type=slot_definition.type_name if slot_definition else "any",
-                    allowed_values=slot_definition.values
-                    if isinstance(slot_definition, CategoricalSlot)
-                    else None,
-                )
-            )
-
-    return filtered_slots
-
-
-def _update_agent_events(events: List[Event], metadata: Dict[str, Any]) -> None:
-    """Update the agent events based on the agent output metadata if needed."""
-    if A2A_AGENT_CONTEXT_ID_KEY in metadata:
-        # If the context ID is present, we need to store it in the AgentStarted
-        # event, so that it can be re-used later in case the agent is restarted.
-        for event in events:
-            if isinstance(event, AgentStarted):
-                event.context_id = metadata[A2A_AGENT_CONTEXT_ID_KEY]
-
-
-def _update_agent_input_metadata_with_events(
-    metadata: Dict[str, Any], agent_id: str, flow_id: str, tracker: DialogueStateTracker
-) -> None:
-    """Update the agent input metadata with the events."""
-    agent_started_events = [
-        event
-        for event in tracker.events
-        if type(event) == AgentStarted
-        and event.agent_id == agent_id
-        and event.flow_id == flow_id
-    ]
-    if agent_started_events:
-        # If we have context ID from the previous agent run, we want to
-        # include it in the metadata so that the agent can continue the same
-        # context.
-        agent_started_event = agent_started_events[-1]
-        if agent_started_event.context_id:
-            metadata[A2A_AGENT_CONTEXT_ID_KEY] = agent_started_event.context_id

rasa/core/policies/flows/mcp_tool_executor.py

@@ -1,9 +1,8 @@
 import json
-import operator
-from functools import reduce
 from typing import Any, Dict, List, Optional
 
 import structlog
+from jinja2.sandbox import SandboxedEnvironment
 from mcp.types import CallToolResult
 
 from rasa.core.available_endpoints import AvailableEndpoints
@@ -23,7 +22,7 @@ from rasa.utils.common import ensure_jsonified_iterable
 
 structlogger = structlog.get_logger()
 
-CONFIG_RESULT_KEY = "result_key"
+CONFIG_VALUE = "value"
 CONFIG_SLOT = "slot"
 
 
@@ -41,6 +40,7 @@ async def call_mcp_tool(
         mapping=step.mapping,
         step_id=step.id,
         flow_id=step.flow_id,
+        json_formatting=["mapping"],
     )
 
     try:
@@ -126,6 +126,7 @@ async def _execute_mcp_tool_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
@@ -195,8 +196,9 @@ async def _connect_to_mcp_server(
         return None
 
     mcp_server_config = mcp_server_configs[0]
-    mcp_server_connection = MCPServerConnection(
-        mcp_server_config.name, mcp_server_config.url, mcp_server_config.type
+
+    mcp_server_connection = MCPServerConnection.from_config(
+        mcp_server_config.model_dump()
     )
 
     # Ensure the connection is established and return the connection object
@@ -222,31 +224,49 @@ def _jsonify_slot_value(value: Any) -> str | int | float | bool | None:
     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."""
+    """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:
-                # Use reduce to navigate through nested keys in the result
-                slot_value = reduce(
-                    operator.getitem,
-                    mapping[CONFIG_RESULT_KEY].split("."),
-                    _result_as_dict,
+                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 (KeyError, TypeError):
+            except Exception as e:
                 structlogger.error(
-                    "call_mcp_tool.result_key_not_found_in_tool_result",
+                    "call_mcp_tool.value_not_found_in_tool_result",
                     slot=mapping[CONFIG_SLOT],
-                    result_key=mapping[CONFIG_RESULT_KEY],
+                    value=mapping[CONFIG_VALUE],
                     result=_result_as_dict,
+                    error=str(e),
+                    json_formatting=["result"],
                 )
                 return None
         return slots
@@ -255,6 +275,7 @@ def _process_tool_result(
             "call_mcp_tool.result_processing_failed",
             error=str(e),
             result=result,
+            json_formatting=["result"],
         )
         return None