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

rasa/__main__.py

@@ -1,4 +1,7 @@
 import argparse
+
+# Check TensorFlow availability without importing the module
+import importlib.util
 import os
 import platform
 import sys
@@ -10,7 +13,6 @@ from rasa_sdk import __version__ as rasa_sdk_version
 import rasa.telemetry
 import rasa.utils.io
 import rasa.utils.licensing
-import rasa.utils.tensorflow.environment as tf_env
 from rasa import version
 from rasa.cli import (
     data,
@@ -40,6 +42,14 @@ from rasa.shared.exceptions import RasaException
 from rasa.utils.common import configure_logging_and_warnings
 from rasa.utils.log_utils import configure_structlog
 
+TENSORFLOW_AVAILABLE = importlib.util.find_spec("tensorflow") is not None
+
+# Only import TensorFlow modules if TensorFlow is available
+if TENSORFLOW_AVAILABLE:
+    import rasa.utils.tensorflow.environment as tf_env
+else:
+    tf_env = None  # type: ignore[assignment]
+
 structlogger = structlog.get_logger()
 
 
@@ -123,8 +133,10 @@ def main(raw_arguments: Optional[List[str]] = None) -> None:
     rasa.utils.io.configure_colored_logging(log_level)
     configure_structlog(log_level)
 
-    tf_env.setup_tf_environment()
-    tf_env.check_deterministic_ops()
+    # Only setup TensorFlow environment if TensorFlow is available
+    if TENSORFLOW_AVAILABLE and tf_env is not None:
+        tf_env.setup_tf_environment()
+        tf_env.check_deterministic_ops()
 
     # insert current path in syspath so custom modules are found
     sys.path.insert(1, os.getcwd())

rasa/agents/agent_factory.py

@@ -40,7 +40,7 @@ class AgentFactory:
             )
             if not cls._is_valid_custom_agent(agent_class, protocol_type):
                 raise ValueError(
-                    f"Agent class {agent_class} does not subclass the "
+                    f"Agent class `{agent_class}` does not subclass the "
                     f"{cls._get_agent_class_from_protocol(protocol_type).__name__} "
                     f"agent class."
                 )
@@ -87,7 +87,7 @@ class AgentFactory:
             protocol_class: The class that implements the protocol.
         """
         if cls.is_protocol_supported(protocol_type):
-            raise ValueError(f"Protocol {protocol_type} already registered.")
+            raise ValueError(f"Protocol {protocol_type.name} already registered.")
         cls._protocols[protocol_type] = protocol_class
 
     @classmethod

rasa/agents/agent_manager.py

@@ -80,6 +80,14 @@ class AgentManager(metaclass=Singleton):
         """
         # Add the agent to the manager
         agent_identifier = make_agent_identifier(agent_name, protocol_type)
+        if agent_identifier in self.agents:
+            structlogger.info(
+                "agent_manager.connect_agent.already_connected",
+                agent_id=str(agent_identifier),
+                agent_name=agent_name,
+                event_info=f"Agent {agent_identifier} already connected",
+            )
+            return
         try:
             # Create the agent client
             client = AgentFactory.create_client(protocol_type, config)
