rasa-pro 3.13.1a17__py3-none-any.whl → 3.13.1.dev1__py3-none-any.whl

rasa/model_manager/trainer_service.py

@@ -14,6 +14,7 @@ from rasa.model_manager.utils import (
     ensure_base_directory_exists,
     logs_path,
     models_base_path,
+    subpath,
     write_encoded_data_to_file,
 )
 from rasa.model_manager.warm_rasa_process import (
@@ -21,7 +22,6 @@ from rasa.model_manager.warm_rasa_process import (
 )
 from rasa.model_training import generate_random_model_name
 from rasa.studio.prompts import handle_prompts
-from rasa.utils.io import subpath
 
 structlogger = structlog.get_logger()
 
@@ -53,15 +53,6 @@ class TrainingSession(BaseModel):
         """Check if the training is running."""
         return self.status == TrainingSessionStatus.RUNNING
 
-    def has_just_finished(self) -> bool:
-        if not self.is_status_indicating_alive():
-            # skip if the training is not running
-            return False
-        if self.process.poll() is None:
-            # process is still running
-            return False
-        return True
-
     def model_path(self) -> str:
         """Return the path to the model."""
         return subpath(models_base_path(), f"{self.model_name}.tar.gz")
@@ -98,8 +89,14 @@ def terminate_training(training: TrainingSession) -> None:
 
 
 def update_training_status(training: TrainingSession) -> None:
-    if training.has_just_finished():
-        complete_training(training)
+    if not training.is_status_indicating_alive():
+        # skip if the training is not running
+        return
+    if training.process.poll() is None:
+        # process is still running
+        return
+
+    complete_training(training)
 
 
 def complete_training(training: TrainingSession) -> None:

rasa/model_manager/utils.py

@@ -5,11 +5,15 @@ from typing import Optional
 import structlog
 
 from rasa.model_manager import config
-from rasa.utils.io import subpath
+from rasa.shared.exceptions import RasaException
 
 structlogger = structlog.get_logger()
 
 
+class InvalidPathException(RasaException):
+    """Raised if a path is invalid - e.g. path traversal is detected."""
+
+
 def write_encoded_data_to_file(encoded_data: bytes, file: str) -> None:
     """Write base64 encoded data to a file."""
     # create the directory if it does not exist of the parent directory
@@ -49,6 +53,30 @@ def logs_path(action_id: str) -> str:
     return subpath(logs_base_path(), f"{action_id}.txt")
 
 
+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}")
+
+    if os.path.basename(safe_path) != child:
+        raise InvalidPathException(
+            f"Invalid path - path traversal detected: {safe_path}"
+        )
+
+    return safe_path
+
+
 def get_logs_content(action_id: str) -> Optional[str]:
     """Return the content of the log file for a given action id."""
     try:

rasa/monkey_patches.py

