rasa-pro 3.14.0rc4__py3-none-any.whl → 3.15.0a1__py3-none-any.whl

rasa/core/run.py

@@ -328,10 +328,21 @@ def serve_application(
 
     logger.info(f"Starting Rasa server on {protocol}://{interface}:{port}")
 
-    app.register_listener(
-        partial(load_agent_on_start, model_path, endpoints, remote_storage, sub_agents),
-        "before_server_start",
-    )
+    async def load_agent_and_check_failure(app: Sanic, loop: AbstractEventLoop) -> None:
+        """Load agent and exit if it fails in non-debug mode."""
+        try:
+            await load_agent_on_start(
+                model_path, endpoints, remote_storage, sub_agents, app, loop
+            )
+        except Exception as e:
+            is_debug = logger.isEnabledFor(logging.DEBUG)
+            if is_debug:
+                raise e  # show traceback in debug
+            # non-debug: log and exit without starting server
+            logger.error(f"Failed to load agent: {e}")
+            os._exit(1)  # Any other exit method would show a traceback.
+
+    app.register_listener(load_agent_and_check_failure, "before_server_start")
 
     app.register_listener(
         licensing.validate_limited_server_license, "after_server_start"

rasa/dialogue_understanding/commands/cancel_flow_command.py

@@ -56,7 +56,7 @@ class CancelFlowCommand(Command):
         Returns:
         The frames that were canceled.
         """
-        canceled_frames = []
+        canceled_frames: List[str] = []
         # we need to go through the original stack dump in reverse order
         # to find the frames that were canceled. we cancel everything from
         # the top of the stack until we hit the user flow that was canceled.

rasa/dialogue_understanding/patterns/default_flows_for_patterns.yml

@@ -233,7 +233,7 @@ flows:
         collect: interrupted_flow_to_continue
         description: "Fill this slot with the name of the flow the user wants to continue. If the user does not want to continue any of the interrupted flows, fill this slot with 'none'."
         next:
-          - if: slots.interrupted_flow_to_continue != "none"
+          - if: slots.interrupted_flow_to_continue is not "none"
             then:
               - action: action_continue_interrupted_flow
                 next: END

rasa/e2e_test/e2e_config.py

@@ -72,9 +72,10 @@ class LLMJudgeConfig(BaseModel):
 
         llm_config = resolve_model_client_config(llm_config)
         llm_config, llm_extra_parameters = cls.extract_attributes(llm_config)
-        llm_config = combine_custom_and_default_config(
-            llm_config, cls.get_default_llm_config()
-        )
+        if not llm_config:
+            llm_config = combine_custom_and_default_config(
+                llm_config, cls.get_default_llm_config()
+            )
         embeddings_config = resolve_model_client_config(embeddings)
         embeddings_config, embeddings_extra_parameters = cls.extract_attributes(
             embeddings_config

rasa/engine/recipes/default_components.py

@@ -27,22 +27,32 @@ from rasa.shared.utils.common import conditional_import
 
 # components dependent on tensorflow
 TEDPolicy, TED_POLICY_AVAILABLE = conditional_import(
-    "rasa.core.policies.ted_policy", "TEDPolicy"
+    "rasa.core.policies.ted_policy", "TEDPolicy", check_installation_setup=True
 )
 UnexpecTEDIntentPolicy, UNEXPECTED_INTENT_POLICY_AVAILABLE = conditional_import(
-    "rasa.core.policies.unexpected_intent_policy", "UnexpecTEDIntentPolicy"
+    "rasa.core.policies.unexpected_intent_policy",
+    "UnexpecTEDIntentPolicy",
+    check_installation_setup=True,
 )
 DIETClassifier, DIET_CLASSIFIER_AVAILABLE = conditional_import(
-    "rasa.nlu.classifiers.diet_classifier", "DIETClassifier"
+    "rasa.nlu.classifiers.diet_classifier",
+    "DIETClassifier",
+    check_installation_setup=True,
 )
 ConveRTFeaturizer, CONVERT_FEATURIZER_AVAILABLE = conditional_import(
-    "rasa.nlu.featurizers.dense_featurizer.convert_featurizer", "ConveRTFeaturizer"
+    "rasa.nlu.featurizers.dense_featurizer.convert_featurizer",
+    "ConveRTFeaturizer",
+    check_installation_setup=True,
 )
 LanguageModelFeaturizer, LANGUAGE_MODEL_FEATURIZER_AVAILABLE = conditional_import(
-    "rasa.nlu.featurizers.dense_featurizer.lm_featurizer", "LanguageModelFeaturizer"
+    "rasa.nlu.featurizers.dense_featurizer.lm_featurizer",
+    "LanguageModelFeaturizer",
+    check_installation_setup=True,
 )
 ResponseSelector, RESPONSE_SELECTOR_AVAILABLE = conditional_import(
-    "rasa.nlu.selectors.response_selector", "ResponseSelector"
+    "rasa.nlu.selectors.response_selector",
+    "ResponseSelector",
+    check_installation_setup=True,
 )
 
 # components dependent on skops

rasa/graph_components/validators/default_recipe_validator.py

@@ -40,16 +40,22 @@ from rasa.shared.utils.common import conditional_import
 
 # Conditional imports for TensorFlow-dependent components
 TEDPolicy, TED_POLICY_AVAILABLE = conditional_import(
-    "rasa.core.policies.ted_policy", "TEDPolicy"
+    "rasa.core.policies.ted_policy", "TEDPolicy", check_installation_setup=True
 )
 UnexpecTEDIntentPolicy, UNEXPECTED_INTENT_POLICY_AVAILABLE = conditional_import(
-    "rasa.core.policies.unexpected_intent_policy", "UnexpecTEDIntentPolicy"
+    "rasa.core.policies.unexpected_intent_policy",
+    "UnexpecTEDIntentPolicy",
+    check_installation_setup=True,
 )
 DIETClassifier, DIET_CLASSIFIER_AVAILABLE = conditional_import(
-    "rasa.nlu.classifiers.diet_classifier", "DIETClassifier"
+    "rasa.nlu.classifiers.diet_classifier",
+    "DIETClassifier",
+    check_installation_setup=True,
 )
 ResponseSelector, RESPONSE_SELECTOR_AVAILABLE = conditional_import(
-    "rasa.nlu.selectors.response_selector", "ResponseSelector"
+    "rasa.nlu.selectors.response_selector",
+    "ResponseSelector",
+    check_installation_setup=True,
 )
 
 # Conditional imports for nlu components requiring other dependencies than tensorflow

rasa/model_manager/runner_service.py

@@ -195,7 +195,7 @@ def fetch_remote_model_to_dir(
     try:
         return persistor.retrieve(model_name=model_name, target_path=target_path)
     except FileNotFoundError as e:
-        raise ModelNotFound() from e
+        raise ModelNotFound("Model not found") from e
 
 
 def fetch_size_of_remote_model(

rasa/nlu/classifiers/diet_classifier.py

@@ -9,9 +9,11 @@ from typing import Any, Dict, List, Optional, Text, Tuple, Type, TypeVar, Union
 import numpy as np
 import scipy.sparse
 
+from rasa.utils.installation_utils import check_for_installation_issues
 from rasa.utils.tensorflow import TENSORFLOW_AVAILABLE
 
 if TENSORFLOW_AVAILABLE:
+    check_for_installation_issues()
     import tensorflow as tf
 else:
     tf = None

rasa/privacy/privacy_config.py

@@ -211,7 +211,7 @@ def get_cron_trigger(cron_expression: str) -> CronTrigger:
             "privacy_config.invalid_cron_expression",
             cron=cron_expression,
         )
-        raise RasaException from exc
+        raise RasaException("Invalid cron expression") from exc
 
     return cron
 

rasa/shared/agents/auth/auth_strategy/oauth2_auth_strategy.py

@@ -139,20 +139,17 @@ class OAuth2AuthStrategy(AgentAuthStrategy):
                 resp.raise_for_status()
                 token_data = resp.json()
         except httpx.HTTPStatusError as e:
-            raise ValueError(
-                f"OAuth2 token request failed with status {e.response.status_code}: "
-                f"{e.response.text}"
-            ) from e
+            raise e
         except httpx.RequestError as e:
-            raise ValueError(f"OAuth2 token request failed: {e}") from e
+            raise ValueError(f"OAuth2 token request failed - {e}") from e
         except Exception as e:
             raise ValueError(
-                f"Unexpected error during OAuth2 token request: {e}"
+                f"Unexpected error during OAuth2 token request - {e}"
             ) from e
 
         # Validate token data
         if KEY_ACCESS_TOKEN not in token_data:
-            raise ValueError(f"No {KEY_ACCESS_TOKEN} in OAuth2 response")
+            raise ValueError(f"No `{KEY_ACCESS_TOKEN}` in OAuth2 response")
 
         # Set access token and expires at
         self._access_token = token_data[KEY_ACCESS_TOKEN]

rasa/shared/core/slots.py

@@ -355,8 +355,8 @@ class FloatSlot(Slot):
         mappings: List[Dict[Text, Any]],
         initial_value: Optional[float] = None,
         value_reset_delay: Optional[int] = None,
-        max_value: float = 1.0,
-        min_value: float = 0.0,
+        max_value: Optional[float] = None,
+        min_value: Optional[float] = None,
         influence_conversation: bool = True,
         is_builtin: bool = False,
         shared_for_coexistence: bool = False,
@@ -380,32 +380,24 @@ class FloatSlot(Slot):
             filled_by=filled_by,
             validation=validation,
         )
+        self.validate_min_max_range(min_value, max_value)
+
         self.max_value = max_value
         self.min_value = min_value
 
-        if min_value >= max_value:
-            raise InvalidSlotConfigError(
-                "Float slot ('{}') created with an invalid range "
-                "using min ({}) and max ({}) values. Make sure "
-                "min is smaller than max."
-                "".format(self.name, self.min_value, self.max_value)
-            )
-
-        if initial_value is not None and not (min_value <= initial_value <= max_value):
-            rasa.shared.utils.io.raise_warning(
-                f"Float slot ('{self.name}') created with an initial value "
-                f"{self.value}. This value is outside of the configured min "
-                f"({self.min_value}) and max ({self.max_value}) values."
-            )
-
     def _as_feature(self) -> List[float]:
+        # set default min and max values used in prior releases
+        # to prevent regressions for existing models
+        min_value = self.min_value or 0.0
+        max_value = self.max_value or 1.0
+
         try:
-            capped_value = max(self.min_value, min(self.max_value, float(self.value)))
-            if abs(self.max_value - self.min_value) > 0:
-                covered_range = abs(self.max_value - self.min_value)
+            capped_value = max(min_value, min(max_value, float(self.value)))
+            if abs(max_value - min_value) > 0:
+                covered_range = abs(max_value - min_value)
             else:
                 covered_range = 1
-            return [1.0, (capped_value - self.min_value) / covered_range]
+            return [1.0, (capped_value - min_value) / covered_range]
         except (TypeError, ValueError):
             return [0.0, 0.0]
 
@@ -424,13 +416,52 @@ class FloatSlot(Slot):
             return value
 
     def is_valid_value(self, value: Any) -> bool:
-        """Checks if the slot contains the value."""
-        # check that coerced type is float
-        return value is None or isinstance(self.coerce_value(value), float)
+        """Checks if the slot value is valid."""
+        if value is None:
+            return True
+
+        if not isinstance(self.coerce_value(value), float):
+            return False
+
+        if (
+            self.min_value is not None
+            and self.max_value is not None
+            and not (self.min_value <= value <= self.max_value)
+        ):
+            return False
+
+        return True
 
     def _feature_dimensionality(self) -> int:
         return len(self.as_feature())
 
+    def validate_min_max_range(
+        self, min_value: Optional[float], max_value: Optional[float]
+    ) -> None:
+        """Validates the min-max range for the slot.
+
+        Raises:
+            InvalidSlotConfigError, if the min-max range is invalid.
+        """
+        if min_value is not None and max_value is not None and min_value >= max_value:
+            raise InvalidSlotConfigError(
+                f"Float slot ('{self.name}') created with an invalid range "
+                f"using min ({min_value}) and max ({max_value}) values. Make sure "
+                f"min is smaller than max."
+            )
+
+        if (
+            self.initial_value is not None
+            and min_value is not None
+            and max_value is not None
+            and not (min_value <= self.initial_value <= max_value)
+        ):
+            raise InvalidSlotConfigError(
+                f"Float slot ('{self.name}') created with an initial value "
+                f"{self.initial_value}. This value is outside of the configured min "
+                f"({min_value}) and max ({max_value}) values."
+            )
+
 
 class BooleanSlot(Slot):
     """A slot storing a truth value."""

rasa/shared/core/training_data/story_reader/story_reader.py

@@ -126,4 +126,4 @@ class StoryParseError(RasaCoreException, ValueError):
 
     def __init__(self, message: Text) -> None:
         self.message = message
-        super(StoryParseError, self).__init__()
+        super(StoryParseError, self).__init__(message)

rasa/shared/exceptions.py

@@ -16,6 +16,17 @@ class RasaException(Exception):
     to the users, but will be ignored in telemetry.
     """
 
+    def __init__(self, message: str, suppress_stack_trace: bool = False, **kwargs: Any):
+        """Initialize the exception.
+
+        Args:
+            message: The error message.
+            suppress_stack_trace: If True, the stack trace will be suppressed in logs.
+            **kwargs: Additional keyword arguments (e.g., cause for exception chaining).
+        """
+        Exception.__init__(self, message)
+        self.suppress_stack_trace = suppress_stack_trace
+
 
 class RasaCoreException(RasaException):
     """Basic exception for errors raised by Rasa Core."""
@@ -113,6 +124,17 @@ class SchemaValidationError(RasaException, jsonschema.ValidationError):
 class InvalidEntityFormatException(RasaException, json.JSONDecodeError):
     """Raised if the format of an entity is invalid."""
 
+    def __init__(self, msg: str, doc: str = "", pos: int = 0):
+        """Initialize the exception.
+
+        Args:
+            msg: The error message.
+            doc: The document that caused the error.
+            pos: The position in the document where the error occurred.
+        """
+        RasaException.__init__(self, msg)
+        json.JSONDecodeError.__init__(self, msg, doc, pos)
+
     @classmethod
     def create_from(
         cls, other: json.JSONDecodeError, msg: Text
@@ -130,8 +152,7 @@ class ConnectionException(RasaException):
 
 
 class ProviderClientAPIException(RasaException):
-    """Raised for errors that occur during API interactions
-    with LLM / embedding providers.
+    """For errors during API interactions with LLM / embedding providers.
 
     Attributes:
         original_exception (Exception): The original exception that was

rasa/shared/providers/llm/litellm_router_llm_client.py

@@ -151,7 +151,7 @@ class LiteLLMRouterLLMClient(_BaseLiteLLMRouterClient, _BaseLiteLLMClient):
         if not self._use_chat_completions_endpoint:
             return self._text_completion(messages)
         try:
-            formatted_messages = self._format_messages(messages)
+            formatted_messages = self._get_formatted_messages(messages)
             response = self.router_client.completion(
                 messages=formatted_messages, **{**self._completion_fn_args, **kwargs}
             )
@@ -189,7 +189,7 @@ class LiteLLMRouterLLMClient(_BaseLiteLLMRouterClient, _BaseLiteLLMClient):
         if not self._use_chat_completions_endpoint:
             return await self._atext_completion(messages)
         try:
-            formatted_messages = self._format_messages(messages)
+            formatted_messages = self._get_formatted_messages(messages)
             response = await self.router_client.acompletion(
                 messages=formatted_messages, **{**self._completion_fn_args, **kwargs}
             )

rasa/shared/utils/common.py

@@ -26,6 +26,7 @@ from rasa.exceptions import MissingDependencyException
 from rasa.shared.constants import DOCS_URL_MIGRATION_GUIDE
 from rasa.shared.exceptions import ProviderClientValidationError, RasaException
 from rasa.shared.utils.cli import print_success
+from rasa.utils.installation_utils import check_for_installation_issues
 
 logger = logging.getLogger(__name__)
 
@@ -396,7 +397,11 @@ Sign up at: https://feedback.rasa.com
     print_success(message)
 
 
-def conditional_import(module_name: str, class_name: str) -> Tuple[Any, bool]:
+def conditional_import(
+    module_name: str,
+    class_name: str,
+    check_installation_setup: bool = False,
+) -> Tuple[Any, bool]:
     """Conditionally import a class, returning (class, is_available) tuple.
 
     Args:
@@ -408,6 +413,9 @@ def conditional_import(module_name: str, class_name: str) -> Tuple[Any, bool]:
         or None if import failed, and is_available is a boolean indicating
         whether the import was successful.
     """
+    if check_installation_setup:
+        check_for_installation_issues()
+
     try:
         module = __import__(module_name, fromlist=[class_name])
         return getattr(module, class_name), True

rasa/shared/utils/llm.py

@@ -1074,7 +1074,7 @@ def _get_llm_command_generator_config(
 
 
 def _get_compact_llm_command_generator_prompt(
-    config: Dict[Text, Any], endpoints: Dict[Text, Any]
+    config: Dict[Text, Any], model_groups: Dict[Text, Any]
 ) -> Text:
     """Get the command generator prompt based on the config."""
     from rasa.dialogue_understanding.generator.single_step.compact_llm_command_generator import (  # noqa: E501
@@ -1084,7 +1084,7 @@ def _get_compact_llm_command_generator_prompt(
     model_config = _get_llm_command_generator_config(config)
     llm_config = resolve_model_client_config(
         model_config=model_config,
-        model_groups=endpoints.get(MODEL_GROUPS_CONFIG_KEY),
+        model_groups=model_groups,
     )
     return get_default_prompt_template_based_on_model(
         llm_config=llm_config or {},
@@ -1119,7 +1119,7 @@ def get_system_default_prompts(
 
     Args:
         config: The config.yml file data.
-        endpoints: The endpoints.yml file data.
+        endpoints: The endpoints configuration dictionary.
 
     Returns:
         SystemPrompts: A Pydantic model containing all default prompts.
@@ -1128,8 +1128,25 @@ def get_system_default_prompts(
         DEFAULT_RESPONSE_VARIATION_PROMPT_TEMPLATE,
     )
 
+    # The Model Manager / Model API service receives the endpoints configuration
+    # as raw YAML text rather than as a file path. However, both
+    # Configuration.initialise_endpoints() and AvailableEndpoints.read_endpoints()
+    # currently only accept a Path input and do not support loading from in-memory
+    # YAML content.
+
+    # Since these classes only support file-based initialization today, we need
+    # to bootstrap the Configuration with an empty AvailableEndpoints instance for now.
+
+    # IMPORTANT: This configuration must be properly initialized with valid endpoints
+    # and available agents once Studio introduces full support for Agent configurations
+    # (A2A and MCP).
+    Configuration.initialise_empty()
+
+    model_groups = endpoints.get(MODEL_GROUPS_CONFIG_KEY)
     return SystemPrompts(
-        command_generator=_get_compact_llm_command_generator_prompt(config, endpoints),
+        command_generator=_get_compact_llm_command_generator_prompt(
+            config, model_groups
+        ),
         enterprise_search=_get_enterprise_search_prompt(config),
         contextual_response_rephraser=DEFAULT_RESPONSE_VARIATION_PROMPT_TEMPLATE,
     )

rasa/shared/utils/mcp/server_connection.py

@@ -121,7 +121,8 @@ class MCPServerConnection:
         except Exception as eg:
             for exc in getattr(eg, "exceptions", [eg]):
                 event_info = (
-                    f"Failed to connect to MCP server `{self.server_name}`: {exc!s}"
+                    f"Failed to connect to MCP server `{self.server_name}`. \nOriginal "
+                    f"error: {exc!s}"
                 )
                 if isinstance(exc, HTTPStatusError):
                     status_code = exc.response.status_code
@@ -135,9 +136,11 @@ class MCPServerConnection:
                     )
                     await self._cleanup()
                     if status_code in [400, 401, 403]:
-                        raise AuthenticationError(eg) from eg
+                        raise AuthenticationError(str(exc)) from eg
+                    elif status_code == 404:
+                        raise Exception(str(exc)) from eg
                     else:
-                        raise ConnectionError(eg) from eg
+                        raise ConnectionError(str(exc)) from eg
                 else:
                     structlogger.error(
                         "mcp_server_connection.connect.other_exception",
@@ -147,7 +150,7 @@ class MCPServerConnection:
                         error=str(exc),
                     )
             await self._cleanup()
-            raise ConnectionError(eg) from eg
+            raise ConnectionError(str(exc)) from eg
 
         except asyncio.CancelledError as e:
             event_info = f"Connection to MCP server `{self.server_name}` was cancelled."

rasa/studio/download.py

@@ -10,6 +10,7 @@ from ruamel.yaml.scalarstring import LiteralScalarString
 
 import rasa.cli.utils
 import rasa.shared.utils.cli
+from rasa.core.config.configuration import Configuration
 from rasa.shared.constants import (
     DEFAULT_CONFIG_PATH,
     DEFAULT_DATA_PATH,
@@ -116,6 +117,8 @@ def _handle_endpoints(handler: StudioDataHandler, root: Path) -> None:
     endpoints_path = root / DEFAULT_ENDPOINTS_PATH
     endpoints_path.write_text(endpoints_data, encoding="utf-8")
 
+    Configuration.initialise_endpoints(endpoints_path=endpoints_path)
+
 
 def _handle_domain(handler: StudioDataHandler, root: Path) -> None:
     """Persist the assistant’s domain file.

rasa/studio/prompts.py

@@ -43,6 +43,7 @@ def handle_prompts(prompts: Dict[Text, Text], root: Path) -> None:
     config: Dict = read_yaml(config_path)
     endpoints: Dict = read_yaml(endpoints_path)
 
+    # System default prompts are dependent on the endpoints
     system_prompts = get_system_default_prompts(config, endpoints)
 
     _handle_contextual_response_rephraser(

rasa/studio/upload.py

@@ -154,6 +154,10 @@ def handle_upload(args: argparse.Namespace) -> None:
             "Authentication is invalid or expired. Please run `rasa studio login`."
         )
 
+    from rasa.core.config.configuration import Configuration
+
+    Configuration.initialise_empty()
+
     structlogger.info("rasa.studio.upload.loading_data", event_info="Loading data...")
 
     args.domain = get_validated_path(args.domain, "domain", DEFAULT_DOMAIN_PATHS)

rasa/utils/common.py

@@ -36,6 +36,7 @@ from rasa.constants import (
     ENV_LOG_LEVEL_LIBRARIES,
     ENV_LOG_LEVEL_MATPLOTLIB,
     ENV_LOG_LEVEL_MCP,
+    ENV_LOG_LEVEL_PYMONGO,
     ENV_LOG_LEVEL_RABBITMQ,
     ENV_MCP_LOGGING_ENABLED,
 )
@@ -297,6 +298,7 @@ def configure_library_logging() -> None:
     update_rabbitmq_log_level(library_log_level)
     update_websockets_log_level(library_log_level)
     update_mcp_log_level()
+    update_pymongo_log_level(library_log_level)
 
 
 def update_apscheduler_log_level() -> None:
@@ -481,6 +483,13 @@ def update_mcp_log_level() -> None:
         logging.getLogger(logger_name).propagate = False
 
 
+def update_pymongo_log_level(library_log_level: str) -> None:
+    """Set the log level of pymongo."""
+    log_level = os.environ.get(ENV_LOG_LEVEL_PYMONGO, library_log_level)
+    logging.getLogger("pymongo").setLevel(log_level)
+    logging.getLogger("pymongo").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())))

rasa/utils/endpoints.py

@@ -1,5 +1,6 @@
 import os
 import ssl
+from functools import lru_cache
 from pathlib import Path
 from types import ModuleType
 from typing import Any, Dict, List, Optional, Text, Union
@@ -16,6 +17,7 @@ from rasa.shared.utils.yaml import read_config_file
 structlogger = structlog.get_logger()
 
 
+@lru_cache(maxsize=10)
 def read_endpoint_config(
     filename: Union[str, Path], endpoint_type: Text
 ) -> Optional["EndpointConfig"]: