rasa-pro 3.13.11__py3-none-any.whl → 3.14.0__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/io.py

@@ -26,6 +26,7 @@ from typing_extensions import Protocol
 
 import rasa.shared.constants
 import rasa.shared.utils.io
+from rasa.shared.exceptions import RasaException
 
 if TYPE_CHECKING:
     from prompt_toolkit.validation import Validator
@@ -124,9 +125,7 @@ def create_path(file_path: Text) -> None:
 def file_type_validator(
     valid_file_types: List[Text], error_message: Text
 ) -> Type["Validator"]:
-    """Creates a `Validator` class which can be used with `questionary` to validate
-    file paths.
-    """
+    """Creates a file type validator class for the questionary package."""
 
     def is_valid(path: Text) -> bool:
         return path is not None and any(
@@ -137,9 +136,7 @@ def file_type_validator(
 
 
 def not_empty_validator(error_message: Text) -> Type["Validator"]:
-    """Creates a `Validator` class which can be used with `questionary` to validate
-    that the user entered something other than whitespace.
-    """
+    """Creates a not empty validator class for the questionary package."""
 
     def is_valid(input: Text) -> bool:
         return input is not None and input.strip() != ""
@@ -150,9 +147,7 @@ def not_empty_validator(error_message: Text) -> Type["Validator"]:
 def create_validator(
     function: Callable[[Text], bool], error_message: Text
 ) -> Type["Validator"]:
-    """Helper method to create `Validator` classes from callable functions. Should be
-    removed when questionary supports `Validator` objects.
-    """
+    """Helper method to create a validator class from a callable function."""
     from prompt_toolkit.document import Document
     from prompt_toolkit.validation import ValidationError, Validator
 
@@ -250,3 +245,26 @@ def write_yaml(
 
     with Path(target).open("w", encoding="utf-8") as outfile:
         dumper.dump(data, outfile, transform=transform)
+
+
+class InvalidPathException(RasaException):
+    """Raised if a path is invalid - e.g. path traversal is detected."""
+
+
+def subpath(parent: str, child: str) -> str:
+    """Return the path to the child directory of the parent directory.
+
+    Ensures, that child doesn't navigate to parent directories. Prevents
+    path traversal. Raises an InvalidPathException if the path is invalid.
+
+    Based on Snyk's directory traversal mitigation:
+    https://learn.snyk.io/lesson/directory-traversal/
+    """
+    safe_path = os.path.abspath(os.path.join(parent, child))
+    parent = os.path.abspath(parent)
+
+    common_base = os.path.commonpath([parent, safe_path])
+    if common_base != parent:
+        raise InvalidPathException(f"Invalid path: {safe_path}")
+
+    return safe_path

rasa/utils/json_utils.py

@@ -1,6 +1,6 @@
 import json
 from decimal import Decimal
-from typing import Any, Text
+from typing import Any, Dict, List, Text
 
 
 class DecimalEncoder(json.JSONEncoder):
@@ -58,3 +58,8 @@ def replace_decimals_with_floats(obj: Any) -> Any:
         Input `obj` with all `Decimal` types replaced by `float`s.
     """
     return json.loads(json.dumps(obj, cls=DecimalEncoder))
+
+
+def extract_values(data: Dict, keys: List[Text]) -> Dict:
+    """Extracts values for given keys from a dictionary."""
+    return {key: data.get(key) for key in keys if data.get(key)}

rasa/utils/licensing.py

@@ -20,7 +20,8 @@ from rasa.shared.utils.cli import print_error_and_exit
 if typing.TYPE_CHECKING:
     from rasa.core.tracker_stores.tracker_store import TrackerStore
 
-LICENSE_ENV_VAR = "RASA_PRO_LICENSE"
+LICENSE_ENV_VAR = "RASA_LICENSE"
+LICENSE_ENV_VAR_LEGACY = "RASA_PRO_LICENSE"
 ALGORITHM = "RS256"
 # deepcode ignore HardcodedKey: This is a public key - not a security issue.
 PUBLIC_KEY = """-----BEGIN PUBLIC KEY-----
@@ -265,12 +266,22 @@ class License:
 
 def retrieve_license_from_env() -> Text:
     """Return the license found in the env var."""
+    # Check environment variables first
+    license_value = os.environ.get(LICENSE_ENV_VAR) or os.environ.get(
+        LICENSE_ENV_VAR_LEGACY
+    )
+    if license_value:
+        return license_value
+
+    # Fall back to .env file
     stored_env_values = dotenv_values(".env")
-    license_from_env = os.environ.get(LICENSE_ENV_VAR)
-    license = license_from_env or stored_env_values.get(LICENSE_ENV_VAR)
-    if not license:
-        raise LicenseNotFoundException()
-    return license
+    license_value = stored_env_values.get(LICENSE_ENV_VAR) or stored_env_values.get(
+        LICENSE_ENV_VAR_LEGACY
+    )
+    if license_value:
+        return license_value
+
+    raise LicenseNotFoundException()
 
 
 def is_license_expiring_soon(license: License) -> bool:
@@ -297,15 +308,15 @@ def validate_license_from_env(product_area: Text = PRODUCT_AREA) -> None:
     except LicenseNotFoundException:
         structlogger.error("license.not_found.error")
         raise SystemExit(
-            f"A Rasa Pro license is required. "
-            f"Please set the environmental variable "
+            f"A Rasa license is required. "
+            f"Please set the environment variable "
             f"`{LICENSE_ENV_VAR}` to a valid license string. "
         )
     except LicenseValidationException as e:
         structlogger.error("license.validation.error", error=e)
         raise SystemExit(
-            f"Failed to validate Rasa Pro license "
-            f"which was read from environmental variable `{LICENSE_ENV_VAR}`. "
+            f"Failed to validate Rasa license "
+            f"which was read from environment variable `{LICENSE_ENV_VAR}`. "
             f"Please ensure `{LICENSE_ENV_VAR}` is set to a valid license string. "
         )