rasa-pro 3.14.0.dev10__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_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

@@ -72,6 +72,10 @@ class A2AAgent(AgentProtocol):
         "application/json",
     ]
 
+    # ============================================================================
+    # Initialization & Setup
+    # ============================================================================
+
     def __init__(
         self,
         name: str,
@@ -128,6 +132,10 @@ class A2AAgent(AgentProtocol):
     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
@@ -141,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:
@@ -174,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
@@ -272,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]:
@@ -340,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)
@@ -353,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
@@ -471,6 +490,10 @@ class A2AAgent(AgentProtocol):
                 metadata=metadata,
             )
 
+    # ============================================================================
+    # Message Preparation & Formatting
+    # ============================================================================
+
     @staticmethod
     def _prepare_message(agent_input: AgentInput) -> Message:
         parts: List[Part] = []
@@ -503,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,
@@ -589,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."""
@@ -677,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."""
@@ -760,6 +796,10 @@ 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

rasa/agents/protocol/mcp/mcp_base_agent.py

@@ -184,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

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(

rasa/agents/protocol/mcp/mcp_task_agent.py

@@ -84,7 +84,7 @@ class MCPTaskAgent(MCPBaseAgent):
         ]
 
         return [
-            AgentToolSchema.from_openai_json_format(
+            AgentToolSchema.from_litellm_json_format(
                 cls.get_slot_specific_set_slot_tool(slot)
             )
             for slot in slot_definitions
@@ -109,12 +109,6 @@ class MCPTaskAgent(MCPBaseAgent):
             slot_name for slot_name in extracted_slot_names if slot_name in slot_names
         ]
 
-        structlogger.debug(
-            "mcp_task_agent.get_agent_specific_built_in_tools.slot_names",
-            exit_conditions=exit_conditions,
-            slot_names=valid_slot_names,
-        )
-
         return valid_slot_names
 
     @classmethod
@@ -173,13 +167,6 @@ class MCPTaskAgent(MCPBaseAgent):
                 rendered_template = Template(condition).render(current_context)
                 predicate = Predicate(rendered_template)
                 condition_result = predicate.evaluate(current_context)
-                structlogger.debug(
-                    "mcp_task_agent.is_exit_conditions_met.predicate.result",
-                    predicate=predicate.description(),
-                    condition_result=condition_result,
-                    slots=slots,
-                    rendered_template=rendered_template,
-                )
 
                 # All conditions must be met (AND logic)
                 if not condition_result:
@@ -196,11 +183,20 @@ class MCPTaskAgent(MCPBaseAgent):
                 internal_error = str(e)
                 break
 
-        structlogger.debug(
-            "mcp_task_agent.is_exit_conditions_met.result",
-            all_conditions_met=all_conditions_met,
-            internal_error=internal_error,
-        )
+        if internal_error:
+            structlogger.debug(
+                "mcp_task_agent.is_exit_conditions_met.result",
+                event_info="Failed to evaluate exit conditions - error occurred",
+                exit_conditions=exit_conditions,
+                error=internal_error,
+            )
+        else:
+            structlogger.debug(
+                "mcp_task_agent.is_exit_conditions_met.result",
+                event_info=f"Exit conditions met: {all_conditions_met}",
+                evaulation_result=all_conditions_met,
+                exit_conditions=exit_conditions,
+            )
 
         return all_conditions_met, internal_error
 
@@ -275,15 +271,24 @@ class MCPTaskAgent(MCPBaseAgent):
 
         # Convert available tools to OpenAI JSON format
         tools_in_openai_format = [
-            tool.to_openai_json_format() for tool in _available_tools
+            tool.to_litellm_json_format() for tool in _available_tools
         ]
 
         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_task_agent.send_message.sending_message_to_llm",
                     messages=messages,
+                    json_formatting=["messages"],
                     event_info=f"Sending message to LLM (iteration {iteration + 1})",
                     agent_name=self._name,
                     agent_id=str(make_agent_identifier(self._name, self.protocol_type)),
@@ -311,8 +316,10 @@ class MCPTaskAgent(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
+                            )
                         ),
                     )
 
@@ -322,8 +329,10 @@ class MCPTaskAgent(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
+                            )
                         ),
                     )
 
@@ -334,14 +343,12 @@ class MCPTaskAgent(MCPBaseAgent):
                         self._get_assistant_message_with_tool_calls(llm_response)
                     )
                     for tool_call in llm_response.tool_calls:
