rasa-pro 3.11.0a4.dev3__py3-none-any.whl → 3.11.0rc2__py3-none-any.whl

rasa/shared/constants.py

@@ -183,7 +183,34 @@ STREAM_CONFIG_KEY = "stream"
 N_REPHRASES_CONFIG_KEY = "n"
 USE_CHAT_COMPLETIONS_ENDPOINT_CONFIG_KEY = "use_chat_completions_endpoint"
 
+ROUTER_CONFIG_KEY = "router"
+ROUTER_STRATEGY_CONFIG_KEY = "router_strategy"
+REDIS_HOST_CONFIG_KEY = "redis_host"
+ROUTER_STRATEGIES_REQUIRING_REDIS_CACHE = [
+    "cost-based-routing",
+    "usage-based-routing",
+]
+ROUTER_STRATEGIES_NOT_REQUIRING_CACHE = [
+    "latency-based-routing",
+    "least-busy",
+    "simple-shuffle",
+]
+VALID_ROUTER_STRATEGIES = (
+    ROUTER_STRATEGIES_REQUIRING_REDIS_CACHE + ROUTER_STRATEGIES_NOT_REQUIRING_CACHE
+)
+
+MODELS_CONFIG_KEY = "models"
+MODEL_GROUPS_CONFIG_KEY = "model_groups"
+MODEL_GROUP_CONFIG_KEY = "model_group"
+MODEL_GROUP_ID_CONFIG_KEY = "id"
+
+EXTRA_PARAMETERS_KEY = "extra_parameters"
+MODEL_GROUP_ID_KEY = "model_group_id"
+MODEL_LIST_KEY = "model_list"
+LITELLM_PARAMS_KEY = "litellm_params"
+
 LLM_API_HEALTH_CHECK_ENV_VAR = "LLM_API_HEALTH_CHECK"
+LLM_API_HEALTH_CHECK_DEFAULT_VALUE = "false"
 
 AZURE_API_KEY_ENV_VAR = "AZURE_API_KEY"
 AZURE_AD_TOKEN_ENV_VAR = "AZURE_AD_TOKEN"
@@ -191,6 +218,8 @@ AZURE_API_BASE_ENV_VAR = "AZURE_API_BASE"
 AZURE_API_VERSION_ENV_VAR = "AZURE_API_VERSION"
 AZURE_API_TYPE_ENV_VAR = "AZURE_API_TYPE"
 
+AWS_REGION_NAME_CONFIG_KEY = "aws_region_name"
+
 HUGGINGFACE_MULTIPROCESS_CONFIG_KEY = "multi_process"
 HUGGINGFACE_CACHE_FOLDER_CONFIG_KEY = "cache_folder"
 HUGGINGFACE_SHOW_PROGRESS_CONFIG_KEY = "show_progress"
@@ -211,6 +240,13 @@ OPENAI_PROVIDER = "openai"
 AZURE_OPENAI_PROVIDER = "azure"
 SELF_HOSTED_PROVIDER = "self-hosted"
 HUGGINGFACE_LOCAL_EMBEDDING_PROVIDER = "huggingface_local"
+RASA_PROVIDER = "rasa"
+
+SELF_HOSTED_VLLM_PREFIX = "hosted_vllm"
+SELF_HOSTED_VLLM_API_KEY_ENV_VAR = "HOSTED_VLLM_API_KEY"
+
+SELF_HOSTED_VLLM_PREFIX = "hosted_vllm"
+SELF_HOSTED_VLLM_API_KEY_ENV_VAR = "HOSTED_VLLM_API_KEY"
 
 SELF_HOSTED_VLLM_PREFIX = "hosted_vllm"
 SELF_HOSTED_VLLM_API_KEY_ENV_VAR = "HOSTED_VLLM_API_KEY"
@@ -244,6 +280,3 @@ RASA_PATTERN_CANNOT_HANDLE_INVALID_INTENT = (
 )
 
 ROUTE_TO_CALM_SLOT = "route_session_to_calm"
-
-ORIGINAL_VALUE = "original_value"
-RESOLVED_VALUE = "resolved_value"

rasa/shared/core/constants.py

@@ -11,6 +11,7 @@ USER_INTENT_BACK = "back"
 USER_INTENT_OUT_OF_SCOPE = "out_of_scope"
 USER_INTENT_SESSION_START = "session_start"
 USER_INTENT_SESSION_END = "session_end"
