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

rasa/tracing/instrumentation/intentless_policy_instrumentation.py

@@ -37,7 +37,7 @@ def _instrument_select_response_examples(
 
         return wrapper
 
-    policy_class.select_response_examples = tracing_select_response_examples_wrapper(  # type: ignore[assignment]
+    policy_class.select_response_examples = tracing_select_response_examples_wrapper(  # type: ignore[method-assign]
         policy_class.select_response_examples
     )
 
@@ -72,7 +72,7 @@ def _instrument_select_few_shot_conversations(
 
         return wrapper
 
-    policy_class.select_few_shot_conversations = (  # type: ignore[assignment]
+    policy_class.select_few_shot_conversations = (  # type: ignore[method-assign]
         tracing_select_few_shot_conversations_wrapper(
             policy_class.select_few_shot_conversations
         )
@@ -104,7 +104,7 @@ def _instrument_extract_ai_responses(
 
         return wrapper
 
-    policy_class.extract_ai_responses = tracing_extract_ai_responses_wrapper(  # type: ignore[assignment]
+    policy_class.extract_ai_responses = tracing_extract_ai_responses_wrapper(  # type: ignore[method-assign]
         policy_class.extract_ai_responses
     )
 
@@ -137,7 +137,7 @@ def _instrument_generate_answer(
 
         return wrapper
 
-    policy_class.generate_answer = tracing_generate_answer_wrapper(  # type: ignore[assignment]
+    policy_class.generate_answer = tracing_generate_answer_wrapper(  # type: ignore[method-assign]
         policy_class.generate_answer
     )
 

rasa/tracing/instrumentation/metrics.py

@@ -2,6 +2,7 @@ from typing import Any, Dict
 
 import psutil
 
+from rasa.agents.protocol.mcp.mcp_base_agent import MCPBaseAgent
 from rasa.core.nlg.contextual_response_rephraser import ContextualResponseRephraser
 from rasa.core.policies.enterprise_search_policy import EnterpriseSearchPolicy
 from rasa.core.policies.intentless_policy import IntentlessPolicy
@@ -27,6 +28,10 @@ from rasa.tracing.constants import (
     LLM_COMMAND_GENERATOR_LLM_RESPONSE_DURATION_METRIC_NAME,
     LLM_COMMAND_GENERATOR_MEMORY_USAGE_METRIC_NAME,
     LLM_COMMAND_GENERATOR_PROMPT_TOKEN_USAGE_METRIC_NAME,
+    MCP_AGENT_LLM_CPU_USAGE_METRIC_NAME,
+    MCP_AGENT_LLM_MEMORY_USAGE_METRIC_NAME,
+    MCP_AGENT_LLM_PROMPT_TOKEN_USAGE_METRIC_NAME,
+    MCP_AGENT_LLM_RESPONSE_DURATION_METRIC_NAME,
     MULTI_STEP_LLM_COMMAND_GENERATOR_CPU_USAGE_METRIC_NAME,
     MULTI_STEP_LLM_COMMAND_GENERATOR_LLM_RESPONSE_DURATION_METRIC_NAME,
     MULTI_STEP_LLM_COMMAND_GENERATOR_MEMORY_USAGE_METRIC_NAME,
@@ -385,6 +390,11 @@ def record_callable_duration_metrics(
         )
         attributes = {"url": kwargs.get("url")}
 
+    if isinstance(self, MCPBaseAgent):
+        metric_instrument = instrument_provider.get_instrument(
+            MCP_AGENT_LLM_RESPONSE_DURATION_METRIC_NAME
+        )
+
     if not metric_instrument:
         return None
 
@@ -416,3 +426,25 @@ def record_request_size_in_bytes(attributes: Dict[str, Any]) -> None:
 
     request_body_size = attributes.pop(REQUEST_BODY_SIZE_IN_BYTES_ATTRIBUTE_NAME, 0)
     metric_instrument.record(amount=request_body_size, attributes=attributes)
+
+
+def record_mcp_agent_llm_metrics(attributes: Dict[str, Any]) -> None:
+    """Record MCP agent LLM metrics."""
+    instrument_provider = MetricInstrumentProvider()
+
+    if not instrument_provider.instruments:
+        return None
+
+    # Use MCP agent specific metric names
+    record_llm_based_component_cpu_usage(
+        instrument_provider, MCP_AGENT_LLM_CPU_USAGE_METRIC_NAME
+    )
+    record_llm_based_component_memory_usage(
+        instrument_provider, MCP_AGENT_LLM_MEMORY_USAGE_METRIC_NAME
+    )
+    record_llm_based_component_prompt_token(
+        instrument_provider,
+        attributes,
+        MCP_AGENT_LLM_PROMPT_TOKEN_USAGE_METRIC_NAME,
+    )
+    return None

rasa/tracing/metric_instrument_provider.py

@@ -4,6 +4,7 @@ from opentelemetry.metrics import get_meter_provider
 from opentelemetry.sdk.metrics import Meter
 
 from rasa.tracing.constants import (
+    AGENT_EXECUTION_DURATION_METRIC_NAME,
     COMPACT_LLM_COMMAND_GENERATOR_CPU_USAGE_METRIC_NAME,
     COMPACT_LLM_COMMAND_GENERATOR_LLM_RESPONSE_DURATION_METRIC_NAME,
     COMPACT_LLM_COMMAND_GENERATOR_MEMORY_USAGE_METRIC_NAME,
@@ -20,6 +21,11 @@ from rasa.tracing.constants import (
     LLM_COMMAND_GENERATOR_LLM_RESPONSE_DURATION_METRIC_NAME,
     LLM_COMMAND_GENERATOR_MEMORY_USAGE_METRIC_NAME,
     LLM_COMMAND_GENERATOR_PROMPT_TOKEN_USAGE_METRIC_NAME,
+    MCP_AGENT_LLM_CPU_USAGE_METRIC_NAME,
+    MCP_AGENT_LLM_MEMORY_USAGE_METRIC_NAME,
+    MCP_AGENT_LLM_PROMPT_TOKEN_USAGE_METRIC_NAME,
+    MCP_AGENT_LLM_RESPONSE_DURATION_METRIC_NAME,
+    MCP_TOOL_EXECUTION_DURATION_METRIC_NAME,
     MULTI_STEP_LLM_COMMAND_GENERATOR_CPU_USAGE_METRIC_NAME,
     MULTI_STEP_LLM_COMMAND_GENERATOR_LLM_RESPONSE_DURATION_METRIC_NAME,
     MULTI_STEP_LLM_COMMAND_GENERATOR_MEMORY_USAGE_METRIC_NAME,
@@ -59,6 +65,8 @@ class MetricInstrumentProvider(metaclass=Singleton):
             **self._create_multi_step_llm_command_generator_instruments(meter),
             **self._create_enterprise_search_policy_instruments(meter),
             **self._create_llm_response_duration_instruments(meter),
+            **self._create_mcp_and_a2a_agent_instruments(meter),
+            **self._create_mcp_agent_llm_instruments(meter),
             **self._create_client_request_instruments(meter),
         }
 
@@ -295,6 +303,28 @@ class MetricInstrumentProvider(metaclass=Singleton):
             CONTEXTUAL_RESPONSE_REPHRASER_LLM_RESPONSE_DURATION_METRIC_NAME: llm_response_duration_contextual_nlg,  # noqa: E501
         }
 
+    @staticmethod
+    def _create_mcp_and_a2a_agent_instruments(
+        meter: Meter,
+    ) -> Dict[str, Any]:
+        """Create instruments for MCP tool execution and agent execution."""
+        mcp_tool_execution_duration = meter.create_histogram(
+            name=MCP_TOOL_EXECUTION_DURATION_METRIC_NAME,
+            description="The duration of MCP tool execution",
+            unit=DURATION_UNIT_NAME,
+        )
+
+        agent_execution_duration = meter.create_histogram(
+            name=AGENT_EXECUTION_DURATION_METRIC_NAME,
+            description="The duration of agent execution",
+            unit=DURATION_UNIT_NAME,
+        )
+
+        return {
+            MCP_TOOL_EXECUTION_DURATION_METRIC_NAME: mcp_tool_execution_duration,
+            AGENT_EXECUTION_DURATION_METRIC_NAME: agent_execution_duration,
+        }
+
     @staticmethod
     def _create_client_request_instruments(
         meter: Meter,
@@ -315,3 +345,41 @@ class MetricInstrumentProvider(metaclass=Singleton):
             RASA_CLIENT_REQUEST_DURATION_METRIC_NAME: client_request_duration,
             RASA_CLIENT_REQUEST_BODY_SIZE_METRIC_NAME: client_request_body_size,
         }
+
+    @staticmethod
+    def _create_mcp_agent_llm_instruments(meter: Meter) -> Dict[str, Any]:
+        """Create instruments for MCP agent LLM calls."""
+        mcp_agent_llm_cpu_usage = meter.create_histogram(
+            name=MCP_AGENT_LLM_CPU_USAGE_METRIC_NAME,
+            description="CPU usage during MCP agent LLM calls",
+            unit=LLM_BASED_COMMAND_GENERATOR_CPU_MEMORY_USAGE_UNIT_NAME,
+        )
+
+        mcp_agent_llm_memory_usage = meter.create_histogram(
+            name=MCP_AGENT_LLM_MEMORY_USAGE_METRIC_NAME,
+            description="Memory usage during MCP agent LLM calls",
+            unit=LLM_BASED_COMMAND_GENERATOR_CPU_MEMORY_USAGE_UNIT_NAME,
+        )
+
+        mcp_agent_llm_prompt_token_usage = meter.create_histogram(
+            name=MCP_AGENT_LLM_PROMPT_TOKEN_USAGE_METRIC_NAME,
+            description="Prompt token usage for MCP agent LLM calls",
+            unit="token",
+        )
+
+        mcp_agent_llm_response_duration = meter.create_histogram(
+            name=MCP_AGENT_LLM_RESPONSE_DURATION_METRIC_NAME,
+            description="Duration of MCP agent LLM calls",
+            unit=DURATION_UNIT_NAME,
+        )
+
+        return {
+            MCP_AGENT_LLM_CPU_USAGE_METRIC_NAME: mcp_agent_llm_cpu_usage,
+            MCP_AGENT_LLM_MEMORY_USAGE_METRIC_NAME: mcp_agent_llm_memory_usage,
+            MCP_AGENT_LLM_PROMPT_TOKEN_USAGE_METRIC_NAME: (
+                mcp_agent_llm_prompt_token_usage
+            ),
+            MCP_AGENT_LLM_RESPONSE_DURATION_METRIC_NAME: (
+                mcp_agent_llm_response_duration
+            ),
+        }

rasa/utils/common.py

@@ -1,5 +1,6 @@
 import copy
 import inspect
+import json
 import logging
 import logging.config
 import logging.handlers
@@ -34,7 +35,9 @@ from rasa.constants import (
     ENV_LOG_LEVEL_KAFKA,
     ENV_LOG_LEVEL_LIBRARIES,
     ENV_LOG_LEVEL_MATPLOTLIB,
+    ENV_LOG_LEVEL_MCP,
     ENV_LOG_LEVEL_RABBITMQ,
+    ENV_MCP_LOGGING_ENABLED,
 )
 from rasa.shared.constants import DEFAULT_LOG_LEVEL, ENV_LOG_LEVEL, TCP_PROTOCOL
 from rasa.shared.exceptions import RasaException
@@ -49,7 +52,7 @@ EXPECTED_WARNINGS: List[Tuple[Type[Warning], str]] = [
     # TODO (issue #9932)
     #  DM1 warnings
     (
-        np.VisibleDeprecationWarning,
+        np.exceptions.VisibleDeprecationWarning,
         "Creating an ndarray from ragged nested sequences.*",
     ),
     # raised by magic_filter, google rpc
@@ -129,6 +132,18 @@ EXPECTED_WARNINGS: List[Tuple[Type[Warning], str]] = [
         FutureWarning,
         "'request_timeout' is deprecated and will be removed in 4.0.0. Use 'timeout'*",
     ),
+    (
+        FutureWarning,
+        "TEDPolicy is deprecated and will be removed in a future version.*",
+    ),
+    (
+        FutureWarning,
+        "DIETClassifier is deprecated and will be removed in a future version.*",
+    ),
+    (
+        FutureWarning,
+        "ResponseSelector is deprecated and will be removed in a future version.*",
+    ),
 ]
 
 PYTHON_LOGGING_SCHEMA_DOCS = (
@@ -281,6 +296,7 @@ def configure_library_logging() -> None:
     update_kafka_log_level(library_log_level)
     update_rabbitmq_log_level(library_log_level)
     update_websockets_log_level(library_log_level)
+    update_mcp_log_level()
 
 
 def update_apscheduler_log_level() -> None:
@@ -415,6 +431,56 @@ def update_websockets_log_level(library_log_level: Text) -> None:
     logging.getLogger("websockets").propagate = False
 
 
+def update_mcp_log_level() -> None:
+    """Set the log level for MCP-related loggers.
+
+    This function configures logging levels for MCP (Model Context Protocol) related
+    loggers to reduce noise from HTTP and MCP client libraries.
+
+    Environment Variables:
+        LOG_LEVEL_MCP: Set the log level for MCP-related loggers.
+                       Valid values: DEBUG, INFO, WARNING, ERROR, CRITICAL
+                       Default: ERROR
+
+        MCP_LOGGING_ENABLED: Enable or disable MCP logging completely.
+                             Valid values: true, false
+                             Default: true
+
+    Examples:
+        # Show only ERROR and above for MCP logs
+        export LOG_LEVEL_MCP=ERROR
+
+        # Show DEBUG level MCP logs (very verbose)
+        export LOG_LEVEL_MCP=DEBUG
+
+        # Completely disable MCP logging
+        export MCP_LOGGING_ENABLED=false
+    """
+    # Check if MCP logging is completely disabled
+    mcp_logging_enabled = (
+        os.environ.get(ENV_MCP_LOGGING_ENABLED, "true").lower() == "true"
+    )
+
+    # Default to ERROR level for MCP logs to reduce noise
+    mcp_log_level: Union[int, str] = os.environ.get(ENV_LOG_LEVEL_MCP, "ERROR")
+    if not mcp_logging_enabled:
+        # Completely disable MCP logging
+        mcp_log_level = logging.CRITICAL + 1  # Higher than CRITICAL to disable all logs
+
+    # MCP client and HTTP-related loggers that are commonly noisy
+    mcp_loggers = [
+        "mcp.client.streamable_http",
+        "mcp.client",
+        "httpcore.connection",
+        "httpcore.http11",
+        "httpx",
+    ]
+
+    for logger_name in mcp_loggers:
+        logging.getLogger(logger_name).setLevel(mcp_log_level)
+        logging.getLogger(logger_name).propagate = False
+
+
 def sort_list_of_dicts_by_first_key(dicts: List[Dict]) -> List[Dict]:
     """Sorts a list of dictionaries by their first key."""
     return sorted(dicts, key=lambda d: next(iter(d.keys())))
@@ -646,3 +712,28 @@ def get_bool_env_variable(variable_name: str, default_variable_value: bool) -> b
             f"Available values are `{true_values + false_values}`"
         )
     return value.lower() in true_values
+
+
+def try_parse_json(value: Any) -> Any:
+    """If value is a JSON string, parse it into a dict/list, else return as-is."""
+    if isinstance(value, str):
+        try:
+            return json.loads(value)
+        except json.JSONDecodeError:
+            return value
+    return value
+
+
+def ensure_jsonified_iterable(value: Any) -> Any:
+    """Convert iterables to JSON strings, flatten nested JSON strings in dicts/lists."""
+    if isinstance(value, dict):
+        # Recursively process dict values
+        return {
+            key: ensure_jsonified_iterable(try_parse_json(val))
+            for key, val in value.items()
+        }
+    elif isinstance(value, list):
+        # Recursively process each item
+        return [ensure_jsonified_iterable(try_parse_json(val)) for val in value]
+    # Keep primitives as-is
+    return value

rasa/utils/endpoints.py

@@ -1,5 +1,6 @@
 import os
 import ssl
+from pathlib import Path
 from types import ModuleType
 from typing import Any, Dict, List, Optional, Text, Union
 
@@ -16,7 +17,7 @@ structlogger = structlog.get_logger()
 
 
 def read_endpoint_config(
-    filename: Text, endpoint_type: Text
+    filename: Union[str, Path], endpoint_type: Text
 ) -> Optional["EndpointConfig"]:
     """Read an endpoint configuration file from disk and extract one config."""
     if not filename:
@@ -25,6 +26,14 @@ def read_endpoint_config(
     try:
         content = read_config_file(filename)
 
+        structlogger.debug(
+            "endpoint.read.success",
+            filename=os.path.abspath(filename),
+            endpoint_type=endpoint_type,
+            event_info="Successfully read endpoint configuration file.",
+            content=content,
+        )
+
         if content.get(endpoint_type) is None:
             return None
 
@@ -42,7 +51,7 @@ def read_endpoint_config(
 
 
 def read_property_config_from_endpoints_file(
-    filename: str, property_name: str
+    filename: Union[str, Path], property_name: str
 ) -> Optional[Union[Dict[str, Any], List]]:
     """Read a property from an endpoint configuration file."""
     if not filename:

rasa/utils/log_utils.py

@@ -19,19 +19,110 @@ from rasa.shared.constants import (
 )
 
 FORCE_JSON_LOGGING = os.environ.get("FORCE_JSON_LOGGING")
+ANSI_CYAN_BOLD = "\033[1;36m"
+ANSI_RESET = "\033[0m"
 
 
 class HumanConsoleRenderer(ConsoleRenderer):
     """Console renderer that outputs human-readable logs."""
 
     def __call__(self, logger: WrappedLogger, name: str, event_dict: EventDict) -> str:
+        should_highlight = event_dict.get("highlight", False)
+        terminal_width = self._get_terminal_width()
+
+        # Use event_info as title for the log entry
         if "event_info" in event_dict:
             event_key = event_dict["event"]
             event_dict["event"] = event_dict["event_info"]
             event_dict["event_key"] = event_key
-            del event_dict["event_info"]
-
-        return super().__call__(logger, name, event_dict)
+            event_dict.pop("event_info", None)
+
+        # In case the log entry should be highlighted
+        # make sure to surround the log entry with ===
+        event_dict = self._highlight_log_entry(
+            event_dict, terminal_width, should_highlight
+        )
+
+        # Format JSON data for better readability
+        event_dict = self._format_json_data(event_dict)
+
+        # Render the log entry first
+        result = super().__call__(logger, name, event_dict)
+
+        # ensure that newlines are properly rendered
+        result = "\n".join(result.split("\\n"))
+
+        # Add closing === if we highlighted this entry
+        if should_highlight:
+            result += f"\n{'=' * terminal_width}"
+
+        return result
+
+    def _highlight_log_entry(
+        self, event_dict: EventDict, terminal_width: int, should_highlight: bool
+    ) -> EventDict:
+        if should_highlight:
+            # Only highlight if log level is DEBUG
+            # structlog passes log level as 'level' or 'levelname'
+            level = event_dict.get("level", event_dict.get("levelname", "")).upper()
+            if level == "DEBUG":
+                # Add opening === before the event info
+                if "event" in event_dict and isinstance(event_dict["event"], str):
+                    event_info = event_dict["event"]
+                    event_dict["event"] = (
+                        f"\n{'=' * terminal_width}\n"
+                        f"{ANSI_CYAN_BOLD}{event_info}{ANSI_RESET}\n"
+                    )
+
+            event_dict.pop("highlight", None)
+
+        return event_dict
+
+    def _format_json_data(self, event_dict: EventDict) -> EventDict:
+        """Format JSON data in the event dict for better readability."""
+        # Get the list of fields to format from the event dict
+        fields_to_format = event_dict.get("json_formatting", [])
+
+        if not fields_to_format:
+            return event_dict
+
+        import json
+
+        # Format only the specified fields
+        for key in fields_to_format:
+            if key in event_dict:
+                value = event_dict[key]
+
+                try:
+                    # Try to parse as JSON if it's a string
+                    if isinstance(value, str):
+                        parsed = json.loads(value)
+                        # If it's a dict or list, format it nicely
+                        if isinstance(parsed, (dict, list)):
+                            formatted = json.dumps(parsed, indent=2, ensure_ascii=False)
+                            event_dict[key] = formatted
+                    elif isinstance(value, (dict, list)):
+                        # Format JSON with indentation for better readability
+                        formatted = json.dumps(value, indent=2, ensure_ascii=False)
+                        event_dict[key] = formatted
+                except (TypeError, ValueError, json.JSONDecodeError):
+                    # If it's not JSON serializable or if it's not valid JSON,
+                    # leave it as is
+                    pass
+
+        # Remove the json_formatting key from the output
+        event_dict.pop("json_formatting", None)
+
+        return event_dict
+
+    def _get_terminal_width(self) -> int:
+        """Get the width of the terminal."""
+        import shutil
+
+        try:
+            return shutil.get_terminal_size((80, 20)).columns
+        except Exception:
+            return 80
 
 
 def configure_structlog(
@@ -52,7 +143,7 @@ def configure_structlog(
         level=log_level,
     )
 
-    shared_processors = [
+    shared_processors: List[structlog.typing.Processor] = [
         # Processors that have nothing to do with output,
         # e.g., add timestamps or log level names.
         # If log level is too low, abort pipeline and throw away log entry.
@@ -94,7 +185,7 @@ def configure_structlog(
         ]
 
     structlog.configure(
-        processors=processors,  # type: ignore
+        processors=processors,
         context_class=dict,
         # `logger_factory` is used to create wrapped loggers that are used for
         # OUTPUT. This one returns a `logging.Logger`. The final value (a JSON

rasa/utils/ml_utils.py

@@ -119,7 +119,7 @@ def response_for_template(
     rsps = responses.get(template_name, [])
     usuable_responses = [r for r in rsps if r.get(KEY_RESPONSES_TEXT)]
     if usuable_responses:
-        selected_response = np.random.choice(usuable_responses)  # type: ignore
+        selected_response = np.random.choice(usuable_responses)
         return selected_response.get(KEY_RESPONSES_TEXT)
     else:
         structlogger.warning(

rasa/utils/tensorflow/__init__.py

@@ -0,0 +1,7 @@
+import importlib.util
+import logging
+
+logger = logging.getLogger(__name__)
+
+# check if TensorFlow is available
+TENSORFLOW_AVAILABLE = importlib.util.find_spec("tensorflow") is not None