rasa-pro 3.14.0.dev1__py3-none-any.whl → 3.14.0.dev20250818__py3-none-any.whl

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

@@ -1,5 +1,5 @@
-import {rasaColors} from '../theme/base/colors'
-import type {Event, Flow, Slot, Stack} from '../types'
+import { rasaColors } from '../theme/base/colors'
+import type { Event, Flow, Slot, Stack } from '../types'
 
 export function formatSlots(slots: { [key: string]: unknown }) {
   if (!slots) {
@@ -13,7 +13,7 @@ export function formatSlots(slots: { [key: string]: unknown }) {
         slotDuple[0] !== 'flow_hashes' &&
         slotDuple[1] != null,
     )
-    .map((slotDuple) => ({name: slotDuple[0], value: slotDuple[1]}))
+    .map((slotDuple) => ({ name: slotDuple[0], value: slotDuple[1] }))
 }
 
 export const formatTestCases = (events: Event[], sessionId: string) => {
@@ -85,14 +85,11 @@ export const formatFlow = (
     `flowchart TD
 classDef collect stroke-width:1px
 classDef action fill:#FBFCFD,stroke:#A0B8CF
-classDef noop fill:#FBFCFD
-classDef callstep fill:#FBFCFD
 classDef link fill:#f43
 classDef slot fill:#e8f3db,stroke:#c5e1a5
 classDef endstep fill:#ccc,stroke:#444
 classDef previous stroke:${rasaColors.rasaOrange[400]},stroke-width:1px
 classDef active stroke:${rasaColors.rasaOrange[400]},stroke-width:3px,fill:${rasaColors.warning[50]}
-classDef pulse animation:pulse 2s infinite
 `,
   ]
   try {
@@ -213,24 +210,6 @@ function renderStepSequence(
       )}"]:::slot\n`
     }
 
-    if (step.call) {
-      const isAgentWaitingOnInput = !!currentStack?.agent_id && currentStack?.state === 'waiting_for_input'
-      mermaidTextFragment += `${mermaidId}["${encodeDoubleQuotes(
-        stepId,
-      )} 🤖"]:::callstep\n`
-
-      if (isAgentWaitingOnInput) {
-        mermaidTextFragment += `class ${mermaidId} pulse\n`
-      }
-    }
-
-    if (step.noop) {
-      mermaidTextFragment += `${mermaidId}["${parseFieldUsingStack(
-        stepId,
-        currentStack
-      )}"]:::noop\n`
-    }
-
     if (activeStep && stepId === activeStep) {
       mermaidTextFragment += `class ${mermaidId} active\n`
     } else if (stepTrail?.includes(stepId)) {

rasa/core/channels/inspector/src/theme/base/styles.ts

@@ -1,19 +1,4 @@
-import {mode, StyleFunctionProps} from '@chakra-ui/theme-tools'
-import {keyframes} from "@chakra-ui/react";
-
-
-const pulse = keyframes`
-    0% {
-        opacity: 1;
-    }
-    50% {
-        opacity: 0.5;
-    }
-    100% {
-        opacity: 1;
-    }
-`;
-
+import { mode, StyleFunctionProps } from '@chakra-ui/theme-tools'
 
 export const styles = {
   global: {
@@ -24,8 +9,5 @@ export const styles = {
       fontSize: theme.rasaFontSizes.md,
       letterSpacing: '0.025rem',
     }),
-    '.pulse': {
-      animation: `${pulse} 2s infinite`,
-    },
   },
 }

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

@@ -40,8 +40,6 @@ export interface Stack {
   collect?: string
   utter?: string
   ended: boolean
-  agent_id?: string
-  state?: "waiting_for_input" | "interrupted"
 }
 
 export interface LatencyData {
@@ -97,6 +95,4 @@ interface Step {
   reset_after_flow_ends: boolean
   utter: string
   set_slots?: unknown
-  call?: string
-  noop?: boolean
 }

rasa/core/constants.py

@@ -31,10 +31,6 @@ BEARER_TOKEN_PREFIX = "Bearer "
 # The lowest priority is intended to be used by machine learning policies.
 DEFAULT_POLICY_PRIORITY = 1
 
-DEFAULT_SUB_AGENTS = "sub_agents"
-
-MCP_SERVERS_KEY = "mcp_servers"
-
 # The priority of intent-prediction policies.
 # This should be below all rule based policies but higher than ML
 # based policies. This enables a loop inside ensemble where if none

rasa/core/policies/enterprise_search_policy.py

@@ -63,8 +63,6 @@ from rasa.shared.constants import (
 )
 from rasa.shared.core.constants import (
     ACTION_CANCEL_FLOW,
-    ACTION_METADATA_MESSAGE_KEY,
-    ACTION_METADATA_TEXT_KEY,
     ACTION_SEND_TEXT_NAME,
     DEFAULT_SLOT_NAMES,
 )
@@ -587,8 +585,8 @@ class EnterpriseSearchPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Po
             return self._create_prediction_internal_error(domain, tracker)
 
         action_metadata = {
-            ACTION_METADATA_MESSAGE_KEY: {
-                ACTION_METADATA_TEXT_KEY: response,
+            "message": {
+                "text": response,
                 SEARCH_RESULTS_METADATA_KEY: [
                     result.text for result in documents.results
                 ],

rasa/core/policies/flow_policy.py

@@ -137,7 +137,7 @@ class FlowPolicy(Policy):
 
         # create executor and predict next action
         try:
-            prediction = await flow_executor.advance_flows(
+            prediction = flow_executor.advance_flows(
                 tracker, domain.action_names_or_texts, flows
             )
             return self._create_prediction_result(
@@ -164,7 +164,7 @@ class FlowPolicy(Policy):
             # we retry, with the internal error frame on the stack
             events = tracker.create_stack_updated_events(updated_stack)
             tracker.update_with_events(events)
-            prediction = await flow_executor.advance_flows(
+            prediction = flow_executor.advance_flows(
                 tracker, domain.action_names_or_texts, flows
             )
             collected_events = events + (prediction.events or [])

rasa/core/policies/flows/flow_executor.py

@@ -1,22 +1,14 @@
 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 (
-    AGENT_METADATA_AGENT_RESPONSE_KEY,
-    AGENT_METADATA_EXIT_IF_KEY,
-    AGENT_METADATA_TOOL_RESULTS_KEY,
+from structlog.contextvars import (
+    bound_contextvars,
 )
-from rasa.agents.core.types import AgentStatus, ProtocolType
-from rasa.agents.schemas import AgentInput, AgentOutput
-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.flow_exceptions import (
@@ -30,8 +22,7 @@ from rasa.core.policies.flows.flow_step_result import (
     FlowStepResult,
     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.commands import CancelFlowCommand
 from rasa.dialogue_understanding.patterns.cancel import CancelPatternFlowStackFrame
 from rasa.dialogue_understanding.patterns.collect_information import (
     FLOW_PATTERN_COLLECT_INFORMATION,
@@ -58,27 +49,17 @@ from rasa.dialogue_understanding.stack.frames import (
     UserFlowStackFrame,
 )
 from rasa.dialogue_understanding.stack.frames.flow_stack_frame import (
-    AgentStackFrame,
-    AgentState,
     FlowStackFrameType,
 )
-from rasa.dialogue_understanding.stack.utils import top_user_flow_frame
-from rasa.shared.agents.utils import get_protocol_type
+from rasa.dialogue_understanding.stack.utils import (
+    top_user_flow_frame,
+)
 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,
@@ -86,7 +67,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 import (
+    END_STEP,
+    Flow,
+    FlowStep,
+)
 from rasa.shared.core.flows.flow_step_links import (
     ElseFlowStepLink,
     IfFlowStepLink,
@@ -104,19 +89,14 @@ 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.utils.llm import tracker_as_readable_transcript
+from rasa.shared.core.trackers import (
+    DialogueStateTracker,
+)
 
 structlogger = structlog.get_logger()
 
 MAX_NUMBER_OF_STEPS = 250
 
-MAX_AGENT_RETRY_DELAY_SECONDS = 5
-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."""
@@ -168,13 +148,6 @@ 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.
-    agent_stack_frame = tracker.stack.top()
-    if agent_stack_frame and isinstance(agent_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
@@ -386,7 +359,7 @@ def reset_scoped_slots(
     return events
 
 
-async def advance_flows(
+def advance_flows(
     tracker: DialogueStateTracker, available_actions: List[str], flows: FlowsList
 ) -> FlowActionPrediction:
     """Advance the current flows until the next action.
@@ -404,10 +377,10 @@ async def advance_flows(
         # if there are no flows, there is nothing to do
         return FlowActionPrediction(None, 0.0)
 
-    return await advance_flows_until_next_action(tracker, available_actions, flows)
+    return advance_flows_until_next_action(tracker, available_actions, flows)
 
 
-async def advance_flows_until_next_action(
+def advance_flows_until_next_action(
     tracker: DialogueStateTracker,
     available_actions: List[str],
     flows: FlowsList,
@@ -468,7 +441,7 @@ async def advance_flows_until_next_action(
 
             with bound_contextvars(step_id=next_step.id):
                 step_stack = tracker.stack
-                step_result = await run_step(
+                step_result = run_step(
                     next_step,
                     current_flow,
                     step_stack,
@@ -504,9 +477,10 @@ async 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 = prediction.metadata or {}
-        prediction.metadata[ACTIVE_FLOW_METADATA_KEY] = tracker.active_flow
-        prediction.metadata[STEP_ID_METADATA_KEY] = tracker.current_step_id
+        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")
@@ -548,8 +522,6 @@ 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):
@@ -578,7 +550,7 @@ def attach_stack_metadata_to_events(
         event.metadata[ACTIVE_FLOW_METADATA_KEY] = flow_id
 
 
-async def run_step(
+def run_step(
     step: FlowStep,
     flow: Flow,
     stack: DialogueStack,
@@ -643,7 +615,7 @@ async def run_step(
         return _run_link_step(initial_events, stack, step)
 
     elif isinstance(step, CallFlowStep):
-        return await _run_call_step(initial_events, stack, step, tracker)
+        return _run_call_step(initial_events, stack, step)
 
     elif isinstance(step, SetSlotsFlowStep):
         return _run_set_slot_step(initial_events, step)
@@ -712,25 +684,17 @@ def _run_set_slot_step(
     return ContinueFlowWithNextStep(events=initial_events + slot_events)
 
 
-async def _run_call_step(
-    initial_events: List[Event],
-    stack: DialogueStack,
-    step: CallFlowStep,
-    tracker: DialogueStateTracker,
+def _run_call_step(
+    initial_events: List[Event], stack: DialogueStack, step: CallFlowStep
 ) -> FlowStepResult:
     structlogger.debug("flow.step.run.call")
-    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)
-    else:
-        stack.push(
-            UserFlowStackFrame(
-                flow_id=step.call,
-                frame_type=FlowStackFrameType.CALL,
-            ),
-        )
-        return ContinueFlowWithNextStep(events=initial_events)
+    stack.push(
+        UserFlowStackFrame(
+            flow_id=step.call,
+            frame_type=FlowStackFrameType.CALL,
+        ),
+    )
+    return ContinueFlowWithNextStep(events=initial_events)
 
 
 def _run_link_step(
@@ -868,306 +832,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,
-) -> 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 {}
-    )
-    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=_filter_slots_for_agent(tracker.current_slot_values()),
-        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_TOOL_RESULTS_KEY] = output.tool_results or []
-
-        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:
-        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:
-        # 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:
-        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,
-            )
-
-        agent_response: AgentOutput = await AgentManager().run_agent(
-            agent_name=agent_name, protocol_type=protocol_type, context=agent_input
-        )
-        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 _filter_slots_for_agent(slots: Dict[str, Any]) -> Dict[str, Any]:
-    """Filter out slots that should not be forwarded to agents.
-
-    Args:
-        slots: The full slot dictionary from the tracker.
-
-    Returns:
-        A copy of the slot dictionary excluding slots listed in
-        `SLOTS_EXCLUDED_FOR_AGENT`.
-    """
-    return {
-        key: value
-        for key, value in slots.items()
-        if key not in SLOTS_EXCLUDED_FOR_AGENT
-    }