@@ -0,0 +1,91 @@
+import os
+import traceback
+from typing import Any, Optional
+
+from litellm.secret_managers.main import str_to_bool
+from packaging.version import Version
+
+
+def litellm_langfuse_logger_init_fixed(
+    self: Any,  # we should not import LangfuseLogger class before we patch it
+    langfuse_public_key: Optional[str] = None,
+    langfuse_secret: Optional[str] = None,
+    langfuse_host: str = "https://cloud.langfuse.com",
+    flush_interval: int = 1,
+) -> None:
+    """Monkeypatched version of LangfuseLogger.__init__ from the LiteLLM library.
+
+    This patched version removes a call that fetched the `project_id` from
+    Langfuse Cloud even when it was already set via environment variables.
+    In the original implementation, this call was made *before* initializing
+    the LangfuseClient, which caused the application to freeze for up to 60 seconds.
+
+    By removing this premature call, the monkeypatch avoids the unnecessary network
+    request and prevents the timeout/freeze issue.
+
+    This workaround can be removed once the underlying bug is resolved in LiteLLM:
+    https://github.com/BerriAI/litellm/issues/7732
+    """
+    try:
+        import langfuse
+        from langfuse import Langfuse
+    except Exception as e:
+        raise Exception(
+            f"\033[91mLangfuse not installed, try running 'pip install langfuse' "
+            f"to fix this error: {e}\n{traceback.format_exc()}\033[0m"
+        )
+    # Instance variables
+    self.secret_key = langfuse_secret or os.getenv("LANGFUSE_SECRET_KEY", "")
+    self.public_key = langfuse_public_key or os.getenv("LANGFUSE_PUBLIC_KEY", "")
+
+    self.langfuse_host = langfuse_host or os.getenv(
+        "LANGFUSE_HOST", "https://cloud.langfuse.com"
+    )
+    self.langfuse_host.replace("http://", "https://")
+    if not self.langfuse_host.startswith("https://"):
+        self.langfuse_host = "https://" + self.langfuse_host
+
+    self.langfuse_release = os.getenv("LANGFUSE_RELEASE")
+    self.langfuse_debug = os.getenv("LANGFUSE_DEBUG")
+    self.langfuse_flush_interval = (
+        os.getenv("LANGFUSE_FLUSH_INTERVAL") or flush_interval
+    )
+
+    parameters = {
+        "public_key": self.public_key,
+        "secret_key": self.secret_key,
+        "host": self.langfuse_host,
+        "release": self.langfuse_release,
+        "debug": self.langfuse_debug,
+        "flush_interval": self.langfuse_flush_interval,  # flush interval in seconds
+    }
+
+    if Version(langfuse.version.__version__) >= Version("2.6.0"):
+        parameters["sdk_integration"] = "litellm"
+
+    self.Langfuse = Langfuse(**parameters)
+
+    if os.getenv("UPSTREAM_LANGFUSE_SECRET_KEY") is not None:
+        upstream_langfuse_debug = (
+            str_to_bool(self.upstream_langfuse_debug)
+            if self.upstream_langfuse_debug is not None
+            else None
+        )
+        self.upstream_langfuse_secret_key = os.getenv("UPSTREAM_LANGFUSE_SECRET_KEY")
+        self.upstream_langfuse_public_key = os.getenv("UPSTREAM_LANGFUSE_PUBLIC_KEY")
+        self.upstream_langfuse_host = os.getenv("UPSTREAM_LANGFUSE_HOST")
+        self.upstream_langfuse_release = os.getenv("UPSTREAM_LANGFUSE_RELEASE")
+        self.upstream_langfuse_debug = os.getenv("UPSTREAM_LANGFUSE_DEBUG")
+        self.upstream_langfuse = Langfuse(
+            public_key=self.upstream_langfuse_public_key,
+            secret_key=self.upstream_langfuse_secret_key,
+            host=self.upstream_langfuse_host,
+            release=self.upstream_langfuse_release,
+            debug=(
+                upstream_langfuse_debug
+                if upstream_langfuse_debug is not None
+                else False
+            ),
+        )
+    else:
+        self.upstream_langfuse = None

rasa/shared/constants.py

@@ -350,6 +350,12 @@ ROLE_SYSTEM = "system"
 REFILL_UTTER = "refill_utter"
 REJECTIONS = "rejections"
 
+# Used for Langfuse metadata
+LANGFUSE_METADATA_USER_ID = "trace_user_id"
+LANGFUSE_METADATA_SESSION_ID = "session_id"
+LANGFUSE_CUSTOM_METADATA_DICT = "trace_metadata"
+LANGFUSE_TAGS = "tags"
+
 # Constants for extractive search FAQ parsing (QA pairs from input documents)
 FAQ_DOCUMENT_METADATA_TITLE = "title"
 FAQ_DOCUMENT_METADATA_ANSWER = "answer"

rasa/shared/core/domain.py