@@ -118,14 +126,54 @@ class AgentManager(metaclass=Singleton):
         """
         agent = self.get_agent(agent_name, protocol_type)
 
+        structlogger.debug(
+            "agent_manager.run_agent.input",
+            event_info="Processing agent input before sending...",
+            agent_name=agent_name,
+            protocol_type=protocol_type,
+        )
+
         # Process input before sending
-        processed_input = await agent.process_input(context)
+        try:
+            processed_input = await agent.process_input(context)
+        except Exception as e:
+            structlogger.error(
+                "agent_manager.run_agent.process_input_failed",
+                agent_name=agent_name,
+                protocol_type=protocol_type,
+                event_info=(
+                    f"Failed to process input for agent '{agent_name}'. "
+                    "Please check your custom implementation."
+                ),
+                error_message=str(e),
+            )
+            raise
 
         # Send message to agent
         output = await agent.run(processed_input)
 
+        structlogger.debug(
+            "agent_manager.run_agent.output",
+            event_info="Agent output received. Processing output...",
+            agent_name=agent_name,
+            protocol_type=protocol_type,
+        )
+
         # Process output before returning
-        processed_output = await agent.process_output(output)
+        try:
+            processed_output = await agent.process_output(output)
+        except Exception as e:
+            structlogger.error(
+                "agent_manager.run_agent.process_output_failed",
+                agent_name=agent_name,
+                protocol_type=protocol_type,
+                event_info=(
+                    f"Failed to process output for agent '{agent_name}'. "
+                    "Please check your custom implementation."
+                ),
+                error_message=str(e),
+            )
+            raise
 
         return processed_output
 

rasa/agents/constants.py

@@ -18,6 +18,9 @@ TOOL_PROPERTIES_KEY = "properties"
 TOOL_REQUIRED_KEY = "required"
 TOOL_PROPERTY_TYPE_KEY = "type"
 
+# MCP Tool Anthropic format related constants
+TOOL_INPUT_SCHEMA_KEY = "input_schema"
+
 # MCP Message related constants
 KEY_ROLE = "role"
 KEY_CONTENT = "content"

rasa/agents/core/types.py

@@ -68,3 +68,14 @@ class AgentStatus(Enum):
     INPUT_REQUIRED = "input_required"
     FATAL_ERROR = "fatal_error"
     RECOVERABLE_ERROR = "recoverable_error"
+
+    def __str__(self) -> str:
+        return self.value
+
+    def __repr__(self) -> str:
+        return f"AgentStatus.{self.value}"
+
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, AgentStatus):
+            return self.value == other.value
+        return False

rasa/agents/protocol/a2a/a2a_agent.py

@@ -50,6 +50,7 @@ from rasa.agents.core.agent_protocol import AgentProtocol
 from rasa.agents.core.types import AgentStatus, ProtocolType
 from rasa.agents.schemas import AgentInput, AgentOutput
 from rasa.core.available_agents import AgentConfig
+from rasa.shared.agents.auth.agent_auth_manager import AgentAuthManager
 from rasa.shared.exceptions import (
     AgentInitializationException,
     InvalidParameterException,
@@ -71,6 +72,10 @@ class A2AAgent(AgentProtocol):
         "application/json",
     ]
 
+    # ============================================================================
+    # Initialization & Setup
+    # ============================================================================
+
     def __init__(
         self,
         name: str,
@@ -78,12 +83,14 @@ class A2AAgent(AgentProtocol):
         agent_card_path: str,
         timeout: int,
         max_retries: int,
+        auth_config: Optional[Dict[str, Any]] = None,
     ) -> None:
         self._name = name
         self._description = description
         self._agent_card_path = agent_card_path
         self._timeout = timeout
         self._max_retries = max_retries
+        self._auth_config = auth_config
 
         self.agent_card: Optional[AgentCard] = None
         self._client: Optional[Client] = None
@@ -111,18 +118,24 @@ class A2AAgent(AgentProtocol):
             else AGENT_DEFAULT_MAX_RETRIES
         )
 
+        _auth_config = config.configuration.auth if config.configuration else None
         return cls(
             name=config.agent.name,
             description=config.agent.description,
             agent_card_path=agent_card_path,
             timeout=timeout,
             max_retries=max_retries,
+            auth_config=_auth_config,
         )
 
     @property
     def protocol_type(self) -> ProtocolType:
         return ProtocolType.A2A
 
+    # ============================================================================
+    # Connection Management
+    # ============================================================================
+
     async def connect(self) -> None:
         """Fetch the AgentCard and initialize the A2A client."""
         from rasa.nlu.utils import is_url
@@ -136,7 +149,8 @@ class A2AAgent(AgentProtocol):
         structlogger.debug(
             "a2a_agent.from_config",
             event_info=f"Loaded agent card from {self._agent_card_path}",
-            agent_card=self.agent_card,
+            agent_card=self.agent_card.model_dump(),
+            json_formatting=["agent_card"],
         )
 
         try:
@@ -169,6 +183,10 @@ class A2AAgent(AgentProtocol):
         """We don't need to explicitly disconnect the A2A client"""
         return
 
