rasa-pro 3.12.0.dev13__py3-none-any.whl → 3.12.0rc2__py3-none-any.whl

rasa/model_manager/socket_bridge.py

@@ -4,6 +4,7 @@ from typing import Any, Dict, Optional
 import structlog
 from socketio import AsyncServer
 from socketio.asyncio_client import AsyncClient
+from socketio.exceptions import ConnectionRefusedError
 
 from rasa.model_manager.runner_service import BotSession
 from rasa.model_manager.studio_jwt_auth import (
@@ -29,7 +30,7 @@ async def socketio_websocket_traffic_wrapper(
 
     if auth_token is None:
         structlogger.error("model_runner.user_no_token", sid=sid)
-        return False
+        raise ConnectionRefusedError("model_runner.user_no_token")
 
     try:
         authenticate_user_to_service(auth_token)
@@ -38,22 +39,22 @@ async def socketio_websocket_traffic_wrapper(
         structlogger.error(
             "model_runner.user_authentication_failed", sid=sid, error=str(error)
         )
-        return False
+        raise ConnectionRefusedError("model_runner.user_authentication_failed")
 
     deployment_id = auth.get("deployment_id") if auth else None
 
     if deployment_id is None:
         structlogger.error("model_runner.bot_no_deployment_id", sid=sid)
-        return False
+        raise ConnectionRefusedError("model_runner.bot_no_deployment_id")
 
     bot = running_bots.get(deployment_id)
     if bot is None:
         structlogger.error("model_runner.bot_not_found", deployment_id=deployment_id)
-        return False
+        raise ConnectionRefusedError("model_runner.bot_not_found")
 
     if not bot.is_alive():
         structlogger.error("model_runner.bot_not_alive", deployment_id=deployment_id)
-        return False
+        raise ConnectionRefusedError("model_runner.bot_not_alive")
 
     client = await create_bridge_client(sio, bot.internal_url, sid, deployment_id)
 
@@ -67,7 +68,7 @@ async def socketio_websocket_traffic_wrapper(
         structlogger.error(
             "model_runner.bot_connection_failed", deployment_id=deployment_id
         )
-        return False
+        raise ConnectionRefusedError("model_runner.bot_connection_failed")
 
 
 def create_bridge_server(sio: AsyncServer, running_bots: Dict[str, BotSession]) -> None:

rasa/shared/constants.py

@@ -83,6 +83,7 @@ ENV_LOG_LEVEL_LLM = "LOG_LEVEL_LLM"
 ENV_LOG_LEVEL_LLM_MODULE_NAMES = {
     "LLMCommandGenerator": "LOG_LEVEL_LLM_COMMAND_GENERATOR",
     "SingleStepLLMCommandGenerator": "LOG_LEVEL_LLM_COMMAND_GENERATOR",
+    "CompactLLMCommandGenerator": "LOG_LEVEL_LLM_COMMAND_GENERATOR",
     "MultiStepLLMCommandGenerator": "LOG_LEVEL_LLM_COMMAND_GENERATOR",
     "EnterpriseSearchPolicy": "LOG_LEVEL_LLM_ENTERPRISE_SEARCH",
     "IntentlessPolicy": "LOG_LEVEL_LLM_INTENTLESS_POLICY",
@@ -106,6 +107,7 @@ CONFIG_NAME_KEY = "name"
 CONFIG_POLICIES_KEY = "policies"
 CONFIG_PIPELINE_KEY = "pipeline"
 CONFIG_LANGUAGE_KEY = "language"
+CONFIG_ADDITIONAL_LANGUAGES_KEY = "additional_languages"
 CONFIG_RECIPE_KEY = "recipe"
 CONFIG_LLM_KEY = "llm"
 CONFIG_MODEL_NAME_KEY = "model_name"
@@ -150,6 +152,8 @@ DEFAULT_MARKERS_CONFIG_PATH = "markers/config"
 DEFAULT_MARKERS_OUTPUT_PATH = "markers/output"
 DEFAULT_MARKERS_STATS_PATH = "markers/stats"
 
+DEFAULT_PROMPT_PACKAGE_NAME = "rasa.dialogue_understanding.generator.prompt_templates"
+
 DIAGNOSTIC_DATA = "diagnostic_data"
 
 RESPONSE_CONDITION = "condition"
@@ -162,6 +166,7 @@ AZURE_AD_TOKEN_ENV_VAR = "AZURE_AD_TOKEN"
 AZURE_API_BASE_ENV_VAR = "AZURE_API_BASE"
 AZURE_API_VERSION_ENV_VAR = "AZURE_API_VERSION"
 AZURE_API_TYPE_ENV_VAR = "AZURE_API_TYPE"
+AZURE_AD_SCOPES_ENV_VAR = "AZURE_AD_SCOPES"
 AZURE_SPEECH_API_KEY_ENV_VAR = "AZURE_SPEECH_API_KEY"
 
 DEEPGRAM_API_KEY_ENV_VAR = "DEEPGRAM_API_KEY"
@@ -198,7 +203,6 @@ MODEL_CONFIG_KEY = "model"
 MODEL_NAME_CONFIG_KEY = "model_name"
 PROMPT_CONFIG_KEY = "prompt"
 PROMPT_TEMPLATE_CONFIG_KEY = "prompt_template"
-
 STREAM_CONFIG_KEY = "stream"
 N_REPHRASES_CONFIG_KEY = "n"
 USE_CHAT_COMPLETIONS_ENDPOINT_CONFIG_KEY = "use_chat_completions_endpoint"
@@ -232,12 +236,6 @@ 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"
-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"
 AWS_ACCESS_KEY_ID_CONFIG_KEY = "aws_access_key_id"
 AWS_SECRET_ACCESS_KEY_CONFIG_KEY = "aws_secret_access_key"
@@ -273,17 +271,11 @@ 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"
-
 VALID_PROVIDERS_FOR_API_TYPE_CONFIG_KEY = [
     OPENAI_PROVIDER,
     AZURE_OPENAI_PROVIDER,
 ]
 
-SELF_HOSTED_VLLM_PREFIX = "hosted_vllm"
-SELF_HOSTED_VLLM_API_KEY_ENV_VAR = "HOSTED_VLLM_API_KEY"
-
 AZURE_API_TYPE = "azure"
 OPENAI_API_TYPE = "openai"
 
@@ -329,3 +321,13 @@ BUTTONS = "buttons"
 ATTACHMENT = "attachment"
 IMAGE = "image"
 CUSTOM = "custom"
+TITLE = "title"
+PAYLOAD = "payload"
+
+# Used for LLM command generation
+ROLE_USER = "user"
+ROLE_SYSTEM = "system"
+
+# Used for key values in ValidateSlotPatternFlowStackFrame
+REFILL_UTTER = "refill_utter"
+REJECTIONS = "rejections"

rasa/shared/core/constants.py

@@ -13,6 +13,7 @@ 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"
+LANGUAGE_SLOT = "language"
 
 DEFAULT_INTENTS = [
     USER_INTENT_RESTART,
@@ -145,6 +146,7 @@ KEY_MAPPING_TYPE = "type"
 KEY_ALLOW_NLU_CORRECTION = "allow_nlu_correction"
 KEY_ACTION = "action"
 KEY_RUN_ACTION_EVERY_TURN = "run_action_every_turn"
+KEY_COEXISTENCE_SYSTEM = "coexistence_system"
 
 
 class SlotMappingType(Enum):

rasa/shared/core/flows/constants.py

@@ -0,0 +1,11 @@
+KEY_ID = "id"
+KEY_STEPS = "steps"
+KEY_NAME = "name"
+KEY_DESCRIPTION = "description"
+KEY_IF = "if"
+KEY_ALWAYS_INCLUDE_IN_PROMPT = "always_include_in_prompt"
+KEY_NLU_TRIGGER = "nlu_trigger"
+KEY_FILE_PATH = "file_path"
+KEY_PERSISTED_SLOTS = "persisted_slots"
+KEY_RUN_PATTERN_COMPLETED = "run_pattern_completed"
+KEY_TRANSLATION = "translation"

rasa/shared/core/flows/flow.py

@@ -7,14 +7,29 @@ from pathlib import Path
 from typing import Any, Dict, List, Optional, Set, Text, Union
 
 import structlog
+from pydantic import BaseModel
 from pypred import Predicate
 
 import rasa.shared.utils.io
+from rasa.engine.language import Language
 from rasa.shared.constants import RASA_DEFAULT_FLOW_PATTERN_PREFIX
 from rasa.shared.core.constants import (
     KEY_ASK_CONFIRM_DIGRESSIONS,
     KEY_BLOCK_DIGRESSIONS,
 )
+from rasa.shared.core.flows.constants import (
+    KEY_ALWAYS_INCLUDE_IN_PROMPT,
+    KEY_DESCRIPTION,
+    KEY_FILE_PATH,
+    KEY_ID,
+    KEY_IF,
+    KEY_NAME,
+    KEY_NLU_TRIGGER,
+    KEY_PERSISTED_SLOTS,
+    KEY_RUN_PATTERN_COMPLETED,
+    KEY_STEPS,
+    KEY_TRANSLATION,
+)
 from rasa.shared.core.flows.flow_path import FlowPath, FlowPathsList, PathNode
 from rasa.shared.core.flows.flow_step import FlowStep
 from rasa.shared.core.flows.flow_step_links import (
@@ -43,6 +58,16 @@ from rasa.shared.core.slots import Slot
 structlogger = structlog.get_logger()
 
 
+class FlowLanguageTranslation(BaseModel):
+    """Represents the translation of the flow properties in a specific language."""
+
+    name: str
+    """The human-readable name of the flow."""
+
+    class Config:
+        extra = "ignore"
+
+
 @dataclass
 class Flow:
     """Represents the configuration of a flow."""
@@ -53,6 +78,8 @@ class Flow:
     """The human-readable name of the flow."""
     description: Optional[Text] = None
     """The description of the flow."""
+    translation: Dict[Text, FlowLanguageTranslation] = field(default_factory=dict)
+    """The translation of the flow properties in different languages."""
     guard_condition: Optional[Text] = None
     """The condition that needs to be fulfilled for the flow to be startable."""
     step_sequence: FlowStepSequence = field(default_factory=FlowStepSequence.empty)
@@ -71,6 +98,8 @@ class Flow:
     """The flow ids for which the assistant should ask for confirmation."""
     block_digressions: List[str] = field(default_factory=list)
     """The flow ids that the assistant should block from digressing to."""
+    run_pattern_completed: bool = True
+    """Whether the pattern_completed flow should be run after the flow ends."""
 
     @staticmethod
     def from_json(
@@ -88,6 +117,8 @@ class Flow:
         Returns:
             A Flow object.
         """
+        from rasa.shared.core.flows.utils import extract_translations
+
         step_sequence = FlowStepSequence.from_json(flow_id, data.get("steps"))
         nlu_triggers = NLUTriggers.from_json(data.get("nlu_trigger"))
 
@@ -96,21 +127,25 @@ class Flow:
 
         return Flow(
             id=flow_id,
-            custom_name=data.get("name"),
-            description=data.get("description"),
-            always_include_in_prompt=data.get("always_include_in_prompt"),
-            # str or bool are permitted in the flow schema but internally we want a str
-            guard_condition=str(data["if"]) if "if" in data else None,
+            custom_name=data.get(KEY_NAME),
+            description=data.get(KEY_DESCRIPTION),
+            always_include_in_prompt=data.get(KEY_ALWAYS_INCLUDE_IN_PROMPT),
+            # str or bool are permitted in the flow schema, but internally we want a str
+            guard_condition=str(data[KEY_IF]) if KEY_IF in data else None,
             step_sequence=Flow.resolve_default_ids(step_sequence),
             nlu_triggers=nlu_triggers,
             # 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", []),
+            file_path=data.get(KEY_FILE_PATH) if KEY_FILE_PATH in data else file_path,
+            persisted_slots=data.get(KEY_PERSISTED_SLOTS, []),
             ask_confirm_digressions=extract_digression_prop(
                 KEY_ASK_CONFIRM_DIGRESSIONS, data
             ),
             block_digressions=extract_digression_prop(KEY_BLOCK_DIGRESSIONS, data),
+            run_pattern_completed=data.get(KEY_RUN_PATTERN_COMPLETED, True),
+            translation=extract_translations(
+                translation_data=data.get(KEY_TRANSLATION, {})
+            ),
         )
 
     def get_full_name(self) -> str:
@@ -168,33 +203,62 @@ class Flow:
             The Flow object as serialized data.
         """
         data: Dict[Text, Any] = {
-            "id": self.id,
-            "steps": self.step_sequence.as_json(),
+            KEY_ID: self.id,
+            KEY_STEPS: self.step_sequence.as_json(),
         }
         if self.custom_name is not None:
-            data["name"] = self.custom_name
+            data[KEY_NAME] = self.custom_name
         if self.description is not None:
-            data["description"] = self.description
+            data[KEY_DESCRIPTION] = self.description
         if self.guard_condition is not None:
-            data["if"] = self.guard_condition
+            data[KEY_IF] = self.guard_condition
         if self.always_include_in_prompt is not None:
-            data["always_include_in_prompt"] = self.always_include_in_prompt
+            data[KEY_ALWAYS_INCLUDE_IN_PROMPT] = self.always_include_in_prompt
         if self.nlu_triggers:
-            data["nlu_trigger"] = self.nlu_triggers.as_json()
+            data[KEY_NLU_TRIGGER] = self.nlu_triggers.as_json()
         if self.file_path:
-            data["file_path"] = self.file_path
+            data[KEY_FILE_PATH] = self.file_path
         if self.persisted_slots:
-            data["persisted_slots"] = self.persisted_slots
+            data[KEY_PERSISTED_SLOTS] = self.persisted_slots
         if self.ask_confirm_digressions:
             data[KEY_ASK_CONFIRM_DIGRESSIONS] = self.ask_confirm_digressions
         if self.block_digressions:
             data[KEY_BLOCK_DIGRESSIONS] = self.block_digressions
+        if self.run_pattern_completed is not None:
+            data["run_pattern_completed"] = self.run_pattern_completed
+        if self.translation:
+            data[KEY_TRANSLATION] = {
+                language_code: translation.dict()
+                for language_code, translation in self.translation.items()
+            }
 
         return data
 
-    def readable_name(self) -> str:
-        """Returns the name of the flow or its id if no name is set."""
-        return self.name or self.id
+    def localized_name(self, language: Optional[Language] = None) -> Optional[Text]:
+        """Returns the language specific flow name or None.
+
+        Args:
+            language: Preferred language code.
+
+        Returns:
+            Flow name in the specified language or None.
+        """
+        language_code = language.code if language else None
+        translation = self.translation.get(language_code)
+        return translation.name if translation else None
+
+    def readable_name(self, language: Optional[Language] = None) -> str:
+        """
+        Returns the flow's name in the specified language if available; otherwise
+        falls back to the flow's name, and finally the flow's ID.
+
+        Args:
+            language: Preferred language code.
+
+        Returns:
+            string: the localized name, the default name, or the flow's ID.
+        """
+        return self.localized_name(language) or self.name or self.id
 
     def step_by_id(self, step_id: Optional[Text]) -> Optional[FlowStep]:
         """Returns the step with the given id."""

rasa/shared/core/flows/flows_yaml_schema.json

@@ -288,9 +288,37 @@
             "additionalProperties": false,
             "schema_name": "dictionary with flow properties",
             "properties": {
+                "name": {
+                    "type": "string"
+                },
                 "description": {
                     "type": "string"
                 },
+                "translation": {
+                    "type": "object",
+                    "schema_name": "flow translation mapping",
+                    "properties": {
+                        "metadata": {
+                            "type": "object"
+                        }
+                    },
+                    "patternProperties": {
+                        "^(?!metadata$).+": {
+                            "type": "object",
+                            "additionalProperties": false,
+                            "required": [
+                                "name"
+                            ],
+                            "properties": {
+                                "name": {
+                                    "type": "string"
+                                },
+                                "metadata": {}
+                            }
+                        }
+                    },
+                    "additionalProperties": false
+                },
                 "if": {
                     "type": [
                         "string",
@@ -300,9 +328,6 @@
                 "always_include_in_prompt": {
                     "type": "boolean"
                 },
-                "name": {
-                    "type": "string"
-                },
                 "nlu_trigger": {
                     "$ref": "#/$defs/nlu_trigger"
                 },
@@ -320,6 +345,9 @@
                 },
                 "block_digressions": {
                     "$ref": "#/$defs/block_digressions"
+                },
+                "run_pattern_completed": {
+                    "type": "boolean"
                 }
             }
         },

rasa/shared/core/flows/steps/collect.py

@@ -10,42 +10,7 @@ from rasa.shared.core.constants import (
 )
 from rasa.shared.core.flows.flow_step import FlowStep
 from rasa.shared.core.flows.utils import extract_digression_prop
-
-
-@dataclass
-class SlotRejection:
-    """A pair of validation condition and an utterance for the case of failure."""
-
-    if_: str
-    """The condition that should be checked."""
-    utter: str
-    """The utterance that should be executed if the condition is met."""
-
-    @staticmethod
-    def from_dict(data: Dict[str, Any]) -> SlotRejection:
-        """Create a SlotRejection object from serialized data.
-
-        Args:
-            data: data for a SlotRejection object in a serialized format
-
-        Returns:
-            A SlotRejection object
-        """
-        return SlotRejection(
-            if_=data["if"],
-            utter=data["utter"],
-        )
-
-    def as_dict(self) -> Dict[str, Any]:
-        """Serialize the SlotRejection object.
-
-        Returns:
-            the SlotRejection object as serialized data
-        """
-        return {
-            "if": self.if_,
-            "utter": self.utter,
-        }
+from rasa.shared.core.slots import SlotRejection
 
 
 @dataclass

rasa/shared/core/flows/utils.py

@@ -1,17 +1,21 @@
-from typing import Any, Dict, List, Set
+from typing import TYPE_CHECKING, Any, Dict, List, Set, Text
 
 from rasa.shared.utils.io import raise_deprecation_warning
 
+if TYPE_CHECKING:
+    from rasa.shared.core.flows.flow import FlowLanguageTranslation
+
+
 RESET_PROPERTY_NAME = "reset_after_flow_ends"
 PERSIST_PROPERTY_NAME = "persisted_slots"
 ALL_LABEL = "ALL"
 
 
-def warn_deprecated_collect_step_config(flow_id: str, collect_step: str) -> None:
+def warn_deprecated_collect_step_config() -> 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"Configuring '{RESET_PROPERTY_NAME}' in collect steps is "
+        f"deprecated and will be removed in Rasa Pro 4.0.0. In the parent flow, "
         f"please use the '{PERSIST_PROPERTY_NAME}' "
         "property at the flow level instead."
     )
@@ -53,3 +57,23 @@ def extract_digression_prop(prop: str, data: Dict[str, Any]) -> List[str]:
         digression_property = [ALL_LABEL] if digression_property else []
 
     return digression_property
+
+
+def extract_translations(
+    translation_data: Dict[Text, Any],
+) -> Dict[Text, "FlowLanguageTranslation"]:
+    """Extracts translations from a dictionary.
+
+    Args:
+        translation_data: The dictionary containing the translations.
+
+    Returns:
+        A dictionary containing the extracted translations.
+    """
+    from rasa.shared.core.flows.flow import FlowLanguageTranslation
+
+    return {
+        language_code: FlowLanguageTranslation.parse_obj({**data})
+        for language_code, data in translation_data.items()
+        if language_code != "metadata"
+    }

rasa/shared/core/flows/validation.py

@@ -723,7 +723,7 @@ def validate_slot_persistence_configuration(flow: Flow) -> None:
             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)
+                warn_deprecated_collect_step_config()
                 if has_flow_level_persistence:
                     raise DuplicateSlotPersistConfigException(flow_id, collect_step)