rasa-pro 3.14.0.dev4__tar.gz → 3.14.0.dev6__tar.gz

{rasa_pro-3.14.0.dev4 → rasa_pro-3.14.0.dev6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: rasa-pro
-Version: 3.14.0.dev4
+Version: 3.14.0.dev6
 Summary: State-of-the-art open-core Conversational AI framework for Enterprises that natively leverages generative AI for effortless assistant development.
 Keywords: nlp,machine-learning,machine-learning-library,bot,bots,botkit,rasa conversational-agents,conversational-ai,chatbot,chatbot-framework,bot-framework
 Author: Rasa Technologies GmbH

{rasa_pro-3.14.0.dev4 → rasa_pro-3.14.0.dev6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "rasa-pro"
-version = "3.14.0.dev4"
+version = "3.14.0.dev6"
 description = "State-of-the-art open-core Conversational AI framework for Enterprises that natively leverages generative AI for effortless assistant development."
 authors = [ "Rasa Technologies GmbH <hi@rasa.com>",]
 maintainers = [ "Tom Bocklisch <tom@rasa.com>",]
@@ -360,6 +360,7 @@ convention = "google"
 
 
 
+
 [tool.poetry.group.dev.dependencies]
 ruff = ">=0.3.5,<0.4.0"
 docker = "~7.1.0"

{rasa_pro-3.14.0.dev4 → rasa_pro-3.14.0.dev6}/rasa/agents/agent_manager.py

@@ -8,6 +8,7 @@ from rasa.agents.core.types import AgentIdentifier, ProtocolType
 from rasa.agents.schemas import AgentInput, AgentOutput
 from rasa.core.available_agents import AgentConfig
 from rasa.shared.agents.utils import make_agent_identifier
+from rasa.shared.exceptions import AgentInitializationException
 from rasa.utils.singleton import Singleton
 
 structlogger = structlog.get_logger()
@@ -41,7 +42,7 @@ class AgentManager(metaclass=Singleton):
             ValueError: If the agent is not connected.
         """
         if agent_identifier not in self.agents:
-            raise ValueError(f"Agent {agent_identifier} not connected")
+            raise ValueError(f"Agent {agent_identifier} is not available")
         del self.agents[agent_identifier]
 
     def get_agent(self, agent_name: str, protocol_type: ProtocolType) -> AgentProtocol:
@@ -59,7 +60,7 @@ class AgentManager(metaclass=Singleton):
         """
         agent_identifier = make_agent_identifier(agent_name, protocol_type)
         if agent_identifier not in self.agents:
-            raise ValueError(f"Agent {agent_identifier} not connected")
+            raise ValueError(f"Agent {agent_identifier} is not available")
         return self.agents[agent_identifier]
 
     async def connect_agent(
@@ -100,7 +101,7 @@ class AgentManager(metaclass=Singleton):
                 agent_id=str(agent_identifier),
                 event_info=event_info,
             )
-            raise ConnectionError(e)
+            raise AgentInitializationException(e)
 
     async def run_agent(
         self, agent_name: str, protocol_type: ProtocolType, context: AgentInput
@@ -138,12 +139,12 @@ class AgentManager(metaclass=Singleton):
             protocol_type: The protocol type of the agent.
 
         Raises:
-            ValueError: If the agent is not connected.
+            ValueError: If the agent is not available.
             ConnectionError: If the agent disconnection fails.
         """
         agent_identifier = make_agent_identifier(agent_name, protocol_type)
         if agent_identifier not in self.agents:
-            raise ValueError(f"Agent {agent_identifier} not connected")
+            raise ValueError(f"Agent {agent_identifier} is not available")
         try:
             await self.get_agent(agent_name, protocol_type).disconnect()
             self._remove_agent(agent_identifier)

{rasa_pro-3.14.0.dev4 → rasa_pro-3.14.0.dev6}/rasa/agents/protocol/mcp/mcp_base_agent.py

@@ -45,6 +45,7 @@ from rasa.shared.constants import (
     TIMEOUT_CONFIG_KEY,
 )
 from rasa.shared.core.events import BotUttered, UserUttered
+from rasa.shared.exceptions import AgentInitializationException
 from rasa.shared.providers.llm.llm_response import LLMResponse, LLMToolCall
 from rasa.shared.utils.constants import LOG_COMPONENT_SOURCE_METHOD_INIT
 from rasa.shared.utils.llm import (
@@ -261,12 +262,19 @@ class MCPBaseAgent(AgentProtocol):
                         "mcp_agent.connect.failed_after_retries",
                         event_info="All connection attempts failed.",
                     )
+                    raise AgentInitializationException(
+                        f"Failed to connect to MCP servers after {self._max_retries} "
+                        f"attempts. Agent `{self._name}` failed to initialize."
+                    ) from ce
             except Exception as e:
                 structlogger.error(
                     "mcp_agent.connect.unexpected_exception",
                     event_info="Unexpected error during agent initialization.",
                     error=str(e),
+                    agent_name=self._name,
+                    agent_id=str(make_agent_identifier(self._name, self.protocol_type)),
                 )
+                raise AgentInitializationException(e) from e
 
     async def connect_to_server(self, server_config: AgentMCPServerConfig) -> None:
         server_name = server_config.name

{rasa_pro-3.14.0.dev4 → rasa_pro-3.14.0.dev6}/rasa/agents/protocol/mcp/mcp_open_agent.py

@@ -228,6 +228,17 @@ class MCPOpenAgent(MCPBaseAgent):
                                 tool_call.tool_args,
                             )
 
+                            structlogger.debug(
+                                "mcp_open_agent.send_message.tool_output",
+                                tool_output=tool_output,
+                                agent_name=self._name,
+                                agent_id=str(
+                                    make_agent_identifier(
+                                        self._name, self.protocol_type
+                                    )
+                                ),
+                            )
+
                             # If the tool call failed, generate an agent error output.
                             if tool_output.is_error or tool_output.result is None:
                                 return self._generate_agent_error_output(
@@ -247,6 +258,9 @@ class MCPOpenAgent(MCPBaseAgent):
                             )
 
             except Exception as e:
+                # TODO: To log the ProviderClientAPIException separately, so that
+                # malformed tool responses automatically trigger a retry, and are
+                # not cached.
                 structlogger.error(
                     "mcp_open_agent.send_message.error_in_agent_loop",
                     event_info=f"Failed to send message: {e}",

{rasa_pro-3.14.0.dev4 → rasa_pro-3.14.0.dev6}/rasa/agents/protocol/mcp/mcp_task_agent.py

@@ -395,6 +395,18 @@ class MCPTaskAgent(MCPBaseAgent):
                                 tool_call.tool_args,
                             )
 
+                            structlogger.debug(
+                                "mcp_task_agent.send_message.tool_output",
+                                tool_output=tool_output,
+                                tool_name=tool_call.tool_name,
+                                agent_name=self._name,
+                                agent_id=str(
+                                    make_agent_identifier(
+                                        self._name, self.protocol_type
+                                    )
+                                ),
+                            )
+
                             # If the tool call failed, generate an agent error output.
                             if tool_output.is_error or tool_output.result is None:
                                 return self._generate_agent_error_output(
@@ -440,6 +452,9 @@ class MCPTaskAgent(MCPBaseAgent):
                             )
 
             except Exception as e:
+                # TODO: To log the ProviderClientAPIException separately, so that
+                # malformed tool responses automatically trigger a retry, and are
+                # not cached.
                 structlogger.error(
                     "mcp_task_agent.send_message.error_in_agent_loop",
                     event_info=f"Failed to send message: {e}",

{rasa_pro-3.14.0.dev4 → rasa_pro-3.14.0.dev6}/rasa/agents/schemas/agent_tool_result.py

@@ -1,4 +1,3 @@
-import json
 from typing import Optional
 
 from mcp.types import CallToolResult
@@ -11,6 +10,19 @@ class AgentToolResult(BaseModel):
     is_error: bool = False
     error_message: Optional[str] = None
 
+    def __str__(self) -> str:
+        """Provide a clean string representation for logging."""
+        if self.is_error:
+            return (
+                f"AgentToolResult(tool_name='{self.tool_name}', "
+                f"error='{self.error_message}')"
+            )
+        return f"AgentToolResult(tool_name='{self.tool_name}', result={self.result})"
+
+    def __repr__(self) -> str:
+        """Provide a detailed representation for debugging."""
+        return self.__str__()
+
     @classmethod
     def from_mcp_tool_result(
         cls, tool_name: str, tool_result: CallToolResult
@@ -25,9 +37,15 @@ class AgentToolResult(BaseModel):
 
         # try to use structured content if available
         if tool_result.structuredContent:
+            if "result" in tool_result.structuredContent:
+                return cls(
+                    tool_name=tool_name,
+                    result=str(tool_result.structuredContent["result"]),
+                    is_error=tool_result.isError,
+                )
             return cls(
                 tool_name=tool_name,
-                result=json.dumps(tool_result.structuredContent),
+                result=str(tool_result.structuredContent),
                 is_error=tool_result.isError,
             )
         # fallback to content if structured content is not available
@@ -36,9 +54,7 @@ class AgentToolResult(BaseModel):
             #   in the tool schema (if present)
             return cls(
                 tool_name=tool_name,
-                result=json.dumps(
-                    [content.model_dump() for content in tool_result.content]
-                ),
+                result=str([content.model_dump() for content in tool_result.content]),
                 is_error=tool_result.isError,
             )
         # if no content is available, return None

{rasa_pro-3.14.0.dev4 → rasa_pro-3.14.0.dev6}/rasa/core/agent.py

@@ -36,7 +36,7 @@ from rasa.privacy.privacy_manager import BackgroundPrivacyManager
 from rasa.shared.constants import DEFAULT_SENDER_ID
 from rasa.shared.core.domain import Domain
 from rasa.shared.core.trackers import DialogueStateTracker, EventVerbosity
-from rasa.shared.exceptions import RasaException
+from rasa.shared.exceptions import AgentInitializationException, RasaException
 from rasa.telemetry import track_privacy_enabled
 from rasa.utils.common import TempDirectoryPath, get_temp_dir_name
 from rasa.utils.endpoints import EndpointConfig
@@ -297,6 +297,8 @@ async def load_agent(
 
         return agent
 
+    except AgentInitializationException as e:
+        raise e
     except Exception as e:
         logger.error(f"Could not load model due to {e}.", exc_info=True)
         return agent

{rasa_pro-3.14.0.dev4 → rasa_pro-3.14.0.dev6}/rasa/core/policies/flows/flow_executor.py

@@ -1148,10 +1148,24 @@ async def _call_agent_with_retry(
                 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),
+            )
 
-        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
 

{rasa_pro-3.14.0.dev4 → rasa_pro-3.14.0.dev6}/rasa/shared/core/flows/flows_list.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Any, Dict, Generator, List, Optional, Set, Text, Union
+from typing import TYPE_CHECKING, Any, Dict, Generator, List, Optional, Set, Text, Union
 
 import rasa.shared.utils.io
 from rasa.shared.core.flows import Flow
@@ -10,6 +10,7 @@ from rasa.shared.core.flows.flow_path import FlowPathsList
 from rasa.shared.core.flows.validation import (
     DuplicatedFlowIdException,
     validate_call_steps,
+    validate_exit_if_conditions,
     validate_flow,
     validate_link_in_call_restriction,
     validate_linked_flows_exists,
@@ -20,6 +21,9 @@ from rasa.shared.core.flows.validation import (
 )
 from rasa.shared.core.slots import Slot
 
+if TYPE_CHECKING:
+    from rasa.shared.core.domain import Domain
+
 
 @dataclass
 class FlowsList:
@@ -160,8 +164,13 @@ class FlowsList:
         else:
             return None
 
-    def validate(self) -> None:
-        """Validate the flows."""
+    def validate(self, domain: Optional["Domain"] = None) -> None:
+        """Validate the flows.
+
+        Args:
+            domain: Optional domain containing slot definitions. If provided,
+                   exit_if conditions will be validated against defined slots.
+        """
         for flow in self.underlying_flows:
             validate_flow(flow)
         validate_nlu_trigger(self.underlying_flows)
@@ -171,6 +180,7 @@ class FlowsList:
         validate_patterns_are_not_called_or_linked(self)
         validate_patterns_are_not_calling_or_linking_other_flows(self)
         validate_step_ids_are_unique(self)
+        validate_exit_if_conditions(self, domain)
 
     @property
     def user_flow_ids(self) -> Set[str]:

{rasa_pro-3.14.0.dev4 → rasa_pro-3.14.0.dev6}/rasa/shared/core/flows/validation.py

@@ -6,6 +6,8 @@ from collections import defaultdict
 from dataclasses import dataclass
 from typing import List, Optional, Set, Text
 
+from jinja2 import Template
+
 from rasa.shared.constants import (
     RASA_DEFAULT_FLOW_PATTERN_PREFIX,
     RASA_PATTERN_CHITCHAT,
@@ -35,6 +37,7 @@ from rasa.shared.core.flows.utils import (
 from rasa.shared.exceptions import RasaException
 
 if typing.TYPE_CHECKING:
+    from rasa.shared.core.domain import Domain
     from rasa.shared.core.flows.flows_list import FlowsList
 
 FLOW_ID_REGEX = r"""^[a-zA-Z0-9_][a-zA-Z0-9_-]*?$"""
@@ -107,6 +110,26 @@ class DuplicatedStepIdException(RasaException):
         )
 
 
+class InvalidExitIfConditionException(RasaException):
+    """Raised when an exit_if condition is invalid."""
+
+    def __init__(self, step_id: str, flow_id: str, condition: str, reason: str) -> None:
+        """Initializes the exception."""
+        self.step_id = step_id
+        self.flow_id = flow_id
+        self.condition = condition
+        self.reason = reason
+
+    def __str__(self) -> str:
+        """Return a string representation of the exception."""
+        return (
+            f"Invalid exit_if condition '{self.condition}' in step '{self.step_id}' "
+            f"of flow '{self.flow_id}': {self.reason}. "
+            f"Please ensure that exit_if conditions contain at least one slot "
+            f"reference and use only defined slots with valid predicates."
+        )
+
+
 class DuplicatedFlowIdException(RasaException):
     """Raised when a flow is using the same id as another flow."""
 
@@ -612,6 +635,64 @@ def validate_call_steps(flows: "FlowsList") -> None:
                 )
 
 
+def validate_exit_if_conditions(
+    flows: "FlowsList", domain: Optional["Domain"] = None
+) -> None:
+    """Validates that exit_if conditions are valid.
+
+    This function validates:
+    - Each condition contains at least one slot reference
+    - Only defined slots are used within the conditions
+    - The predicates are valid
+
+    Args:
+        flows: The flows to validate.
+        domain: The domain with slot definitions. If None, slot validation is skipped.
+
+    Raises:
+        InvalidExitIfConditionException: If any exit_if condition is invalid.
+    """
+    for flow in flows.underlying_flows:
+        for step in flow.steps:
+            if not isinstance(step, CallFlowStep) or not step.exit_if:
+                continue
+
+            for condition in step.exit_if:
+                if not isinstance(condition, str):
+                    raise InvalidExitIfConditionException(
+                        step.id, flow.id, str(condition), "Condition must be a string"
+                    )
+
+                # Check if condition contains at least one slot reference
+                slot_references = re.findall(r"\bslots\.\w+", condition)
+                if not slot_references:
+                    raise InvalidExitIfConditionException(
+                        step.id,
+                        flow.id,
+                        condition,
+                        "Condition must contain at least one slot reference "
+                        "(e.g., 'slots.slot_name')",
+                    )
+
+                # Validate slot names if domain is provided
+                if domain:
+                    domain_slots = {slot.name: slot for slot in domain.slots}
+                    for slot_ref in slot_references:
+                        slot_name = slot_ref.split(".")[1]
+                        if slot_name not in domain_slots:
+                            raise InvalidExitIfConditionException(
+                                step.id,
+                                flow.id,
+                                condition,
+                                f"Slot '{slot_name}' is not defined in the domain",
+                            )
+
+                        # Validate predicate syntax using pypred
+                        _validate_predicate_syntax_with_pypred(
+                            step.id, flow.id, condition
+                        )
+
+
 def validate_linked_flows_exists(flows: "FlowsList") -> None:
     """Validates that all linked flows exist."""
     for flow in flows.underlying_flows:
@@ -790,3 +871,53 @@ def validate_slot_persistence_configuration(flow: Flow) -> None:
         result = _is_persist_slots_valid(persist_slots, flow_slots)
         if not result.is_valid:
             raise InvalidPersistSlotsException(flow_id, result.invalid_slots)
+
+
+def _validate_predicate_syntax_with_pypred(
+    step_id: str, flow_id: str, condition: str
+) -> None:
+    """Validates predicate syntax using pypred.
+
+    This function validates that the exit_if condition has valid predicate syntax.
+    Pypred catches syntax errors like double operators, invalid expressions, etc.
+
+    Args:
+        step_id: The ID of the step containing the condition.
+        flow_id: The ID of the flow containing the step.
+        condition: The exit_if condition string.
+
+    Raises:
+        InvalidExitIfConditionException: If pypred detects syntax errors.
+    """
+    try:
+        from pypred import Predicate
+
+        # Create a simple test context for syntax validation.
+        # This context works with all slot types since it's only used for:
+        # 1. Template rendering: Basic structure for Jinja2 template rendering
+        # 2. Syntax validation: Pypred validates predicate syntax
+        #    without actual slot values
+        test_context = {"slots": {"test_slot": "test_value"}}
+        rendered_template = Template(condition).render(test_context)
+
+        # Let pypred validate the predicate syntax
+        predicate = Predicate(rendered_template)
+        if not predicate.is_valid():
+            raise InvalidExitIfConditionException(
+                step_id,
+                flow_id,
+                condition,
+                "Invalid predicate syntax",
+            )
+
+    except ImportError:
+        # pypred not available, skip validation
+        pass
+    except Exception as e:
+        # Re-raise pypred errors as predicate syntax errors
+        raise InvalidExitIfConditionException(
+            step_id,
+            flow_id,
+            condition,
+            f"Invalid predicate syntax: {e}",
+        )

{rasa_pro-3.14.0.dev4 → rasa_pro-3.14.0.dev6}/rasa/shared/importers/rasa.py

@@ -74,7 +74,7 @@ class RasaFileImporter(TrainingDataImporter):
     @cached_method
     def get_flows(self) -> FlowsList:
         """Retrieves training stories / rules (see parent class for full docstring)."""
-        return utils.flows_from_paths(self._flow_files)
+        return utils.flows_from_paths(self._flow_files, self.get_domain())
 
     @cached_method
     def get_conversation_tests(self) -> StoryGraph:

{rasa_pro-3.14.0.dev4 → rasa_pro-3.14.0.dev6}/rasa/shared/importers/utils.py

@@ -23,8 +23,14 @@ def story_graph_from_paths(
     return StoryGraph(story_steps)
 
 
-def flows_from_paths(files: List[Text]) -> FlowsList:
-    """Returns the flows from paths."""
+def flows_from_paths(files: List[Text], domain: Optional[Domain] = None) -> FlowsList:
+    """Returns the flows from paths.
+
+    Args:
+        files: List of flow file paths to load.
+        domain: Optional domain for validation. If provided, exit_if conditions
+               will be validated against defined slots.
+    """
     from rasa.shared.core.flows.yaml_flows_io import YAMLFlowsReader
 
     flows = FlowsList(underlying_flows=[])
@@ -32,5 +38,5 @@ def flows_from_paths(files: List[Text]) -> FlowsList:
         flows = flows.merge(
             YAMLFlowsReader.read_from_file(file), ignore_duplicates=False
         )
-    flows.validate()
+    flows.validate(domain)
     return flows

{rasa_pro-3.14.0.dev4 → rasa_pro-3.14.0.dev6}/rasa/shared/providers/llm/llm_response.py

@@ -9,6 +9,7 @@ from litellm.utils import ChatCompletionMessageToolCall
 from pydantic import BaseModel
 
 from rasa.shared.constants import KEY_TOOL_CALLS
+from rasa.shared.exceptions import ProviderClientAPIException
 
 structlogger = structlog.get_logger()
 
@@ -66,10 +67,26 @@ class LLMToolCall(BaseModel):
     @classmethod
     def from_litellm(cls, data: ChatCompletionMessageToolCall) -> "LLMToolCall":
         """Creates an LLMToolResponse from a dictionary."""
+        try:
+            tool_args = json.loads(data.function.arguments)
+        except json.JSONDecodeError as e:
+            structlogger.error(
+                "llm_response.litellm_tool_call.invalid_arguments",
+                tool_name=data.function.name,
+                tool_call=data.function.arguments,
+            )
+            raise ProviderClientAPIException(
+                original_exception=e,
+                message=(
+                    f"Invalid arguments for tool call `{data.function.name}`: "
+                    f"`{data.function.arguments}`"
+                ),
+            )
+
         return cls(
             id=data.id,
             tool_name=data.function.name,
-            tool_args=json.loads(data.function.arguments),
+            tool_args=tool_args,
             type=data.type,
         )
 

{rasa_pro-3.14.0.dev4 → rasa_pro-3.14.0.dev6}/rasa/shared/utils/mcp/server_connection.py

@@ -1,6 +1,7 @@
 """MCP server connection utilities."""
 
 import asyncio
+import warnings
 from contextlib import AsyncExitStack
 from typing import Any, Dict, Optional
 
@@ -11,6 +12,14 @@ from mcp.client.streamable_http import streamablehttp_client
 structlogger = structlog.get_logger()
 
 
+# Suppress RuntimeWarning about unawaited coroutines when MCP server is not reachable.
+warnings.filterwarnings(
+    "ignore",
+    message=".*BaseEventLoop.create_server.*was never awaited.*",
+    category=RuntimeWarning,
+)
+
+
 class MCPServerConnection:
     """
     Manages connection to an MCP server.

{rasa_pro-3.14.0.dev4 → rasa_pro-3.14.0.dev6}/rasa/tracing/instrumentation/instrumentation.py

@@ -53,6 +53,7 @@ from rasa.engine.graph import GraphNode
 from rasa.engine.training.graph_trainer import GraphTrainer
 from rasa.shared.core.domain import Domain
 from rasa.shared.core.flows import FlowsList
+from rasa.shared.core.slots import Slot
 from rasa.shared.core.trackers import DialogueStateTracker
 from rasa.shared.nlu.constants import SET_SLOT_COMMAND
 from rasa.shared.nlu.training_data.message import Message
@@ -1092,10 +1093,11 @@ def _instrument_advance_flows_until_next_action(
             tracker: DialogueStateTracker,
             available_actions: List[str],
             flows: FlowsList,
+            slots: List[Slot],
         ) -> FlowActionPrediction:
             with tracer.start_as_current_span(f"{module_name}.{fn.__name__}") as span:
                 prediction: FlowActionPrediction = await fn(
-                    tracker, available_actions, flows
+                    tracker, available_actions, flows, slots
                 )
 
                 span.set_attributes(

{rasa_pro-3.14.0.dev4 → rasa_pro-3.14.0.dev6}/rasa/version.py

@@ -1,3 +1,3 @@
 # this file will automatically be changed,
 # do not add anything but the version number here!
-__version__ = "3.14.0.dev4"
+__version__ = "3.14.0.dev6"