rasa-pro 3.14.0rc1__py3-none-any.whl → 3.14.0rc3__py3-none-any.whl

rasa/agents/protocol/a2a/a2a_agent.py

@@ -3,6 +3,7 @@ import json
 import os
 import time
 import uuid
+from contextlib import aclosing
 from typing import Any, ClassVar, Dict, List, Optional
 from urllib.parse import urlparse
 
@@ -168,8 +169,7 @@ class A2AAgent(AgentProtocol):
                 error=str(exception),
             )
             raise AgentInitializationException(
-                f"Failed to initialize A2A client for agent "
-                f"'{self._name}': {exception}"
+                f"Failed to initialize A2A client for agent '{self._name}': {exception}"
             ) from exception
 
         await self._perform_health_check()
@@ -215,21 +215,26 @@ class A2AAgent(AgentProtocol):
         task_id: Optional[str] = None
         events_received = 0
         try:
-            async for event in self._client.send_message(message):
-                events_received += 1
-                agent_output = self._handle_send_message_response(agent_input, event)
-                if agent_output is not None:
-                    return agent_output
-                else:
-                    # Not a terminal response, save taskID (in case that's the only
-                    # event, and we need to pool) and continue waiting for next events
-                    if (
-                        isinstance(event, tuple)
-                        and len(event) == 2
-                        and isinstance(event[0], Task)
-                    ):
-                        task_id = event[0].id
-                    continue
+            # Use aclosing to ensure proper cleanup of the async generator
+            stream = self._client.send_message(message)
+            async with aclosing(stream) as stream:  # type: ignore[type-var]
+                async for event in stream:
+                    events_received += 1
+                    agent_output = self._handle_send_message_response(
+                        agent_input, event
+                    )
+                    if agent_output is not None:
+                        return agent_output
+                    else:
+                        # Not a terminal response, save taskID (in case that's the only
+                        # event, and we need to pool) and continue waiting for events
+                        if (
+                            isinstance(event, tuple)
+                            and len(event) == 2
+                            and isinstance(event[0], Task)
+                        ):
+                            task_id = event[0].id
+                        continue
         except A2AClientJSONRPCError as e:
             return self._handle_json_rpc_error_response(agent_input, e.error)
         except A2AClientError as exception:
@@ -833,37 +838,40 @@ class A2AAgent(AgentProtocol):
                 parts=[Part(root=TextPart(text="hello"))],
                 message_id=str(uuid.uuid4()),
             )
-            async for event in self._client.send_message(test_message):
-                if (
-                    isinstance(event, Message)
-                    or isinstance(event, tuple)
-                    and len(event) == 2
-                    and isinstance(event[0], Task)
-                ):
-                    # We got a valid response, health check succeeded
-                    return
+            # Use aclosing to ensure proper cleanup of the async generator
+            stream = self._client.send_message(test_message)
+            async with aclosing(stream) as stream:  # type: ignore[type-var]
+                async for event in stream:
+                    if (
+                        isinstance(event, Message)
+                        or isinstance(event, tuple)
+                        and len(event) == 2
+                        and isinstance(event[0], Task)
+                    ):
+                        # We got a valid response, health check succeeded
+                        return
 
-                event_info = "Unexpected response type during health check"
+                    event_info = "Unexpected response type during health check"
+                    structlogger.error(
+                        "a2a_agent.health_check.unexpected_response",
+                        event_info=event_info,
+                        agent_name=self._name,
+                        response=event,
+                        url=str(self.agent_card.url),
+                    )
+                    raise AgentInitializationException(f"{event_info}: {event}")
+                # If the loop completes with no return, no events were received
+                event_info = (
+                    f"Health check failed for A2A agent '{self._name}' "
+                    f"at {self.agent_card.url}: no events received"
+                )
                 structlogger.error(
-                    "a2a_agent.health_check.unexpected_response",
+                    "a2a_agent.health_check.no_events",
                     event_info=event_info,
                     agent_name=self._name,
-                    response=event,
                     url=str(self.agent_card.url),
                 )
