rasa-pro 3.14.0rc2__py3-none-any.whl → 3.14.0rc4__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/protocol/mcp/mcp_base_agent.py

@@ -71,7 +71,7 @@ structlogger = structlog.get_logger()
 
 
 class MCPBaseAgent(AgentProtocol):
-    """MCP protocol implementation"""
+    """MCP protocol implementation."""
 
     MAX_ITERATIONS = 10
 
@@ -135,6 +135,20 @@ class MCPBaseAgent(AgentProtocol):
     @classmethod
     def from_config(cls, config: AgentConfig) -> "MCPBaseAgent":
         """Initialize the MCP Open Agent with the given configuration."""
+        # Warn if configuration.timeout is set for MCP agents
+        if config.configuration and config.configuration.timeout is not None:
+            structlogger.warning(
+                "mcp_agent.configuration.timeout.not_implemented",
+                event_info="configuration.timeout is not implemented for MCP agents. "
+                "MCP agents do not establish external connections, "
+                "so agent-level timeout is not used. "
+                "To set timeout for LLM requests, "
+                "configure 'timeout' in the model_group "
+                "in endpoints.yml and reference it via configuration.llm.model_group.",
+                agent_name=config.agent.name,
+                timeout_value=config.configuration.timeout,
+            )
+
         return cls(
             name=config.agent.name,
             description=config.agent.description,

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

@@ -5,8 +5,9 @@ import urllib.parse
 from collections import Counter
 from typing import Any, Dict, List, NoReturn, Set
 
+import jinja2.exceptions
+import structlog
 from pydantic import ValidationError as PydanticValidationError
-from ruamel import yaml
 
 from rasa.agents.exceptions import (
     AgentNameFlowConflictException,
@@ -18,11 +19,18 @@ 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.agents.auth.utils import validate_secrets_in_params
+from rasa.shared.utils.llm import get_prompt_template, validate_jinja2_template
+from rasa.shared.utils.yaml import read_config_file
+
+# Initialize logger
+structlogger = structlog.get_logger()
 
 # Centralized allowed keys configuration to eliminate duplication
 ALLOWED_KEYS = {
@@ -34,6 +42,7 @@ ALLOWED_KEYS = {
         "timeout",
         "max_retries",
         "agent_card",
+        "auth",
     },
     "connections": {"mcp_servers"},
 }
@@ -149,6 +158,41 @@ def _validate_a2a_config(agent_config: AgentConfig) -> None:
                 f"exist: {agent_card}",
             )
 
+    # Validate right use of secrets in auth configuration
+    if agent_config.configuration.auth:
+        validate_secrets_in_params(
+            agent_config.configuration.auth, f"agent '{agent_name}'"
+        )
+
+
+def _validate_prompt_template_syntax(prompt_path: str, agent_name: str) -> None:
+    """Validate Jinja2 syntax of a prompt template file."""
+    try:
+        # Use a simple default template, as we're assuming
+        # that the default templates are valid
+        default_template = "{{ content }}"
+        template_content = get_prompt_template(
+            prompt_path,
+            default_template,
+            log_source_component=f"agent.validation.{agent_name}",
+            log_source_method="init",
+        )
+        validate_jinja2_template(template_content)
+
+    except jinja2.exceptions.TemplateSyntaxError as e:
+        raise ValidationError(
+            code="agent.validation.prompt_template_syntax_error",
+            event_info=(
+                f"Agent '{agent_name}' has invalid Jinja2 template syntax at line "
+                f"{e.lineno}: {e.message}"
+            ),
+        ) from e
+    except Exception as e:
+        raise ValidationError(
+            code="agent.validation.optional.prompt_template_error",
+            event_info=(f"Agent '{agent_name}' has error reading prompt template: {e}"),
+        ) from e
+
 
 def _validate_optional_keys(agent_config: AgentConfig) -> None:
     """Validate optional keys in agent configuration."""
@@ -158,11 +202,22 @@ def _validate_optional_keys(agent_config: AgentConfig) -> None:
     if agent_config.configuration and agent_config.configuration.prompt_template:
         prompt_path = agent_config.configuration.prompt_template
         if not os.path.exists(prompt_path):
-            raise ValidationError(
-                code="agent.validation.optional.prompt_template_not_found",
-                event_info=f"Agent '{agent_name}' has prompt template that "
-                f"does not exist: {prompt_path}",
+            # If reading the custom prompt fails,
+            # allow fallback to default prompt template
+            structlogger.warning(
+                "agent.validation.optional.prompt_template_file_not_found",
+                agent_name=agent_name,
+                prompt_path=prompt_path,
+                event_info=(
+                    f"Prompt template file not found: {prompt_path}. "
+                    f"Agent will use default template."
+                ),
             )
+            # Don't raise ValidationError, allow fallback to default template
+            return
+
+        # Validate Jinja2 syntax
+        _validate_prompt_template_syntax(prompt_path, agent_name)
 
     # Validate module if present
     if agent_config.configuration and agent_config.configuration.module:
@@ -348,9 +403,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 +488,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 +496,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

@@ -14,6 +14,7 @@ COPILOT_TRAINING_ERROR_HANDLER_PROMPT_FILE = (
 COPILOT_MESSAGE_TEMPLATES_DIR = "builder.copilot.templated_messages"
 RASA_INTERNAL_MESSAGES_TEMPLATES_FILE = "copilot_internal_messages_templates.yml"
 COPILOT_HANDLER_RESPONSES_FILE = "copilot_templated_responses.yml"
+COPILOT_WELCOME_MESSAGES_FILE = "copilot_welcome_messages.yml"
 
 # OpenAI roles copilot utilizes - Use literal types to avoid type errors with OpenAI
 ROLE_USER: Literal["user"] = "user"
@@ -32,3 +33,6 @@ COPILOT_SEGMENT_WRITE_KEY_ENV_VAR = "COPILOT_SEGMENT_WRITE_KEY"
 
 # Copilot signing
 SIGNATURE_VERSION_V1 = "v1"
+
+# Welcome message key for prompt-to-bot (not a template enum)
+PROMPT_TO_BOT_KEY = "prompt_to_bot"

rasa/builder/copilot/copilot.py

@@ -22,10 +22,12 @@ from rasa.builder.copilot.constants import (
 )
 from rasa.builder.copilot.exceptions import CopilotStreamError
 from rasa.builder.copilot.models import (
+    ChatMessage,
     CopilotChatMessage,
     CopilotContext,
     CopilotGenerationContext,
     CopilotSystemMessage,
+    EventContent,
     FileContent,
     InternalCopilotRequestChatMessage,
     ResponseCategory,
@@ -144,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 (
@@ -272,8 +278,11 @@ class Copilot:
             ValueError: If the message type is not supported.
         """
         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
+                context, relevant_documents, tracker_event_attachments
             )
             return latest_message.build_openai_message(prompt=rendered_prompt)
 
@@ -299,6 +308,7 @@ class Copilot:
         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]
@@ -306,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,
@@ -313,6 +325,7 @@ class Copilot:
             assistant_logs=context.assistant_logs,
             assistant_files=context.assistant_files,
             documentation_results=documents,
+            attachments=attachments,
         )
         return rendered_prompt
 
@@ -390,6 +403,8 @@ class Copilot:
     @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
 
@@ -524,3 +539,24 @@ class Copilot:
             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)

rasa/builder/copilot/copilot_templated_message_provider.py

@@ -7,6 +7,7 @@ import yaml  # type: ignore
 from rasa.builder.copilot.constants import (
     COPILOT_HANDLER_RESPONSES_FILE,
     COPILOT_MESSAGE_TEMPLATES_DIR,
+    COPILOT_WELCOME_MESSAGES_FILE,
     RASA_INTERNAL_MESSAGES_TEMPLATES_FILE,
 )
 from rasa.shared.constants import PACKAGE_NAME
@@ -56,3 +57,25 @@ def load_copilot_handler_default_responses() -> Dict[str, str]:
             error=e,
         )
         return dict()
+
+
+def load_copilot_welcome_messages() -> Dict[str, str]:
+    """Load welcome message templates from the YAML configuration file.
+
+    Returns:
+        Dictionary mapping template names to welcome message text.
+    """
+    try:
+        config = yaml.safe_load(
+            importlib.resources.read_text(
+                f"{PACKAGE_NAME}.{COPILOT_MESSAGE_TEMPLATES_DIR}",
+                COPILOT_WELCOME_MESSAGES_FILE,
+            )
+        )
+        return config.get("welcome_messages", {})
+    except Exception as e:
+        structlogger.error(
+            "copilot_templated_message_provider.failed_to_load_welcome_messages",
+            error=e,
+        )
+        return dict()

rasa/builder/copilot/models.py

@@ -110,7 +110,7 @@ class LogContent(BaseContent):
     )
 
 
-class EventContent(BaseModel):
+class EventContent(BaseContent):
     type: Literal["event"]
     event: str = Field(..., description="The event's type_name")
 
@@ -171,6 +171,38 @@ class BaseCopilotChatMessage(BaseModel, ABC):
         return None if v is None else v.value
 
 
+class BaseContentBlockCopilotChatMessage(BaseCopilotChatMessage, ABC):
+    """Base class for messages that contain ContentBlock lists."""
+
+    content: List[ContentBlock]
+
+    def get_flattened_text_content(self) -> str:
+        """Get the text content from the message."""
+        return "\n".join(
+            content_block.text
+            for content_block in self.content
+            if isinstance(content_block, TextContent)
+        )
+
+    def get_flattened_log_content(self) -> str:
+        """Get the log content from the message."""
+        return "\n".join(
+            content_block.content
+            for content_block in self.content
+            if isinstance(content_block, LogContent)
+        )
+
+    def get_content_blocks_by_type(
+        self, content_type: Type[TContentBlock]
+    ) -> List[TContentBlock]:
+        """Get the content blocks from the message by type."""
+        return [
+            content_block
+            for content_block in self.content
+            if isinstance(content_block, content_type)
+        ]
+
+
 class CopilotSystemMessage(BaseCopilotChatMessage):
     role: Literal["system"] = Field(
         default=ROLE_SYSTEM,
@@ -183,13 +215,12 @@ class CopilotSystemMessage(BaseCopilotChatMessage):
         return {"role": ROLE_SYSTEM, "content": prompt}
 
 
-class UserChatMessage(BaseCopilotChatMessage):
+class UserChatMessage(BaseContentBlockCopilotChatMessage):
     role: Literal["user"] = Field(
         default=ROLE_USER,
         pattern=f"^{ROLE_USER}",
         description="The user who sent the message.",
     )
-    content: List[ContentBlock]
 
     @classmethod
     @field_validator("content")
@@ -234,14 +265,6 @@ class UserChatMessage(BaseCopilotChatMessage):
 
         return self
 
-    def get_flattened_text_content(self) -> str:
-        """Get the text content from the message."""
-        return "\n".join(
-            content_block.text
-            for content_block in self.content
-            if isinstance(content_block, TextContent)
-        )
-
     def build_openai_message(  # type: ignore[no-untyped-def]
         self, prompt: Optional[str] = None, *args, **kwargs
     ) -> Dict[str, Any]:
@@ -260,17 +283,8 @@ class UserChatMessage(BaseCopilotChatMessage):
             return {"role": ROLE_USER, "content": self.get_flattened_text_content()}
 
 
-class CopilotChatMessage(BaseCopilotChatMessage):
+class CopilotChatMessage(BaseContentBlockCopilotChatMessage):
     role: Literal["copilot"]
-    content: List[ContentBlock]
-
-    def get_flattened_text_content(self) -> str:
-        """Get the text content from the message."""
-        return "\n".join(
-            content_block.text
-            for content_block in self.content
-            if isinstance(content_block, TextContent)
-        )
 
     def build_openai_message(self, *args, **kwargs) -> Dict[str, Any]:  # type: ignore[no-untyped-def]
         # For now the Copilot responds only with the text content and all the content
@@ -278,9 +292,8 @@ class CopilotChatMessage(BaseCopilotChatMessage):
         return {"role": ROLE_ASSISTANT, "content": self.get_flattened_text_content()}
 
 
-class InternalCopilotRequestChatMessage(BaseCopilotChatMessage):
+class InternalCopilotRequestChatMessage(BaseContentBlockCopilotChatMessage):
     role: Literal["internal_copilot_request"]
-    content: List[ContentBlock]
 
     @model_validator(mode="after")
     def validate_response_category(self) -> "InternalCopilotRequestChatMessage":
@@ -311,32 +324,6 @@ class InternalCopilotRequestChatMessage(BaseCopilotChatMessage):
 
         return self
 
-    def get_flattened_text_content(self) -> str:
-        """Get the text content from the message."""
-        return "\n".join(
-            content_block.text
-            for content_block in self.content
-            if isinstance(content_block, TextContent)
-        )
-
-    def get_flattened_log_content(self) -> str:
-        """Get the text content from the message."""
-        return "\n".join(
-            content_block.content
-            for content_block in self.content
-            if isinstance(content_block, LogContent)
-        )
-
-    def get_content_blocks_by_type(
-        self, content_type: Type[TContentBlock]
-    ) -> List[TContentBlock]:
-        """Get the content blocks from the message by type."""
-        return [
-            content_block
-            for content_block in self.content
-            if isinstance(content_block, content_type)
-        ]
-
     def build_openai_message(self, prompt: str, *args, **kwargs) -> Dict[str, Any]:  # type: ignore[no-untyped-def]
         """Build OpenAI message with pre-rendered prompt.
 
@@ -689,6 +676,13 @@ class CopilotGenerationContext(BaseModel):
     last_user_message: Optional[Dict[str, Any]] = Field(
         None, description="The last user message with context that was processed."
     )
+    tracker_event_attachments: List[EventContent] = Field(
+        ...,
+        description=(
+            "The tracker event attachments passed with the user message used as "
+            "an additional context."
+        ),
+    )
 
     class Config:
         """Config for CopilotGenerationContext."""