+USER_INTENT_SILENCE_TIMEOUT = "silence_timeout"
 SESSION_START_METADATA_SLOT = "session_started_metadata"
 
 DEFAULT_INTENTS = [
@@ -19,6 +20,7 @@ DEFAULT_INTENTS = [
     USER_INTENT_OUT_OF_SCOPE,
     USER_INTENT_SESSION_START,
     USER_INTENT_SESSION_END,
+    USER_INTENT_SILENCE_TIMEOUT,
     constants.DEFAULT_NLU_FALLBACK_INTENT_NAME,
 ]
 
@@ -106,6 +108,11 @@ FLOW_HASHES_SLOT = "flow_hashes"
 
 FLOW_SLOT_NAMES = [FLOW_HASHES_SLOT]
 
+# slots for audio timeout
+SLOT_SILENCE_TIMEOUT = "silence_timeout"
+SILENCE_TIMEOUT_DEFAULT_VALUE = 6.0
+SLOT_CONSECUTIVE_SILENCE_TIMEOUTS = "consecutive_silence_timeouts"
+SILENCE_SLOTS = [SLOT_SILENCE_TIMEOUT, SLOT_CONSECUTIVE_SILENCE_TIMEOUTS]
 # slots for knowledge base
 SLOT_LISTED_ITEMS = "knowledge_base_listed_objects"
 SLOT_LAST_OBJECT = "knowledge_base_last_object"

rasa/shared/core/domain.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import collections
 import copy
 import json
+import math
 import os
 from dataclasses import dataclass
 from functools import cached_property
@@ -57,6 +58,7 @@ from rasa.shared.core.events import SlotSet, UserUttered
 from rasa.shared.core.slots import (
     AnySlot,
     CategoricalSlot,
+    FloatSlot,
     ListSlot,
     Slot,
     TextSlot,
@@ -1082,6 +1084,7 @@ class Domain:
         self._add_knowledge_base_slots()
         self._add_categorical_slot_default_value()
         self._add_session_metadata_slot()
+        self._add_audio_slots()
 
     def _add_categorical_slot_default_value(self) -> None:
         """Add a default value to all categorical slots.
@@ -1136,6 +1139,29 @@ class Domain:
                 )
             )
 
+    def _add_audio_slots(self) -> None:
+        """Add slots relevant for audio channels."""
+        self.slots.append(
+            FloatSlot(
+                rasa.shared.core.constants.SLOT_SILENCE_TIMEOUT,
+                mappings=[],
+                influence_conversation=False,
+                is_builtin=True,
+                initial_value=rasa.shared.core.constants.SILENCE_TIMEOUT_DEFAULT_VALUE,
+                max_value=math.inf,
+            )
+        )
+        self.slots.append(
+            FloatSlot(
+                rasa.shared.core.constants.SLOT_CONSECUTIVE_SILENCE_TIMEOUTS,
+                mappings=[],
+                influence_conversation=False,
+                is_builtin=True,
+                initial_value=0.0,
+                max_value=math.inf,
+            )
+        )
+
     def _add_knowledge_base_slots(self) -> None:
         """Add slots for the knowledge base action to slots.
 

rasa/shared/core/flows/flow.py

@@ -60,6 +60,8 @@ class Flow:
     """
     file_path: Optional[str] = None
     """The path to the file where the flow is stored."""
+    persisted_slots: List[str] = field(default_factory=list)
+    """The list of slots that should be persisted after the flow ends."""
 
     @staticmethod
     def from_json(
@@ -95,6 +97,7 @@ class Flow:
             # If we are reading the flows in after training the file_path is part of
             # data. When the model is trained, take the provided file_path.
             file_path=data.get("file_path") if "file_path" in data else file_path,
+            persisted_slots=data.get("persisted_slots", []),
         )
 
     def get_full_name(self) -> str:
@@ -167,6 +170,8 @@ class Flow:
             data["nlu_trigger"] = self.nlu_triggers.as_json()
         if self.file_path:
             data["file_path"] = self.file_path
+        if self.persisted_slots:
+            data["persisted_slots"] = self.persisted_slots
 
         return data
 

rasa/shared/core/flows/flows_list.py

@@ -234,12 +234,16 @@ class FlowsList:
             [f for f in self.underlying_flows if not f.is_startable_only_via_link()]
         )
 
-    def available_slot_names(self) -> Set[str]:
+    def available_slot_names(
+        self, ask_before_filling: Optional[bool] = None
+    ) -> Set[str]:
         """Get all slot names collected by flows."""
         return {
             step.collect
             for flow in self.underlying_flows
             for step in flow.get_collect_steps()
+            if ask_before_filling is None
+            or step.ask_before_filling == ask_before_filling
         }
 
     def available_custom_actions(self) -> Set[str]:

rasa/shared/core/flows/flows_yaml_schema.json

@@ -279,6 +279,9 @@
                 },
                 "steps": {
                     "$ref": "#/$defs/steps"
+                },
+                "persisted_slots": {
+                    "$ref": "#/$defs/persisted_slots"
                 }
             }
         },
@@ -288,6 +291,13 @@
             "items": {
                 "type": "object"
             }
+        },
+        "persisted_slots": {
+            "type": "array",
+            "schema_name": "list of slots",
+            "items": {
+                "type": "string"
+            }
         }
     }
 }

rasa/shared/core/flows/utils.py

@@ -0,0 +1,39 @@
+from typing import Set
+from rasa.shared.utils.io import raise_deprecation_warning
+
+RESET_PROPERTY_NAME = "reset_after_flow_ends"
+PERSIST_PROPERTY_NAME = "persisted_slots"
+
+
+def warn_deprecated_collect_step_config(flow_id: str, collect_step: str) -> None:
+    """Warns about deprecated reset_after_flow_ends usage in collect steps."""
+    raise_deprecation_warning(
+        f"Configuring '{RESET_PROPERTY_NAME}' in collect step '{collect_step}' is "
+        f"deprecated and will be removed in Rasa Pro 4.0.0. In flow id '{flow_id}', "
+        f"please use the '{PERSIST_PROPERTY_NAME}' "
+        "property at the flow level instead."
+    )
+
+
+def get_duplicate_slot_persistence_config_error_message(
+    flow_id: str, collect_step: str
+) -> str:
+    """Returns an error message for duplicate slot persistence configuration."""
+    return (
+        f"Flow with id '{flow_id}' uses the '{RESET_PROPERTY_NAME}' property "
+        f"in collect step '{collect_step}' and also the "
+        f"'{PERSIST_PROPERTY_NAME}' property at the flow level. "
+        "Please use only one of the two configuration methods."
+    )
+
+
+def get_invalid_slot_persistence_config_error_message(
+    flow_id: str, invalid_slots: Set[str]
+) -> str:
+    """Returns an error message for invalid slot persistence configuration."""
+    return (
+        f"Flow with id '{flow_id}' lists slot(s) '{invalid_slots}' in the "
+        f"'{PERSIST_PROPERTY_NAME}' property. However these slots "
+        f"are neither used in a collect step nor a set_slot step of the flow. "
+        f"Please remove such slots from the '{PERSIST_PROPERTY_NAME}' property."
+    )

rasa/shared/core/flows/validation.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import re
 import typing
 from collections import defaultdict
+from dataclasses import dataclass
 from typing import Optional, Set, Text, List
 
 from rasa.shared.constants import (
@@ -26,6 +27,12 @@ from rasa.shared.core.flows.steps.call import CallFlowStep
 from rasa.shared.core.flows.steps.collect import CollectInformationFlowStep
 from rasa.shared.core.flows.steps.constants import CONTINUE_STEP_PREFIX, DEFAULT_STEPS
 from rasa.shared.core.flows.steps.link import LinkFlowStep
+from rasa.shared.core.flows.steps.set_slots import SetSlotsFlowStep
+from rasa.shared.core.flows.utils import (
+    warn_deprecated_collect_step_config,
+    get_duplicate_slot_persistence_config_error_message,
+    get_invalid_slot_persistence_config_error_message,
+)
 from rasa.shared.exceptions import RasaException
 
 if typing.TYPE_CHECKING:
@@ -379,6 +386,42 @@ class FlowIdNamingException(RasaException):
         )
 
 
+class DuplicateSlotPersistConfigException(RasaException):
+    """Raised when a slot persist configuration is duplicated."""
+
+    def __init__(self, flow_id: str, collect_step: str) -> None:
+        """Initializes the exception."""
+        self.flow_id = flow_id
+        self.collect_step = collect_step
+
+    def __str__(self) -> str:
+        """Return a string representation of the exception."""
+        return get_duplicate_slot_persistence_config_error_message(
+            self.flow_id, self.collect_step
+        )
+
+
+class InvalidPersistSlotsException(RasaException):
+    """Raised when a slot persist configuration is duplicated."""
+
+    def __init__(self, flow_id: str, invalid_slots: Set[str]) -> None:
+        """Initializes the exception."""
+        self.flow_id = flow_id
+        self.invalid_slots = invalid_slots
+
+    def __str__(self) -> str:
+        """Return a string representation of the exception."""
+        return get_invalid_slot_persistence_config_error_message(
+            self.flow_id, self.invalid_slots
+        )
+
+
+@dataclass
+class ValidationResult:
+    is_valid: bool
+    invalid_slots: Set[str]
+
+
 def validate_flow(flow: Flow) -> None:
     """Validates the flow configuration.
 
@@ -387,6 +430,8 @@ def validate_flow(flow: Flow) -> None:
         - whether all next links point to existing steps
         - whether all steps can be reached from the start step
     """
+    from rasa.cli.utils import is_skip_validation_flag_set
+
     validate_flow_not_empty(flow)
     validate_no_empty_step_sequences(flow)
     validate_all_steps_next_property(flow)
@@ -397,6 +442,12 @@ def validate_flow(flow: Flow) -> None:
     validate_slot_names_to_be_collected(flow)
     validate_flow_id(flow)
 
+    if is_skip_validation_flag_set():
+        # we only want to run this validation if the --skip-validation flag is used
+        # during training because Flow Validation exceptions are raised one by one
+        # as opposed to all at once with the Validator class
+        validate_slot_persistence_configuration(flow)
+
 
 def validate_flow_not_empty(flow: Flow) -> None:
     """Validate that the flow is not empty."""
@@ -637,3 +688,48 @@ def validate_flow_id(flow: Flow) -> None:
     flow_re = re.compile(FLOW_ID_REGEX)
     if not flow_re.search(flow.id):
         raise FlowIdNamingException(flow.id)
+
+
+def validate_slot_persistence_configuration(flow: Flow) -> None:
+    """Validates that slot persistence configuration is valid.
+
+    Only slots used in either a collect step or a set_slot step can be persisted
+    and the configuration can either be set at the flow level or the collect step level,
+    but not both.
+
+    Args:
+        flow: The flow to validate.
+
+    Raises:
+        DuplicateSlotPersistConfigException: If slot persist config is duplicated.
+    """
+
+    def _is_persist_slots_valid(
+        persist_slots: List[str], flow_slots: Set[str]
+    ) -> ValidationResult:
+        """Validates that the slots that should be persisted are used in the flow."""
+        invalid_slots = set(persist_slots) - flow_slots
+        is_valid = False if invalid_slots else True
+
+        return ValidationResult(is_valid, invalid_slots)
+
+    flow_id = flow.id
+    persist_slots = flow.persisted_slots
+    has_flow_level_persistence = True if persist_slots else False
+    flow_slots = set()
+
+    for step in flow.steps_with_calls_resolved:
+        if isinstance(step, SetSlotsFlowStep):
+            flow_slots.update([slot["key"] for slot in step.slots])
+        elif isinstance(step, CollectInformationFlowStep):
+            flow_slots.add(step.collect)
+            if not step.reset_after_flow_ends:
+                collect_step = step.collect
+                warn_deprecated_collect_step_config(flow_id, collect_step)
+                if has_flow_level_persistence:
+                    raise DuplicateSlotPersistConfigException(flow_id, collect_step)
+
+    if has_flow_level_persistence:
+        result = _is_persist_slots_valid(persist_slots, flow_slots)
+        if not result.is_valid:
+            raise InvalidPersistSlotsException(flow_id, result.invalid_slots)

rasa/shared/core/slots.py

@@ -193,6 +193,11 @@ class Slot(ABC):
         data.update(self.persistence_info())
         return rasa.shared.utils.io.get_dictionary_fingerprint(data)
 
+    def __eq__(self, other: Any) -> bool:
+        if not isinstance(other, Slot):
+            return False
+        return self.name == other.name and self.value == other.value
+
 
 class FloatSlot(Slot):
     """A slot storing a float value."""

rasa/shared/nlu/training_data/features.py

@@ -1,15 +1,133 @@
 from __future__ import annotations
-from typing import Iterable, Union, Text, Optional, List, Any, Tuple, Dict, Set
+
 import itertools
+from dataclasses import dataclass
+from typing import Iterable, Union, Text, Optional, List, Any, Tuple, Dict, Set
 
 import numpy as np
 import scipy.sparse
+from safetensors.numpy import save_file, load_file
 
-import rasa.shared.utils.io
 import rasa.shared.nlu.training_data.util
+import rasa.shared.utils.io
 from rasa.shared.nlu.constants import FEATURE_TYPE_SEQUENCE, FEATURE_TYPE_SENTENCE
 
 
+@dataclass
+class FeatureMetadata:
+    data_type: str
+    attribute: str
+    origin: Union[str, List[str]]
+    is_sparse: bool
+    shape: tuple
+    safetensors_key: str
+
+
+def save_features(
+    features_dict: Dict[Text, List[Features]], file_name: str
+) -> Dict[str, Any]:
+    """Save a dictionary of Features lists to disk using safetensors.
+
+    Args:
+        features_dict: Dictionary mapping strings to lists of Features objects
+        file_name: File to save the features to
+
+    Returns:
+        The metadata to reconstruct the features.
+    """
+    # All tensors are stored in a single safetensors file
+    tensors_to_save = {}
+    # Metadata will be stored separately
+    metadata = {}
+
+    for key, features_list in features_dict.items():
+        feature_metadata_list = []
+
+        for idx, feature in enumerate(features_list):
+            # Create a unique key for this tensor in the safetensors file
+            safetensors_key = f"{key}_{idx}"
+
+            # Convert sparse matrices to dense if needed
+            if feature.is_sparse():
+                # For sparse matrices, use the COO format
+                coo = feature.features.tocoo()  # type:ignore[union-attr]
+                # Save data, row indices and col indices separately
+                tensors_to_save[f"{safetensors_key}_data"] = coo.data
+                tensors_to_save[f"{safetensors_key}_row"] = coo.row
+                tensors_to_save[f"{safetensors_key}_col"] = coo.col
+            else:
+                tensors_to_save[safetensors_key] = feature.features
+
+            # Store metadata
+            metadata_item = FeatureMetadata(
+                data_type=feature.type,
+                attribute=feature.attribute,
+                origin=feature.origin,
+                is_sparse=feature.is_sparse(),
+                shape=feature.features.shape,
+                safetensors_key=safetensors_key,
+            )
+            feature_metadata_list.append(vars(metadata_item))
+
+        metadata[key] = feature_metadata_list
+
+    # Save tensors
+    save_file(tensors_to_save, file_name)
+
+    return metadata
+
+
+def load_features(
+    filename: str, metadata: Dict[str, Any]
+) -> Dict[Text, List[Features]]:
+    """Load Features dictionary from disk.
+
+    Args:
+        filename: File name of the safetensors file.
+        metadata: Metadata to reconstruct the features.
+
+    Returns:
+        Dictionary mapping strings to lists of Features objects
+    """
+    # Load tensors
+    tensors = load_file(filename)
+
+    # Reconstruct the features dictionary
+    features_dict: Dict[Text, List[Features]] = {}
+
+    for key, feature_metadata_list in metadata.items():
+        features_list = []
+
+        for meta in feature_metadata_list:
+            safetensors_key = meta["safetensors_key"]
+
+            if meta["is_sparse"]:
+                # Reconstruct sparse matrix from COO format
+                data = tensors[f"{safetensors_key}_data"]
+                row = tensors[f"{safetensors_key}_row"]
+                col = tensors[f"{safetensors_key}_col"]
+
+                features_matrix = scipy.sparse.coo_matrix(
+                    (data, (row, col)), shape=tuple(meta["shape"])
+                ).tocsr()  # Convert back to CSR format
+            else:
+                features_matrix = tensors[safetensors_key]
+
+            # Reconstruct Features object
+            features = Features(
+                features=features_matrix,
+                feature_type=meta["data_type"],
+                attribute=meta["attribute"],
+                origin=meta["origin"],
+            )
+
+            features_list.append(features)
+
+        features_dict[key] = features_list
+
+    return features_dict
+
+
 class Features:
     """Stores the features produced by any featurizer."""
 

rasa/shared/providers/_configs/azure_openai_client_config.py

@@ -107,8 +107,7 @@ class AzureOpenAIClientConfig:
 
     @classmethod
     def from_dict(cls, config: dict) -> "AzureOpenAIClientConfig":
-        """
-        Initializes a dataclass from the passed config.
+        """Initializes a dataclass from the passed config.
 
         Args:
             config: (dict) The config from which to initialize.
@@ -175,7 +174,10 @@ def is_azure_openai_config(config: dict) -> bool:
 
     # Case: Configuration contains `deployment` key
     # (specific to Azure OpenAI configuration)
-    if config.get(DEPLOYMENT_CONFIG_KEY) is not None:
+    if (
+        config.get(DEPLOYMENT_CONFIG_KEY) is not None
+        and config.get(PROVIDER_CONFIG_KEY) is None
+    ):
         return True
 
     return False