@@ -98,8 +98,6 @@ IS_RETRIEVAL_INTENT_KEY = "is_retrieval_intent"
 ENTITY_ROLES_KEY = "roles"
 ENTITY_GROUPS_KEY = "groups"
 ENTITY_FEATURIZATION_KEY = "influence_conversation"
-STORE_ENTITIES_AS_SLOTS_KEY = "store_entities_as_slots"
-DOMAIN_CONFIG_KEY = "config"
 
 KEY_SLOTS = "slots"
 KEY_INTENTS = "intents"
@@ -148,8 +146,6 @@ MERGE_FUNC_MAPPING: Dict[Text, Callable[..., Any]] = {
     KEY_FORMS: rasa.shared.utils.common.merge_dicts,
 }
 
-DEFAULT_STORE_ENTITIES_AS_SLOTS = True
-
 DICT_DATA_KEYS = [
     key
     for key, value in MERGE_FUNC_MAPPING.items()
@@ -322,7 +318,7 @@ class Domain:
         actions = cls._collect_action_names(domain_actions)
 
         additional_arguments = {
-            **data.get(DOMAIN_CONFIG_KEY, {}),
+            **data.get("config", {}),
             "actions_which_explicitly_need_domain": (
                 cls._collect_actions_which_explicitly_need_domain(domain_actions)
             ),
@@ -472,9 +468,9 @@ class Domain:
             return domain_dict
 
         if override:
-            config = domain_dict.get(DOMAIN_CONFIG_KEY, {})
+            config = domain_dict.get("config", {})
             for key, val in config.items():
-                combined[DOMAIN_CONFIG_KEY][key] = val
+                combined["config"][key] = val
 
         if (
             override
@@ -512,10 +508,10 @@ class Domain:
         return combined
 
     def partial_merge(self, other: Domain) -> Domain:
-        """Returns a new Domain with intersection-based merging.
-
-        For each domain section only overwrite items that already exist in self.
-        Brand-new items in `other` are ignored.
+        """
+        Returns a new Domain with intersection-based merging:
+          - For each domain section only overwrite items that already exist in self.
+          - Brand-new items in `other` are ignored.
 
         Args:
             other: The domain to merge with.
@@ -547,9 +543,9 @@ class Domain:
         return Domain.from_dict(updated_self)
 
     def difference(self, other: Domain) -> Domain:
-        """Returns a new Domain containing items in `self` that are NOT in `other`.
-
-        Uses simple equality checks for dict/list items.
+        """
+        Returns a new Domain containing items in `self` that are NOT in `other`,
+        using simple equality checks for dict/list items.
 
         Args:
             other: The domain to compare with.
@@ -602,16 +598,9 @@ class Domain:
     ) -> Dict:
         # add the config, session_config and training data version defaults
         # if not included in the original domain dict
-        if (
-            DOMAIN_CONFIG_KEY not in data
-            and store_entities_as_slots != DEFAULT_STORE_ENTITIES_AS_SLOTS
-        ):
+        if "config" not in data and not store_entities_as_slots:
             data.update(
-                {
-                    DOMAIN_CONFIG_KEY: {
-                        STORE_ENTITIES_AS_SLOTS_KEY: store_entities_as_slots
-                    }
-                }
+                {"config": {"store_entities_as_slots": store_entities_as_slots}}
             )
 
         if SESSION_CONFIG_KEY not in data:
@@ -948,7 +937,7 @@ class Domain:
         forms: Union[Dict[Text, Any], List[Text]],
         data: Dict,
         action_texts: Optional[List[Text]] = None,
-        store_entities_as_slots: bool = DEFAULT_STORE_ENTITIES_AS_SLOTS,
+        store_entities_as_slots: bool = True,
         session_config: SessionConfig = SessionConfig.default(),
         **kwargs: Any,
     ) -> None:
@@ -1722,45 +1711,9 @@ class Domain:
         else:
             return True
 
-    def _uses_custom_session_config(self) -> bool:
-        """Check if the domain uses a custom session config."""
-        return self._data.get(SESSION_CONFIG_KEY) != SessionConfig.default().as_dict()
-
-    def _uses_custom_domain_config(self) -> bool:
-        """Check if the domain uses a custom domain config."""
-        return self._data.get(DOMAIN_CONFIG_KEY) != {
-            STORE_ENTITIES_AS_SLOTS_KEY: DEFAULT_STORE_ENTITIES_AS_SLOTS
-        }
-
-    def _cleaned_json_data(self) -> Dict[Text, Any]:
-        """Remove default values from the domain data.
-
-        Only retains data that was customized by the user.
-
-        Returns:
-            A cleaned dictionary version of the domain.
-        """
-        cleaned_data = copy.deepcopy(self._data)
-
-        # Remove default config if it only contains store_entities_as_slots: False
-        if DOMAIN_CONFIG_KEY in cleaned_data and not self._uses_custom_domain_config():
-            del cleaned_data[DOMAIN_CONFIG_KEY]
-
-        # Remove default session config if it matches the default values
-        if (
-            SESSION_CONFIG_KEY in cleaned_data
-            and not self._uses_custom_session_config()
-        ):
-            del cleaned_data[SESSION_CONFIG_KEY]
-
-        return cleaned_data
-
-    def as_dict(self, should_clean_json: bool = False) -> Dict[Text, Any]:
+    def as_dict(self) -> Dict[Text, Any]:
         """Return serialized `Domain`."""
-        if should_clean_json:
-            return self._cleaned_json_data()
-        else:
-            return self._data
+        return self._data
 
     @staticmethod
     def get_responses_with_multilines(

rasa/shared/core/flows/flow_step.py

@@ -52,13 +52,7 @@ def step_from_json(flow_id: Text, data: Dict[Text, Any]) -> FlowStep:
         return SetSlotsFlowStep.from_json(flow_id, data)
     if "noop" in data:
         return NoOperationFlowStep.from_json(flow_id, data)
-
-    required_properties = ["action", "collect", "link", "call", "set_slots", "noop"]
-    raise RasaException(
-        f"Failed to parse step from json. Unknown type for {data}. "
-        f"At lest one of the following properties is required: "
-        f"{', '.join(required_properties)}"
-    )
+    raise RasaException(f"Failed to parse step from json. Unknown type for {data}.")
 
 
 @dataclass

rasa/shared/core/flows/yaml_flows_io.py

@@ -262,9 +262,12 @@ class YamlFlowsWriter:
         Returns:
             The dumped YAML.
         """
-        return dump_obj_as_yaml_to_string(
-            {KEY_FLOWS: get_flows_as_json(flows, should_clean_json)}
-        )
+        dump = {}
+        for flow in flows:
+            dumped_flow = get_flow_as_json(flow, should_clean_json)
+            del dumped_flow["id"]
+            dump[flow.id] = dumped_flow
+        return dump_obj_as_yaml_to_string({KEY_FLOWS: dump})
 
     @staticmethod
     def dump(
@@ -421,20 +424,9 @@ def process_yaml_content(yaml_content: Dict[str, Any]) -> Dict[str, Any]:
     return yaml_content
 
 
-def get_flows_as_json(
-    flows: FlowsList, should_clean_json: bool = False
-) -> Dict[str, Any]:
-    """Get the flows as a JSON dictionary."""
-    dump = {}
-    for flow in flows:
-        dumped_flow = get_flow_as_json(flow, should_clean_json)
-        del dumped_flow["id"]
-        dump[flow.id] = dumped_flow
-    return dump
-
-
 def get_flow_as_json(flow: Flow, should_clean_json: bool = False) -> Dict[str, Any]:
-    """Clean the Flow JSON by removing default values and empty fields.
+    """
+    Clean the Flow JSON by removing default values and empty fields.
 
     Args:
         flow: The Flow object to clean.

rasa/shared/core/slots.py

@@ -273,14 +273,10 @@ class Slot(ABC):
         try:
             return rasa.shared.utils.common.class_from_module_path(type_name)
         except (ImportError, AttributeError):
-            known_types = [
-                cls.type_name for cls in rasa.shared.utils.common.all_subclasses(Slot)
-            ]
             raise InvalidSlotTypeException(
                 f"Failed to find slot type, '{type_name}' is neither a known type nor "
                 f"user-defined. If you are creating your own slot type, make "
                 f"sure its module path is correct. "
-                f"Known types: {', '.join(known_types)} "
                 f"You can find all build in types at {DOCS_URL_SLOTS}"
             )
 

rasa/shared/importers/importer.py

@@ -207,12 +207,6 @@ class TrainingDataImporter(ABC):
                 )
             ]
 
-        return TrainingDataImporter.wrap_in_builtins(importers)
-
-    @staticmethod
-    def wrap_in_builtins(
-        importers: List["TrainingDataImporter"],
-    ) -> "TrainingDataImporter":
         return LanguageImporter(
             E2EImporter(
                 FlowSyncImporter(ResponsesSyncImporter(CombinedDataImporter(importers)))

rasa/shared/importers/utils.py

@@ -1,37 +1,9 @@
-from typing import Any, Dict, Iterable, List, Optional, Text
-
-from pydantic import BaseModel, Field
+from typing import Iterable, List, Optional, Text
 
 from rasa.shared.core.domain import Domain
 from rasa.shared.core.flows import FlowsList
-from rasa.shared.core.flows.yaml_flows_io import get_flows_as_json
 from rasa.shared.core.training_data.structures import StoryGraph
-from rasa.shared.importers.importer import TrainingDataImporter
-from rasa.shared.nlu.training_data.formats.rasa_yaml import RasaYAMLWriter
 from rasa.shared.nlu.training_data.training_data import TrainingData
-from rasa.utils.json_utils import extract_values
-
-
-class CALMUserData(BaseModel):
-    """All pieces that will be uploaded to Rasa Studio."""
-
-    flows: Dict[str, Any] = Field(default_factory=dict)
-    domain: Dict[str, Any] = Field(default_factory=dict)
-    config: Dict[str, Any] = Field(default_factory=dict)
-    endpoints: Dict[str, Any] = Field(default_factory=dict)
-    nlu: Dict[str, Any] = Field(default_factory=dict)
-
-
-DOMAIN_KEYS = [
-    "version",
-    "actions",
-    "responses",
-    "slots",
-    "intents",
-    "entities",
-    "forms",
-    "session_config",
-]
 
 
 def training_data_from_paths(paths: Iterable[Text], language: Text) -> TrainingData:
@@ -62,51 +34,3 @@ def flows_from_paths(files: List[Text]) -> FlowsList:
         )
     flows.validate()
     return flows
-
-
-def extract_calm_import_parts_from_importer(
-    importer: TrainingDataImporter,
-    config: Optional[Dict[str, Any]] = None,
-    endpoints: Optional[Dict[str, Any]] = None,
-) -> CALMUserData:
-    """Extracts CALMUserData from a TrainingDataImporter.
-
-    Args:
-        importer: The training data importer
-        data_paths: The path(s) to the training data for flows
-        config: Optional config dict, if not provided will use importer.get_config()
-        endpoints: Optional endpoints dict, defaults to empty dict
-
-    Returns:
-        CALMUserData containing flows, domain, config, endpoints, and nlu data
-    """
-    # Extract config
-    if config is None:
-        config = importer.get_config()
-
-    # Extract domain
-    domain_from_files = importer.get_user_domain().as_dict()
-    domain = extract_values(domain_from_files, DOMAIN_KEYS)
-
-    # Extract flows
-    flows = importer.get_user_flows()
-    flows_dict = get_flows_as_json(flows)
-
-    # Extract NLU data
-    nlu_data = importer.get_nlu_data()
-    nlu_examples = nlu_data.filter_training_examples(
-        lambda ex: ex.get("intent") in nlu_data.intents
-    )
-    nlu_dict = RasaYAMLWriter().training_data_to_dict(nlu_examples)
-
-    # Use provided endpoints or default to empty dict
-    if endpoints is None:
-        endpoints = {}
-
-    return CALMUserData(
-        flows=flows_dict or {},
-        domain=domain or {},
-        config=config or {},
-        endpoints=endpoints or {},
-        nlu=nlu_dict or {},
-    )

rasa/shared/providers/constants.py

@@ -4,3 +4,13 @@ LITE_LLM_API_KEY_FIELD = "api_key"
 LITE_LLM_API_VERSION_FIELD = "api_version"
 LITE_LLM_MODEL_FIELD = "model"
 LITE_LLM_AZURE_AD_TOKEN = "azure_ad_token"
+
+# Enable or disable Langfuse integration
+RASA_LANGFUSE_INTEGRATION_ENABLED_ENV_VAR = "RASA_LANGFUSE_INTEGRATION_ENABLED"
+
+# Langfuse configuration
+LANGFUSE_CALLBACK_NAME = "langfuse"
+LANGFUSE_HOST_ENV_VAR = "LANGFUSE_HOST"
+LANGFUSE_PROJECT_ID_ENV_VAR = "LANGFUSE_PROJECT_ID"
+LANGFUSE_PUBLIC_KEY_ENV_VAR = "LANGFUSE_PUBLIC_KEY"
+LANGFUSE_SECRET_KEY_ENV_VAR = "LANGFUSE_SECRET_KEY"

rasa/shared/providers/llm/_base_litellm_client.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import logging
 from abc import abstractmethod
-from typing import Any, Dict, List, Union, cast
+from typing import Any, Dict, List, Optional, Union, cast
 
 import structlog
 from litellm import acompletion, completion, validate_environment
@@ -126,7 +126,11 @@ class _BaseLiteLLMClient:
             raise ProviderClientValidationError(event_info)
 
     @suppress_logs(log_level=logging.WARNING)
-    def completion(self, messages: Union[List[dict], List[str], str]) -> LLMResponse:
+    def completion(
+        self,
+        messages: Union[List[dict], List[str], str],
+        metadata: Optional[Dict[str, Any]] = None,
+    ) -> LLMResponse:
         """Synchronously generate completions for given list of messages.
 
         Args:
@@ -138,6 +142,7 @@ class _BaseLiteLLMClient:
                 - a list of messages. Each message is a string and will be formatted
                     as a user message.
                 - a single message as a string which will be formatted as user message.
+            metadata: Optional metadata to be passed to the LLM call.
 
         Returns:
             List of message completions.
@@ -155,7 +160,9 @@ class _BaseLiteLLMClient:
 
     @suppress_logs(log_level=logging.WARNING)
     async def acompletion(
-        self, messages: Union[List[dict], List[str], str]
+        self,
+        messages: Union[List[dict], List[str], str],
+        metadata: Optional[Dict[str, Any]] = None,
     ) -> LLMResponse:
         """Asynchronously generate completions for given list of messages.
 
@@ -168,6 +175,7 @@ class _BaseLiteLLMClient:
                 - a list of messages. Each message is a string and will be formatted
                     as a user message.
                 - a single message as a string which will be formatted as user message.
+            metadata: Optional metadata to be passed to the LLM call.
 
         Returns:
             List of message completions.
@@ -178,7 +186,9 @@ class _BaseLiteLLMClient:
         try:
             formatted_messages = self._get_formatted_messages(messages)
             arguments = resolve_environment_variables(self._completion_fn_args)
-            response = await acompletion(messages=formatted_messages, **arguments)
+            response = await acompletion(
+                messages=formatted_messages, metadata=metadata, **arguments
+            )
             return self._format_response(response)
         except Exception as e:
             message = ""