-                raise AgentInitializationException(f"{event_info}: {event}")
-            # If the loop completes with no return, no events were received
-            event_info = (
-                f"Health check failed for A2A agent '{self._name}' "
-                f"at {self.agent_card.url}: no events received"
-            )
-            structlogger.error(
-                "a2a_agent.health_check.no_events",
-                event_info=event_info,
-                agent_name=self._name,
-                url=str(self.agent_card.url),
-            )
-            raise AgentInitializationException(event_info)
+                raise AgentInitializationException(event_info)
         except Exception as exception:
             event_info = (
                 f"Health check failed for A2A agent '{self._name}' at "

rasa/agents/utils.py

@@ -127,7 +127,9 @@ def is_agent_valid(agent_id: str) -> bool:
     Returns:
         True if the agent exists, False otherwise.
     """
-    agent_config = AvailableAgents.get_agent_config(agent_id)
+    agent_config = Configuration.get_instance().available_agents.get_agent_config(
+        agent_id
+    )
     return agent_config is not None
 
 
@@ -159,7 +161,9 @@ def get_agent_info(agent_id: str) -> Optional[Dict[str, str]]:
     Returns:
         Dictionary with agent name and description if found, None otherwise.
     """
-    agent_config = AvailableAgents.get_agent_config(agent_id)
+    agent_config = Configuration.get_instance().available_agents.get_agent_config(
+        agent_id
+    )
     if agent_config is None:
         return None
 
@@ -170,7 +174,7 @@ def get_agent_info(agent_id: str) -> Optional[Dict[str, str]]:
 
 
 def get_completed_agents_info(tracker: DialogueStateTracker) -> List[Dict[str, str]]:
-    """Get information for all completed agents.
+    """Get information for all completed agents in the currently active flow.
 
     Args:
         tracker: The dialogue state tracker.
@@ -178,12 +182,30 @@ def get_completed_agents_info(tracker: DialogueStateTracker) -> List[Dict[str, s
     Returns:
         List of dictionaries containing agent information for completed agents.
     """
+    from rasa.dialogue_understanding.stack.utils import top_user_flow_frame
+
+    # Get the currently active flow
+    top_flow_frame = top_user_flow_frame(tracker.stack)
+    if not top_flow_frame:
+        # No active flow, return empty list
+        return []
+
+    current_flow_id = top_flow_frame.flow_id
     completed_agents = []
+
+    # Get all agents that completed in the current flow
+    agents_completed_in_current_flow = set()
     for event in reversed(tracker.events):
-        if isinstance(event, AgentCompleted):
-            agent_info = get_agent_info(event.agent_id)
+        if isinstance(event, AgentCompleted) and event.flow_id == current_flow_id:
+            agents_completed_in_current_flow.add(event.agent_id)
+
+    # Only include agents that are completed (not currently running)
+    for agent_id in agents_completed_in_current_flow:
+        if is_agent_completed(tracker, agent_id):
+            agent_info = get_agent_info(agent_id)
             if agent_info:
                 completed_agents.append(agent_info)
+
     return completed_agents
 
 

rasa/agents/validation.py

@@ -6,7 +6,6 @@ from collections import Counter
 from typing import Any, Dict, List, NoReturn, Set
 
 from pydantic import ValidationError as PydanticValidationError
-from ruamel import yaml
 
 from rasa.agents.exceptions import (
     AgentNameFlowConflictException,
@@ -18,11 +17,13 @@ from rasa.core.available_agents import (
     AgentConfiguration,
     AgentConnections,
     AgentInfo,
+    AvailableAgents,
     ProtocolConfig,
 )
 from rasa.core.config.available_endpoints import AvailableEndpoints
 from rasa.core.config.configuration import Configuration
 from rasa.exceptions import ValidationError
+from rasa.shared.utils.yaml import read_config_file
 
 # Centralized allowed keys configuration to eliminate duplication
 ALLOWED_KEYS = {
@@ -34,6 +35,7 @@ ALLOWED_KEYS = {
         "timeout",
         "max_retries",
         "agent_card",
+        "auth",
     },
     "connections": {"mcp_servers"},
 }
@@ -348,9 +350,9 @@ def _validate_mandatory_fields(data: Dict[str, Any], agent_name: str) -> None:
             ),
         )
 
-    # Check for required fields
+    # Check for required fields (protocol is optional due to default in model)
     missing_fields = []
-    for field in ["name", "protocol", "description"]:
+    for field in ["name", "description"]:
         if field not in agent_data or not agent_data[field]:
             missing_fields.append(field)
 
@@ -433,8 +435,7 @@ def validate_agent_folder(agent_folder: str = DEFAULT_AGENTS_CONFIG_FOLDER) -> N
         # Read and validate the config content
         try:
             # First read the raw YAML data to validate structure
-            with open(config_path, "r") as f:
-                data = yaml.safe_load(f)
+            data = read_config_file(config_path)
 
             # Validate no additional keys
             _validate_no_additional_keys_raw_data(data)
@@ -442,10 +443,7 @@ def validate_agent_folder(agent_folder: str = DEFAULT_AGENTS_CONFIG_FOLDER) -> N
             # Validate mandatory fields before creating Pydantic models
             _validate_mandatory_fields(data, agent_folder_name)
 
-            # Create the agent config using AvailableAgents
-            from rasa.core.available_agents import AvailableAgents
-
-            agent_config = AvailableAgents._read_agent_config(config_path)
+            agent_config = AvailableAgents.from_dict(data)
 
             # Validate the agent config (protocol-specific and endpoint references)
             validate_agent_config(agent_config)

rasa/api.py

@@ -37,11 +37,10 @@ def run(
     """
     import rasa.core.run
     import rasa.shared.utils.common
-    from rasa.core.available_agents import AvailableAgents
     from rasa.shared.constants import DOCS_BASE_URL
     from rasa.shared.utils.cli import print_warning
 
-    _sub_agents = AvailableAgents.get_instance(sub_agents)
+    _sub_agents = Configuration.get_instance().available_agents
 
     credentials = Configuration.get_instance().credentials
 

rasa/builder/copilot/constants.py

@@ -6,6 +6,9 @@ COPILOT_PROMPTS_FILE = "copilot_system_prompt.jinja2"
 COPILOT_LAST_USER_MESSAGE_CONTEXT_PROMPT_FILE = (
     "latest_user_message_context_prompt.jinja2"
 )
+COPILOT_TRAINING_ERROR_HANDLER_PROMPT_FILE = (
+    "copilot_training_error_handler_prompt.jinja2"
+)
 
 # A dot-path for importlib to the rasa internal messages templates
 COPILOT_MESSAGE_TEMPLATES_DIR = "builder.copilot.templated_messages"
@@ -22,7 +25,7 @@ ROLE_COPILOT: Literal["copilot"] = "copilot"
 
 # Rasa internal role - Used to indicate that the message is from the Rasa internal
 # system components.
-ROLE_COPILOT_INTERNAL: Literal["copilot_internal"] = "copilot_internal"
+ROLE_COPILOT_INTERNAL: Literal["internal_copilot_request"] = "internal_copilot_request"
 
 # Copilot Telemetry
 COPILOT_SEGMENT_WRITE_KEY_ENV_VAR = "COPILOT_SEGMENT_WRITE_KEY"

rasa/builder/copilot/copilot.py

@@ -1,9 +1,8 @@
 import asyncio
-import copy
 import importlib
 import json
 from contextlib import asynccontextmanager
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional, Union
 
 import openai
 import structlog
@@ -16,19 +15,24 @@ from rasa.builder.copilot.constants import (
     COPILOT_LAST_USER_MESSAGE_CONTEXT_PROMPT_FILE,
     COPILOT_PROMPTS_DIR,
     COPILOT_PROMPTS_FILE,
+    COPILOT_TRAINING_ERROR_HANDLER_PROMPT_FILE,
     ROLE_COPILOT,
     ROLE_COPILOT_INTERNAL,
-    ROLE_SYSTEM,
     ROLE_USER,
 )
 from rasa.builder.copilot.exceptions import CopilotStreamError
 from rasa.builder.copilot.models import (
+    ChatMessage,
     CopilotChatMessage,
     CopilotContext,
     CopilotGenerationContext,
+    CopilotSystemMessage,
+    EventContent,
+    FileContent,
+    InternalCopilotRequestChatMessage,
     ResponseCategory,
-    TextContent,
     UsageStatistics,
+    UserChatMessage,
 )
 from rasa.builder.document_retrieval.inkeep_document_retrieval import (
     InKeepDocumentRetrieval,
@@ -60,6 +64,12 @@ class Copilot:
                 COPILOT_LAST_USER_MESSAGE_CONTEXT_PROMPT_FILE,
             )
         )
+        self._training_error_handler_prompt_template = Template(
+            importlib.resources.read_text(
+                f"{PACKAGE_NAME}.{COPILOT_PROMPTS_DIR}",
+                COPILOT_TRAINING_ERROR_HANDLER_PROMPT_FILE,
+            )
+        )
 
         # The final stream chunk includes usage statistics.
         self.usage_statistics = UsageStatistics()
@@ -136,12 +146,16 @@ class Copilot:
         """
         relevant_documents = await self.search_rasa_documentation(context)
         messages = await self._build_messages(context, relevant_documents)
+        tracker_event_attachments = self._extract_tracker_event_attachments(
+            context.copilot_chat_history[-1]
+        )
 
         support_evidence = CopilotGenerationContext(
             relevant_documents=relevant_documents,
             system_message=messages[0],
             chat_history=messages[1:-1],
             last_user_message=messages[-1],
+            tracker_event_attachments=tracker_event_attachments,
         )
 
         return (
@@ -205,91 +219,96 @@ class Copilot:
         Returns:
             A list of messages in OpenAI format.
         """
-        # Split chat history into past messages and latest message
-        past_messages = [
-            message
-            for message in context.copilot_chat_history[:-1]
-            if message.response_category != ResponseCategory.GUARDRAILS_POLICY_VIOLATION
-        ]
-        latest_message = context.copilot_chat_history[-1]
-
-        # Create the system message
-        system_message = await self._create_system_message()
-        # Create the chat history messages (excludes the last message)
-        chat_history = self._create_chat_history_messages(past_messages)
-        # Create the last message and add the context to it
-        latest_message_with_context = self._create_last_user_message_with_context(
-            latest_message, context, relevant_documents
+        if not context.copilot_chat_history:
+            return []
+
+        past_messages = self._create_chat_history_messages(
+            context.copilot_chat_history[:-1]
         )
-        return [system_message, *chat_history, latest_message_with_context]
 
-    async def _create_system_message(self) -> Dict[str, Any]:
-        """Render the correct Jinja template based on desired output_type."""
-        rendered_prompt = self._system_message_prompt_template.render()
-        return {"role": ROLE_SYSTEM, "content": rendered_prompt}
+        latest_message = self._process_latest_message(
+            context.copilot_chat_history[-1], context, relevant_documents
+        )
+        system_message = self._create_system_message()
+
+        return [system_message, *past_messages, latest_message]
 
     def _create_chat_history_messages(
-        self,
-        past_messages: List["CopilotChatMessage"],
+        self, chat_history: List[Union[UserChatMessage, CopilotChatMessage]]
     ) -> List[Dict[str, Any]]:
-        """Create the chat history messages for the copilot.
+        """Filter and convert past messages to OpenAI format.
 
-        Filter out messages with response_category of GUARDRAILS_POLICY_VIOLATION.
-        This will filter out all the user messages that were flagged by guardrails, but
-        also the copilot messages that were produced by guardrails.
+        Excludes guardrails policy violations and non-user/copilot messages.
 
         Args:
-            past_messages: List of past messages (excluding the latest message).
+            chat_history: List of chat messages to filter and convert.
 
         Returns:
-            List of messages in OpenAI format.
+            List of messages in OpenAI format
         """
-        return [
-            message.to_openai_format()
-            for message in past_messages
-            if message.response_category != ResponseCategory.GUARDRAILS_POLICY_VIOLATION
-        ]
+        filtered_messages = []
+
+        for message in chat_history:
+            if (
+                message.response_category
+                != ResponseCategory.GUARDRAILS_POLICY_VIOLATION
+                and message.role in [ROLE_USER, ROLE_COPILOT]
+            ):
+                filtered_messages.append(message)
 
-    def _create_last_user_message_with_context(
+        return [message.build_openai_message() for message in filtered_messages]
+
+    def _process_latest_message(
         self,
-        latest_message: "CopilotChatMessage",
+        latest_message: Any,
         context: CopilotContext,
         relevant_documents: List[Document],
     ) -> Dict[str, Any]:
-        """Create the last user message with context.
-
-        The last user message is the last message in the copilot chat history.
-        We add the context prompt with the current conversation, state, assistant logs,
-        assistant files, and relevant documents as a text content block to the beginning
-        of the message.
+        """Process the latest message and convert it to OpenAI format.
 
         Args:
-            context: The context of the copilot.
-            relevant_documents: The relevant documents to use in the context.
+            latest_message: The most recent message from the chat history.
+            context: The copilot context containing conversation state.
+            relevant_documents: List of relevant documents for context.
 
         Returns:
-            The last user message with context in the OpenAI format.
+            Message in OpenAI format.
+
+        Raises:
+            ValueError: If the message type is not supported.
         """
-        last_user_message = copy.deepcopy(latest_message)
-        context_prompt = self._render_last_user_message_context_prompt(
-            context, relevant_documents
-        )
-        last_user_message.content.insert(
-            0, TextContent(type="text", text=context_prompt)
-        )
-        return {
-            "role": ROLE_USER,
-            "content": [
-                {"type": "text", "text": content.text}
-                for content in last_user_message.content
-                if isinstance(content, TextContent)
-            ],
-        }
+        if isinstance(latest_message, UserChatMessage):
+            tracker_event_attachments = latest_message.get_content_blocks_by_type(
+                EventContent
+            )
+            rendered_prompt = self._render_last_user_message_context_prompt(
+                context, relevant_documents, tracker_event_attachments
+            )
+            return latest_message.build_openai_message(prompt=rendered_prompt)
+
+        elif isinstance(latest_message, InternalCopilotRequestChatMessage):
+            rendered_prompt = self._render_training_error_handler_prompt(
+                latest_message, relevant_documents
+            )
+            return latest_message.build_openai_message(prompt=rendered_prompt)
+
+        else:
+            raise ValueError(f"Unexpected message type: {type(latest_message)}")
+
+    def _create_system_message(self) -> Dict[str, Any]:
+        """Create the system message for the conversation.
+
+        Returns:
+            System message in OpenAI format with rendered prompt template.
+        """
+        rendered_prompt = self._system_message_prompt_template.render()
+        return CopilotSystemMessage().build_openai_message(prompt=rendered_prompt)
 
     def _render_last_user_message_context_prompt(
         self,
         context: CopilotContext,
         relevant_documents: List[Document],
+        tracker_event_attachments: List[EventContent],
     ) -> str:
         # Format relevant documentation
         documents = [doc.model_dump() for doc in relevant_documents]
@@ -297,6 +316,8 @@ class Copilot:
         conversation = self._format_conversation_history(context.tracker_context)
         # Format current state
         current_state = self._format_current_state(context.tracker_context)
+        # Format tracker events
+        attachments = self._format_tracker_event_attachments(tracker_event_attachments)
 
         rendered_prompt = self._last_user_message_context_prompt_template.render(
             current_conversation=conversation,
@@ -304,43 +325,90 @@ class Copilot:
             assistant_logs=context.assistant_logs,
             assistant_files=context.assistant_files,
             documentation_results=documents,
+            attachments=attachments,
         )
         return rendered_prompt
 
+    def _render_training_error_handler_prompt(
+        self,
+        internal_request_message: InternalCopilotRequestChatMessage,
+        relevant_documents: List[Document],
+    ) -> str:
+        """Render the training error handler prompt with documentation and context.
+
+        Args:
+            internal_request_message: Internal request message.
+            context: The copilot context.
+            relevant_documents: List of relevant documents for context.
+
+        Returns:
+            Rendered prompt string for training error analysis.
+        """
+        modified_files_dicts: Dict[str, str] = {
+            file.file_path: file.file_content
+            for file in internal_request_message.get_content_blocks_by_type(FileContent)
+        }
+        rendered_prompt = self._training_error_handler_prompt_template.render(
+            logs=internal_request_message.get_flattened_log_content(),
+            modified_files=modified_files_dicts,
+            documentation_results=self._format_documents(relevant_documents),
+        )
+
+        return rendered_prompt
+
     @staticmethod
     def _create_documentation_search_query(context: CopilotContext) -> str:
-        """Format chat messages between user and copilot for documentation search."""
+        """Format chat messages between user and copilot for documentation search.
 
-        result = ""
+        Filters out guardrails policy violations and only includes messages with
+        USER or COPILOT roles, then takes the last N relevant messages.
+        """
         role_to_prefix = {
             ROLE_USER: "User",
             ROLE_COPILOT: "Assistant",
-            ROLE_COPILOT_INTERNAL: "Copilot Internal Request",
+            ROLE_COPILOT_INTERNAL: "User",
         }
+        allowed_message_types = (
+            UserChatMessage,
+            InternalCopilotRequestChatMessage,
+            CopilotChatMessage,
+        )
+
+        query_chat_history: List[str] = []
 
-        # Only use the last N messages for documentation search
-        messages_to_include = context.copilot_chat_history[
-            -COPILOT_DOCUMENTATION_SEARCH_QUERY_HISTORY_MESSAGES:
-        ]
+        for message in reversed(context.copilot_chat_history):
+            if (
+                message.response_category
+                == ResponseCategory.GUARDRAILS_POLICY_VIOLATION
+                or not isinstance(message, allowed_message_types)
+            ):
+                continue
+
+            if (
+                len(query_chat_history)
+                >= COPILOT_DOCUMENTATION_SEARCH_QUERY_HISTORY_MESSAGES
+            ):
+                break
 
-        for message in messages_to_include:
             prefix = role_to_prefix[message.role]
-            text = message.get_text_content().strip()
-            if text:
-                result += f"{prefix}: {text}\n"
-            log_content = message.get_log_content().strip()
-            if log_content:
-                result += f"{prefix}: {log_content}\n"
+            text = (
+                Copilot._format_internal_message_for_query_chat_history(message)
+                if isinstance(message, InternalCopilotRequestChatMessage)
+                else Copilot._format_normal_message_for_query_chat_history(message)
+            )
+            query_chat_history.insert(0, f"{prefix}: {text}")
 
-        return result
+        return "\n".join(query_chat_history)
 
     @staticmethod
     def _format_documents(results: List[Document]) -> Optional[str]:
         """Format documentation search results as JSON dump to be used in the prompt."""
+        # We want the special message that indicates no relevant documentation source
+        # found if there are no results.
         if not results:
             return None
 
-        formatted_results = {
+        formatted_results: Dict[str, Any] = {
             "sources": [
                 {
                     # Start the reference from 1, not 0.
@@ -448,3 +516,47 @@ class Copilot:
             return json.dumps({}, ensure_ascii=False, indent=2)
         current_state = tracker_context.current_state.model_dump()
         return json.dumps(current_state, ensure_ascii=False, indent=2)
+
+    @staticmethod
+    def _format_normal_message_for_query_chat_history(
+        message: Union[UserChatMessage, CopilotChatMessage],
+    ) -> str:
+        """Format normal message for query chat history."""
+        return f"{message.get_flattened_text_content()}"
+
+    @staticmethod
+    def _format_internal_message_for_query_chat_history(
+        message: InternalCopilotRequestChatMessage,
+    ) -> str:
+        """Format internal copilot request message for query chat history."""
+        text_content = message.get_flattened_text_content()
+        log_content = message.get_flattened_log_content()
+        if text_content and log_content:
+            return f"{text_content}\nLogs: {log_content}"
+        elif text_content:
+            return text_content
+        elif log_content:
+            return f"Logs: {log_content}"
+        else:
+            return ""
+
+    @staticmethod
+    def _format_tracker_event_attachments(events: List[EventContent]) -> Optional[str]:
+        """Format tracker events as JSON dump to be used in the prompt."""
+        # We don't want to display the attachment sectin in the last user message
+        # context prompt if there are no attachments.
+        if not events:
+            return None
+        # If there are attachments, return the formatted JSON dump.
+        return json.dumps(
+            [event_content.model_dump() for event_content in events],
+            ensure_ascii=False,
+            indent=2,
+        )
+
+    @staticmethod
+    def _extract_tracker_event_attachments(message: ChatMessage) -> List[EventContent]:
+        """Extract the tracker event attachments from the message."""
+        if not isinstance(message, UserChatMessage):
+            return []
+        return message.get_content_blocks_by_type(EventContent)