+    # ============================================================================
+    # Core Protocol Methods
+    # ============================================================================
+
     async def process_input(self, agent_input: AgentInput) -> AgentInput:
         """Pre-process the input before sending it to the agent."""
         # A2A-specific input processing logic
@@ -267,6 +285,10 @@ class A2AAgent(AgentProtocol):
         # A2A-specific output processing logic
         return output
 
+    # ============================================================================
+    # Message Processing & Response Handling
+    # ============================================================================
+
     def _handle_send_message_response(
         self, agent_input: AgentInput, response: ClientEvent | Message
     ) -> Optional[AgentOutput]:
@@ -335,8 +357,9 @@ class A2AAgent(AgentProtocol):
         structlogger.debug(
             "a2a_agent.run.client_event_received",
             event_info="Received client event from A2A",
-            task=task,
-            update_event=update_event,
+            task=task.model_dump() if task else None,
+            update_event=update_event.model_dump() if update_event else None,
+            json_formatting=["task", "update_event"],
         )
 
         return self._handle_task(agent_input=agent_input, task=task)
@@ -348,7 +371,8 @@ class A2AAgent(AgentProtocol):
             "a2a_agent.run.message_received",
             event_info="Received message from A2A",
             agent_name=self._name,
-            message=message,
+            message=message.model_dump(),
+            json_formatting=["message"],
         )
         metadata = agent_input.metadata or {}
         metadata[A2A_AGENT_CONTEXT_ID_KEY] = message.context_id
@@ -442,6 +466,16 @@ class A2AAgent(AgentProtocol):
         elif state == TaskState.submitted or state == TaskState.working:
             # The task is still in progress, return None to continue waiting for updates
             return None
+        elif state == TaskState.unknown:
+            # The task has an unknown state. Perhaps this is a transient condition.
+            # Return None to continue waiting for updates
+            structlogger.warning(
+                "a2a_agent.run_streaming_agent.unknown_task_state",
+                event_info="Task is in unknown state, continuing to wait for updates",
+                agent_name=self._name,
+                state=state,
+            )
+            return None
         else:
             structlogger.error(
                 "a2a_agent.run_streaming_agent.unexpected_task_state",
@@ -456,6 +490,10 @@ class A2AAgent(AgentProtocol):
                 metadata=metadata,
             )
 
+    # ============================================================================
+    # Message Preparation & Formatting
+    # ============================================================================
+
     @staticmethod
     def _prepare_message(agent_input: AgentInput) -> Message:
         parts: List[Part] = []
@@ -488,10 +526,15 @@ class A2AAgent(AgentProtocol):
             "a2a_agent.prepare_message",
             event_info="Prepared message to send to A2A server",
             agent_name=agent_input.id,
-            message=agent_message,
+            message=agent_message.model_dump(),
+            json_formatting=["message"],
         )
         return agent_message
 
+    # ============================================================================
+    # Task Management & Polling
+    # ============================================================================
+
     async def _pool_task_until_terminal(
         self,
         agent_input: AgentInput,
@@ -574,6 +617,10 @@ class A2AAgent(AgentProtocol):
                     error_message=f"Polling error: {exception!s}",
                 )
 
+    # ============================================================================
+    # Response Generation & Formatting
+    # ============================================================================
+
     @staticmethod
     def _generate_response_message_from_parts(parts: Optional[List[Part]]) -> str:
         """Convert a list of Part objects to a single string message."""
