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

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
 
@@ -253,11 +249,15 @@ class MCPTaskAgent(MCPBaseAgent):
     def render_prompt_template(self, context: AgentInput) -> str:
         """Render the prompt template with the provided inputs."""
         slot_names = self._get_slot_names_from_exit_conditions(context)
+        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,
             slot_names=slot_names,
+            current_date=current_date,
+            current_time=current_time,
+            current_day=current_day,
         )
 
     async def send_message(self, agent_input: AgentInput) -> AgentOutput:
@@ -271,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)),
@@ -307,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
+                            )
                         ),
                     )
 
@@ -318,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
+                            )
                         ),
                     )
 
@@ -330,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)
@@ -401,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/__init__.py

@@ -1,10 +1,11 @@
-from rasa.agents.schemas.agent_input import AgentInput
+from rasa.agents.schemas.agent_input import AgentInput, AgentInputSlot
 from rasa.agents.schemas.agent_output import AgentOutput
 from rasa.agents.schemas.agent_tool_result import AgentToolResult
 from rasa.agents.schemas.agent_tool_schema import AgentToolSchema, CustomToolSchema
 
 __all__ = [
     "AgentInput",
+    "AgentInputSlot",
     "AgentOutput",
     "AgentToolSchema",
     "AgentToolResult",

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

@@ -11,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 }}

rasa/agents/templates/mcp_task_agent_prompt_template.jinja2

@@ -13,5 +13,10 @@ You are a helpful assistant that should assist the user in the best possible way
 * Always avoid making assumptions about what values to pass into tools. Ask for clarification if a user's request is ambiguous.
 * 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 }}

rasa/agents/utils.py

@@ -1,5 +1,7 @@
 from typing import Dict, List, Optional
 
+import structlog
+
 from rasa.agents.agent_manager import AgentManager
 from rasa.agents.exceptions import AgentNotFoundException
 from rasa.agents.validation import validate_agent_names_not_conflicting_with_flows
@@ -10,12 +12,13 @@ from rasa.core.available_agents import (
 )
 from rasa.core.available_endpoints import AvailableEndpoints
 from rasa.shared.agents.utils import get_protocol_type
-from rasa.shared.core.domain import Domain
-from rasa.shared.core.events import AgentCompleted
+from rasa.shared.core.events import AgentCompleted, AgentStarted
 from rasa.shared.core.flows import FlowsList
 from rasa.shared.core.flows.steps import CallFlowStep
 from rasa.shared.core.trackers import DialogueStateTracker
 