-                        structlogger.info(
+                        structlogger.debug(
                             "mcp_task_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),
+                            json_formatting=["tool_args"],
                             agent_name=self._name,
                             agent_id=str(
                                 make_agent_identifier(self._name, self.protocol_type)
@@ -405,7 +412,11 @@ class MCPTaskAgent(MCPBaseAgent):
 
                             structlogger.debug(
                                 "mcp_task_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"],
                                 tool_name=tool_call.tool_name,
                                 agent_name=self._name,
                                 agent_id=str(

rasa/agents/schemas/agent_tool_result.py

@@ -50,8 +50,6 @@ class AgentToolResult(BaseModel):
             )
         # fallback to content if structured content is not available
         elif tool_result.content:
-            # TODO try to parse the content using the output schema defined
-            #   in the tool schema (if present)
             return cls(
                 tool_name=tool_name,
                 result=str([content.model_dump() for content in tool_result.content]),

rasa/agents/schemas/agent_tool_schema.py

@@ -7,6 +7,7 @@ from rasa.agents.constants import (
     TOOL_ADDITIONAL_PROPERTIES_KEY,
     TOOL_DESCRIPTION_KEY,
     TOOL_EXECUTOR_KEY,
+    TOOL_INPUT_SCHEMA_KEY,
     TOOL_NAME_KEY,
     TOOL_PARAMETERS_KEY,
     TOOL_PROPERTIES_KEY,
@@ -42,9 +43,60 @@ class AgentToolSchema(BaseModel):
         )
 
     @classmethod
-    def from_openai_json_format(cls, tool: Dict[str, Any]) -> "AgentToolSchema":
+    def from_litellm_json_format(cls, tool: Dict[str, Any]) -> "AgentToolSchema":
         """Convert OpenAI dict format to AgentToolSchema."""
+        references = (
+            "Refer: \n"
+            "- LiteLLM JSON Format - https://docs.litellm.ai/docs/completion/function_call#full-code---parallel-function-calling-with-gpt-35-turbo-1106\n"
+            "- OpenAI Tool JSON Format - https://platform.openai.com/docs/guides/tools?tool-type=function-calling\n"
+        )
+        expected_structure = (
+            "{\n"
+            "    'type': 'function',\n"
+            "    'function': {\n"
+            "        'name': 'string',\n"
+            "        'description': 'string',\n"
+            "        'parameters': {\n"
+            "            'type': 'object',\n"
+            "            'properties': {'string': 'string'},\n"
+            "            'required': ['string']\n"
+            "        }\n"
+            "    }\n"
+            "}"
+        )
+        if (
+            TOOL_NAME_KEY in tool
+            and TOOL_DESCRIPTION_KEY in tool
+            and TOOL_INPUT_SCHEMA_KEY in tool
+        ):
+            raise ValueError(
+                "Anthropic Tool format is not supported yet. Please use the LiteLLM "
+                "Tool format, which is based on OpenAI's format.\n"
+                "The expected structure is:\n"
+                f"{expected_structure}\n"
+                f"{references}"
+            )
+        if not (TOOL_TYPE_FUNCTION_KEY in tool and TOOL_TYPE_KEY in tool):
+            raise ValueError(
+                "Invalid tool format. Expected a dictionary with 'type' and "
+                "'function' keys. Expected LiteLLM Tool format that is based on OpenAI "
+                "format which has the following structure: \n"
+                f"{expected_structure}\n"
+                f"{references}"
+            )
+
         function_data = tool[TOOL_TYPE_FUNCTION_KEY]
+
+        if not (
+            TOOL_NAME_KEY in function_data and TOOL_DESCRIPTION_KEY in function_data
+        ):
+            raise ValueError(
+                "Invalid tool format. 'function' must contain 'name' and "
+                "'description' keys. Expected LiteLLM Tool format that is based on "
+                "OpenAI format which has the following structure: \n"
+                f"{expected_structure}\n"
+                f"{references}"
+            )
         parameters = function_data.get(TOOL_PARAMETERS_KEY, {})
 
         if parameters:
@@ -104,7 +156,7 @@ class AgentToolSchema(BaseModel):
                 if TOOL_REQUIRED_KEY not in prop_schema:
                     prop_schema[TOOL_REQUIRED_KEY] = []
 
-    def to_openai_json_format(self) -> Dict[str, Any]:
+    def to_litellm_json_format(self) -> Dict[str, Any]:
         """Convert AgentToolSchema to OpenAI format."""
         # Ensure the schema is valid before conversion
         return {
@@ -123,7 +175,7 @@ class CustomToolSchema(BaseModel):
     @classmethod
     def from_dict(cls, config: Dict[str, Any]) -> "CustomToolSchema":
         """Convert a custom tool config to CustomToolSchema."""
-        agent_tool_schema = AgentToolSchema.from_openai_json_format(config)
+        agent_tool_schema = AgentToolSchema.from_litellm_json_format(config)
         if TOOL_EXECUTOR_KEY not in config:
             raise ValueError("Custom tool executor is required.")
 

rasa/agents/templates/mcp_open_agent_prompt_template.jinja2

@@ -1,10 +1,5 @@
 You are a helpful assistant that should assist the user in the best possible way.
 
-### Context
-- Current date: {{ current_date }}   (YYYY-MM-DD)
-- Current time: {{ current_time }}   (HH:MM:SS, 24-hour format)
-- Current day: {{ current_day }}     (Day of week)
-
 ### Primary Task
 {{ description }}
 
@@ -16,5 +11,10 @@ You are a helpful assistant that should assist the user in the best possible way
 * Do NOT call the `task_completed` tool unless you're absolutely certain that your primary task (NOT the slot corrections, updates, etc), described above, is fully completed. Focus on the task given in the task description above.
 * Strictly avoid making up information or ability to take some action which is not available in `tool` provided.
 
+### Context
+- Current date: {{ current_date }}   (YYYY-MM-DD)
+- Current time: {{ current_time }}   (HH:MM:SS, 24-hour format)
+- Current day: {{ current_day }}     (Day of week)
+
 ### Conversation history
-{{ conversation_history }}
+{{ conversation_history }}