@@ -606,21 +653,21 @@ class A2AAgent(AgentProtocol):
         In case of completed tasks, the final message might be in
         the task status message or in the artifacts (or both).
         """
-        result = ""
+        # We need to preserve the order of the message,
+        # but also make sure to remove any duplicates.
+        result: List[str] = []
         if task.status.message:
-            result += (
-                A2AAgent._generate_response_message_from_parts(
-                    task.status.message.parts
-                )
-                + "\n"
+            message = A2AAgent._generate_response_message_from_parts(
+                task.status.message.parts
             )
+            if message and message not in result:
+                result.append(message)
         if task.artifacts:
             for artifact in task.artifacts:
-                result += (
-                    A2AAgent._generate_response_message_from_parts(artifact.parts)
-                    + "\n"
-                )
-        return result.strip()
+                message = A2AAgent._generate_response_message_from_parts(artifact.parts)
+                if message and message not in result:
+                    result.append(message)
+        return "\n".join(result)
 
     @staticmethod
     def _generate_structured_results_from_artifacts(
@@ -662,6 +709,10 @@ class A2AAgent(AgentProtocol):
 
         return previous_structured_results
 
+    # ============================================================================
+    # Agent Card Management
+    # ============================================================================
+
     @staticmethod
     def _load_agent_card_from_file(agent_card_path: str) -> AgentCard:
         """Load agent card from JSON file."""
@@ -745,10 +796,18 @@ class A2AAgent(AgentProtocol):
             f"{max_retries} attempts."
         )
 
+    # ============================================================================
+    # Client Initialization & Health Checks
+    # ============================================================================
+
     def _init_client(self) -> Client:
+        _agent_manager = AgentAuthManager.load_auth(self._auth_config)
+        auth_strategy = _agent_manager.get_auth() if _agent_manager else None
         factory = ClientFactory(
             config=ClientConfig(
-                httpx_client=httpx.AsyncClient(timeout=self._timeout),
+                httpx_client=httpx.AsyncClient(
+                    timeout=self._timeout, auth=auth_strategy
+                ),
                 streaming=True,
                 supported_transports=[
                     TransportProtocol.jsonrpc,

rasa/agents/protocol/mcp/mcp_base_agent.py

@@ -1,5 +1,6 @@
 import json
 from abc import abstractmethod
+from datetime import datetime
 from inspect import isawaitable
 from typing import Any, Dict, List, Optional, Tuple
 
@@ -183,17 +184,26 @@ class MCPBaseAgent(AgentProtocol):
         """Add custom tool definitions and their executors for MCP agents.
 
         This method can be overridden to provide custom tools that the agent
-        can use during its operation. The tools should be defined in the OpenAI
-        JSON format, which includes the tool name, description, and parameters.
+        can use during its operation. Each tool definition follows the LiteLLM JSON
+        format and must include:
+        - "type": should always be "function" for tools.
+        - "function" → the tool metadata (name, description, and parameters).
+        - "tool_executor" → a coroutine method that actually performs the tool's action.
 
-        Refer: https://platform.openai.com/docs/guides/function-calling?api-mode=responses
+        Refer:
+        - LiteLLM JSON Format - https://docs.litellm.ai/docs/completion/function_call#full-code---parallel-function-calling-with-gpt-35-turbo-1106
+        - OpenAI Tool JSON Format - https://platform.openai.com/docs/guides/tools?tool-type=function-calling
 
         Note:
-            The tool executor method should be a coroutine function that returns an
+            - In LiteLLM, the tool metadata is wrapped inside the "function" key.
+            - This differs from OpenAI's format, where the metadata (name, description,
+            parameters) sits at the top level. Be careful when copying examples from
+            OpenAI docs.
+            - The tool executor method should be a coroutine function that returns an
             AgentToolResult object.
 
         Returns:
-            A list of custom tool definitions along with their tool executor method.
+            A list of tool definitions paired with their executors.
 
         Example:
             ```python
@@ -493,11 +503,25 @@ class MCPBaseAgent(AgentProtocol):
     # LLM & Prompt Management
     # ============================================================================
 
+    def _get_current_date_time_day(self) -> Tuple[str, str, str]:
+        """Get the current date, time, and day in standard formats."""
+        now = datetime.now()
+        current_date = now.strftime("%Y-%m-%d")  # e.g. 2025-09-14
+        current_time = now.strftime("%H:%M:%S")  # e.g. 16:45:12
+        current_day = now.strftime("%A")  # e.g. Sunday
+        return current_date, current_time, current_day
+
     def render_prompt_template(self, context: AgentInput) -> str:
         """Render the prompt template with the provided inputs."""
+        # Current date, time, and weekday in standard formats
+        current_date, current_time, current_day = self._get_current_date_time_day()
+
         return Template(self.prompt_template).render(
             **context.model_dump(exclude={"id", "timestamp", "events"}),
             description=self._description,
+            current_date=current_date,
+            current_time=current_time,
+            current_day=current_day,
         )
 
     def build_messages_for_llm_request(

rasa/agents/protocol/mcp/mcp_open_agent.py

@@ -112,7 +112,7 @@ class MCPOpenAgent(MCPBaseAgent):
         cls, agent_input: AgentInput
     ) -> List[AgentToolSchema]:
         """Get agentic specific built-in tools."""
-        return [AgentToolSchema.from_openai_json_format(cls.get_task_completed_tool())]
+        return [AgentToolSchema.from_litellm_json_format(cls.get_task_completed_tool())]
 
     def _run_task_completed_tool(
         self,
@@ -145,14 +145,22 @@ class MCPOpenAgent(MCPBaseAgent):
         tool_results: Dict[str, AgentToolResult] = {}
         # Convert available tools to OpenAI JSON format
         tools_in_openai_format = [
-            tool.to_openai_json_format()
+            tool.to_litellm_json_format()
             for tool in self.get_available_tools(agent_input)
         ]
 
         for iteration in range(self.MAX_ITERATIONS):
             try:
+                structlogger.debug(
+                    "mcp_task_agent.send_message.iteration",
+                    event_info=(
+                        f"Starting iteration {iteration + 1} for agent {self._name}"
+                    ),
+                    agent_id=str(make_agent_identifier(self._name, self.protocol_type)),
+                    highlight=True,
+                )
                 # Make the LLM call using the llm_client
-                structlogger.info(
+                structlogger.debug(
                     "mcp_open_agent.send_message.sending_message_to_llm",
                     messages=messages,
                     event_info=f"Sending message to LLM (iteration {iteration + 1})",
@@ -182,8 +190,10 @@ class MCPOpenAgent(MCPBaseAgent):
                         id=agent_input.id,
                         status=AgentStatus.RECOVERABLE_ERROR,
                         error_message=event_info,
-                        structured_results=self._get_structured_results_for_agent_output(
-                            agent_input, tool_results
+                        structured_results=(
+                            self._get_structured_results_for_agent_output(
+                                agent_input, tool_results
+                            )
                         ),
                     )
 
@@ -193,8 +203,10 @@ class MCPOpenAgent(MCPBaseAgent):
                         id=agent_input.id,
                         status=AgentStatus.INPUT_REQUIRED,
                         response_message=llm_response.choices[0],
-                        structured_results=self._get_structured_results_for_agent_output(
-                            agent_input, tool_results
+                        structured_results=(
+                            self._get_structured_results_for_agent_output(
+                                agent_input, tool_results
+                            )
                         ),
                     )
 
@@ -205,18 +217,16 @@ class MCPOpenAgent(MCPBaseAgent):
                         self._get_assistant_message_with_tool_calls(llm_response)
                     )
                     for tool_call in llm_response.tool_calls:
-                        structlogger.info(
+                        structlogger.debug(
                             "mcp_open_agent.send_message.tool_call",
-                            event_info=(
-                                f"Processing tool call `{tool_call.tool_name}` with "
-                                f"args: {tool_call.tool_args}"
-                            ),
+                            event_info=f"Processing tool call {tool_call.tool_name}",
                             tool_name=tool_call.tool_name,
                             tool_args=json.dumps(tool_call.tool_args),
                             agent_name=self._name,
                             agent_id=str(
                                 make_agent_identifier(self._name, self.protocol_type)
                             ),
+                            json_formatting=["tool_args"],
                         )
 
                         # Agent signals task completion.
@@ -234,7 +244,11 @@ class MCPOpenAgent(MCPBaseAgent):
 
                             structlogger.debug(
                                 "mcp_open_agent.send_message.tool_output",
-                                tool_output=tool_output,
+                                event_info=(
+                                    f"Tool output for tool call {tool_call.tool_name}"
+                                ),
+                                tool_output=tool_output.model_dump(),
+                                json_formatting=["tool_output"],
                                 agent_name=self._name,
                                 agent_id=str(
                                     make_agent_identifier(