+structlogger = structlog.get_logger()
+
 
 def resolve_agent_config(
     agent_config: AgentConfig,
@@ -43,13 +46,15 @@ def resolve_agent_config(
 
 async def initialize_agents(
     flows: FlowsList,
-    domain: Domain,
     sub_agents: AvailableAgents,
 ) -> None:
     """Iterate over flows and create/connect the referenced agents."""
     agent_manager: AgentManager = AgentManager()
     endpoints = AvailableEndpoints.get_instance()
 
+    agent_used = False
+    mcp_tool_used = False
+
     # Validate agent names don't conflict with flow names
     flow_names = {flow.id for flow in flows.underlying_flows}
     validate_agent_names_not_conflicting_with_flows(sub_agents.agents, flow_names)
@@ -63,11 +68,14 @@ async def initialize_agents(
                 if step.is_calling_mcp_tool():
                     # The call step is calling an MCP tool, so we don't need to
                     # initialize any agent.
+                    mcp_tool_used = True
                     continue
 
                 if not step.is_calling_agent():
                     raise AgentNotFoundException(step.call)
 
+                agent_used = True
+
                 agent_name = step.call
                 agent_config = sub_agents.get_agent_config(agent_name)
                 resolved_agent_config = resolve_agent_config(agent_config, endpoints)
@@ -79,6 +87,35 @@ async def initialize_agents(
                     resolved_agent_config,
                 )
 
+    _log_beta_feature_warning(mcp_tool_used, agent_used)
+
+
+def _log_beta_feature_warning(mcp_tool_used: bool, agent_used: bool) -> None:
+    """Log a warning if an agent or MCP tool is used in the flow(s)."""
+    if mcp_tool_used:
+        structlogger.info(
+            "rasa.agents.utils.initialize_agents",
+            event_info="Beta Feature",
+            message=(
+                "An MCP tool is being called in at least one of the flows. "
+                "This feature is currently under beta development. "
+                "It might undergo upgrades / breaking changes in future "
+                "releases to graduate it to GA."
+            ),
+        )
+
+    if agent_used:
+        structlogger.info(
+            "rasa.agents.utils.initialize_agents",
+            event_info="Beta Feature",
+            message=(
+                "A sub-agent is being called from a flow. "
+                "This feature is currently under beta development. "
+                "It might undergo upgrades / breaking changes in future "
+                "releases to graduate it to GA."
+            ),
+        )
+
 
 def is_agent_valid(agent_id: str) -> bool:
     """Check if an agent ID references a valid agent.
@@ -107,6 +144,8 @@ def is_agent_completed(tracker: DialogueStateTracker, agent_id: str) -> bool:
     for event in reversed(tracker.events):
         if isinstance(event, AgentCompleted) and event.agent_id == agent_id:
             return True
+        elif isinstance(event, AgentStarted) and event.agent_id == agent_id:
+            return False
     return False
 
 

rasa/agents/validation.py

@@ -84,7 +84,7 @@ def _validate_mcp_config(agent_config: AgentConfig) -> None:
     if agent_config.connections is None or agent_config.connections.mcp_servers is None:
         raise ValidationError(
             code="agent.validation.mcp.missing_connections",
-            event_info=f"For protocol 'MCP', agent '{agent_name}' must have "
+            event_info=f"For protocol 'RASA', agent '{agent_name}' must have "
             "'connections.mcp_servers' configured.",
         )
 
@@ -92,7 +92,7 @@ def _validate_mcp_config(agent_config: AgentConfig) -> None:
     if not agent_config.connections.mcp_servers:
         raise ValidationError(
             code="agent.validation.mcp.empty_servers_list",
-            event_info=f"For protocol 'MCP', agent '{agent_name}' must have "
+            event_info=f"For protocol 'RASA', agent '{agent_name}' must have "
             "at least one MCP server configured in 'connections.mcp_servers'.",
         )
 
@@ -101,7 +101,7 @@ def _validate_mcp_config(agent_config: AgentConfig) -> None:
         if not server.name:
             raise ValidationError(
                 code="agent.validation.mcp.server_missing_name",
-                event_info=f"For protocol 'MCP', agent '{agent_name}' MCP server "
+                event_info=f"For protocol 'RASA', agent '{agent_name}' MCP server "
                 f"at index {i} must have a 'name' field.",
             )
 
@@ -400,7 +400,7 @@ def validate_agent_config(agent_config: AgentConfig) -> None:
     protocol = agent_config.agent.protocol
 
     # Run protocol-specific validation
-    if protocol == ProtocolConfig.MCP:
+    if protocol == ProtocolConfig.RASA:
         _validate_mcp_config(agent_config)
     elif protocol == ProtocolConfig.A2A:
         _validate_a2a_config(agent_config)

rasa/builder/copilot/telemetry.py

@@ -99,7 +99,7 @@ class CopilotTelemetry:
         total_tokens: Optional[int] = None,
         system_message: Optional[dict[str, Any]] = None,
         chat_history: Optional[list[dict[str, Any]]] = None,
-        last_user_message: Optional[dict[str, Any]] = None,
+        last_user_message: Optional[str] = None,
     ) -> None:
         """Track a copilot message in the conversation.
 
@@ -112,28 +112,44 @@ class CopilotTelemetry:
             input_tokens: Number of input tokens used (optional).
             output_tokens: Number of output tokens generated (optional).
             total_tokens: Total number of tokens used (input + output) (optional).
+            system_message: The system message used (optional).
+            chat_history: The chat history messages used (optional).
+            last_user_message: The last user message used (optional).
         """
         structlogger.debug("builder.telemetry.log_copilot_turn", text=text)
+
+        # FIXME: Temporarily remove the system_message from telemetry payload.
+        # Reason: It often exceeds Segment payload size limits, causing the request
+        # to be rejected and the event to be absent in Segment. Instead, temporarily
+        # log the system_message so it's visible in Grafana.
+        telemetry_data = {
+            "project_id": self._project_id,
+            "message_id": uuid.uuid4().hex,
+            "text": text,
+            "prompt_version": self._prompt_version,
+            "source_urls": list(source_urls),
+            "flags": list(flags),
+            "latency_ms": latency_ms,
+            "model": model,
+            "input_tokens": input_tokens,
+            "output_tokens": output_tokens,
+            "total_tokens": total_tokens,
+            "chat_history": chat_history,
+            "last_user_message": last_user_message,
+            "timestamp": dt.datetime.utcnow().isoformat(),
+        }
+
+        # Log all telemetry data plus system_message for debugging
+        log_data = telemetry_data.copy()
+        if system_message:
+            log_data["system_message"] = system_message
+
+        structlogger.info("builder.telemetry.copilot_turn", **log_data)
+
         _track(
             COPILOT_BOT_MESSAGE_EVENT,
             self._user_id,
-            {
-                "project_id": self._project_id,
-                "message_id": uuid.uuid4().hex,
-                "text": text,
-                "prompt_version": self._prompt_version,
-                "source_urls": list(source_urls),
-                "flags": list(flags),
-                "latency_ms": latency_ms,
-                "model": model,
-                "input_tokens": input_tokens,
-                "output_tokens": output_tokens,
-                "total_tokens": total_tokens,
-                "system_message": system_message,
-                "chat_history": chat_history,
-                "last_user_message": last_user_message,
-                "timestamp": dt.datetime.utcnow().isoformat(),
-            },
+            telemetry_data,
         )
 
     @staticmethod
@@ -177,7 +193,7 @@ class CopilotTelemetry:
         total_tokens: int,
         system_message: dict[str, Any],
         chat_history: list[dict[str, Any]],
-        last_user_message: dict[str, Any],
+        last_user_message: Optional[str],
     ) -> None:
         """Log a copilot message from the response handler.
 

rasa/builder/main.py

@@ -22,11 +22,9 @@ from rasa.builder.logging_utils import (
     log_request_start,
 )
 from rasa.builder.service import bp, setup_project_generator
-from rasa.builder.template_cache import (
-    background_download_template_caches,
-)
 from rasa.builder.training_service import try_load_existing_agent, update_agent
 from rasa.core.channels.studio_chat import StudioChatInput
+from rasa.model_manager.warm_rasa_process import warmup
 from rasa.server import configure_cors
 from rasa.utils.common import configure_logging_and_warnings
 from rasa.utils.log_utils import configure_structlog
@@ -150,16 +148,6 @@ def create_app(project_folder: str) -> Sanic:
         except Exception as e:
             structlogger.warning("Failed to load agent on server startup", error=str(e))
 
-    if config.HELLO_RASA_PROJECT_ID and app.ctx.project_generator.is_empty():
-        app.register_listener(background_download_template_caches, "after_server_start")
-    else:
-        structlogger.debug(
-            "builder.main.background_cache_download.disabled",
-            event_info=(
-                "No hello rasa project id set; skipping background cache download"
-            ),
-        )
-
     return app
 
 
@@ -200,9 +188,12 @@ def main(project_folder: Optional[str] = None) -> None:
         rasa.telemetry.initialize_telemetry()
         rasa.telemetry.initialize_error_reporting(private_mode=False)
 
-        # TODO: don't do this when running locally
         _apply_llm_overrides_from_builder_env()
 
+        if config.HELLO_RASA_PROJECT_ID:
+            # ensures long import times for modules are ahead of time
+            warmup()
+
         # working directory needs to be the project folder, e.g.
         # for relative paths (./docs) in a projects config to work
         if not project_folder:

rasa/builder/project_generator.py

@@ -62,7 +62,7 @@ class ProjectGenerator:
         create_initial_project(self.project_folder.as_posix(), template)
         # If a local cache for this template exists, copy it into the project.
         # We no longer download here to avoid blocking project creation.
-        copy_cache_for_template_if_available(template, self.project_folder)
+        await copy_cache_for_template_if_available(template, self.project_folder)
         # needs to happen after caching, as we download/copy .rasa and that would
         # overwrite the project info file in .rasa
         ensure_first_used(self.project_folder)

rasa/builder/service.py

@@ -1155,6 +1155,11 @@ async def copilot(request: Request) -> None:
                 latency_ms=int((time.perf_counter() - start_timestamp) * 1000),
                 system_message=generation_context.system_message,
                 chat_history=generation_context.chat_history,
+                last_user_message=(
+                    req.last_message.get_text_content()
+                    if (req.last_message and req.last_message.role == ROLE_USER)
+                    else None
+                ),
                 **copilot_client.usage_statistics.model_dump(),
             )
         )