rasa-pro 3.11.8__py3-none-any.whl → 3.11.10__py3-none-any.whl

rasa/core/channels/voice_ready/audiocodes.py

@@ -139,6 +139,12 @@ class Conversation:
                 structlogger.warning(
                     "audiocodes.handle.activities.duplicate_activity",
                     activity_id=activity[ACTIVITY_ID_KEY],
+                    event_info=(
+                        "Audiocodes might send duplicate activities if the bot has not "
+                        "responded to the previous one or responded too late. Please "
+                        "consider enabling the `use_websocket` option to use"
+                        " Audiocodes Asynchronous API."
+                    ),
                 )
                 continue
             self.activity_ids.append(activity[ACTIVITY_ID_KEY])
@@ -390,30 +396,41 @@ class AudiocodesInput(InputChannel):
                     "audiocodes.on_activities.no_conversation", request=request.json
                 )
                 return response.json({})
-            elif conversation.ws:
+
+            if self.use_websocket:
+                # send an empty response for this request
+                # activities are processed in the background
+                # chat response is sent via the websocket
                 ac_output: Union[WebsocketOutput, AudiocodesOutput] = WebsocketOutput(
                     conversation.ws, conversation_id
                 )
-                response_json = {}
-            else:
-                # handle non websocket case where messages get returned in json
-                ac_output = AudiocodesOutput()
-                response_json = {
+                self._create_task(
+                    conversation_id,
+                    conversation.handle_activities(
+                        request.json,
+                        input_channel_name=self.name(),
+                        output_channel=ac_output,
+                        on_new_message=on_new_message,
+                    ),
+                )
+                return response.json({})
+
+            # without websockets, this becomes a blocking call
+            # and the response is sent back to the Audiocodes server
+            # after the activities are processed
+            ac_output = AudiocodesOutput()
+            await conversation.handle_activities(
+                request.json,
+                input_channel_name=self.name(),
+                output_channel=ac_output,
+                on_new_message=on_new_message,
+            )
+            return response.json(
+                {
                     "conversation": conversation_id,
                     "activities": ac_output.messages,
                 }
-
-            # start a background task to handle activities
-            self._create_task(
-                conversation_id,
-                conversation.handle_activities(
-                    request.json,
-                    input_channel_name=self.name(),
-                    output_channel=ac_output,
-                    on_new_message=on_new_message,
-                ),
             )
-            return response.json(response_json)
 
         @ac_webhook.route(
             "/conversation/<conversation_id>/disconnect", methods=["POST"]

rasa/shared/constants.py

@@ -220,6 +220,7 @@ EXTRA_PARAMETERS_KEY = "extra_parameters"
 MODEL_GROUP_ID_KEY = "model_group_id"
 MODEL_LIST_KEY = "model_list"
 LITELLM_PARAMS_KEY = "litellm_params"
+_VALIDATE_ENVIRONMENT_MISSING_KEYS_KEY = "missing_keys"
 
 LLM_API_HEALTH_CHECK_ENV_VAR = "LLM_API_HEALTH_CHECK"
 LLM_API_HEALTH_CHECK_DEFAULT_VALUE = "false"

rasa/shared/core/flows/flow.py

@@ -22,10 +22,11 @@ from rasa.shared.core.flows.flow_step_links import (
 from rasa.shared.core.flows.flow_step_sequence import FlowStepSequence
 from rasa.shared.core.flows.nlu_trigger import NLUTriggers
 from rasa.shared.core.flows.steps import (
+    ActionFlowStep,
+    CallFlowStep,
     CollectInformationFlowStep,
     EndFlowStep,
     StartFlowStep,
-    ActionFlowStep,
 )
 from rasa.shared.core.flows.steps.constants import (
     CONTINUE_STEP_PREFIX,
@@ -402,161 +403,156 @@ class Flow:
         and a set of visited step IDs to prevent revisiting steps.
         It calls `go_over_steps` to recursively explore and fill the paths list.
         """
-        flow_paths_list = FlowPathsList(self.id, paths=[])
-        steps: List[FlowStep] = self.steps
+        all_paths = FlowPathsList(self.id, paths=[])
+        start_step: FlowStep = self.first_step_in_flow()
         current_path: FlowPath = FlowPath(flow=self.id, nodes=[])
-        step_ids_visited: Set[str] = set()
-
-        self._go_over_steps(steps, current_path, flow_paths_list, step_ids_visited)
+        visited_step_ids: Set[str] = set()
 
-        if not flow_paths_list.is_path_part_of_list(current_path):
-            flow_paths_list.paths.append(copy.deepcopy(current_path))
+        self._go_over_steps(start_step, current_path, all_paths, visited_step_ids)
 
         structlogger.debug(
             "shared.core.flows.flow.extract_all_paths",
             comment="Extraction complete",
-            number_of_paths=len(flow_paths_list.paths),
+            number_of_paths=len(all_paths.paths),
             flow_name=self.name,
         )
-        return flow_paths_list
+        return all_paths
 
     def _go_over_steps(
         self,
-        steps_to_go: Union[str, List[FlowStep]],
+        current_step: FlowStep,
         current_path: FlowPath,
-        completed_paths: FlowPathsList,
-        step_ids_visited: Set[str],
+        all_paths: FlowPathsList,
+        visited_step_ids: Set[str],
     ) -> None:
         """Processes the flow steps recursively.
 
-        Either following direct step IDs or handling conditions, and adds complete
-        paths to the collected_paths.
-
         Args:
-            steps_to_go: Either a direct step ID or a list of steps to process.
+            current_step: The current step being processed.
             current_path: The current path being constructed.
-            completed_paths: The list where completed paths are added.
-            step_ids_visited: A set of step IDs that have been visited to avoid cycles.
+            all_paths: The list where completed paths are added.
+            visited_step_ids: A set of steps that have been visited to avoid cycles.
 
         Returns:
-            None: This function modifies collected_paths in place by appending new paths
+            None: This function modifies all_paths in place by appending new paths
             as they are found.
         """
-        # Case 1: If the steps_to_go is a custom_id string
-        # This happens when a "next" of, for example, a IfFlowStepLink is targeting
-        # a specific step by id
-        if isinstance(steps_to_go, str):
-            for i, step in enumerate(self.steps):
-                # We don't need to check for 'id' as a link can only happen to a
-                # custom id.
-                if step.custom_id == steps_to_go:
-                    self._go_over_steps(
-                        self.steps[i:], current_path, completed_paths, step_ids_visited
-                    )
-
-        # Case 2: If steps_to_go is a list of steps
-        else:
-            for i, step in enumerate(steps_to_go):
-                # 1. Check if the step is relevant for testable_paths extraction.
-                # We only create new path nodes for ActionFlowStep and
-                # CollectInformationFlowStep because these are externally visible
-                # changes in the assistant's behaviour (trackable in the e2e tests).
-                # For other flow steps, we only follow their links.
-                # We decided to ignore calls to other flows in our coverage analysis.
-                if not isinstance(step, (CollectInformationFlowStep, ActionFlowStep)):
-                    self._handle_links(
-                        step.next.links,
-                        current_path,
-                        completed_paths,
-                        step_ids_visited,
-                    )
-                    continue
-
-                # 2. Check if already visited this custom step id
-                # in order to keep track of loops
-                if step.custom_id is not None and step.custom_id in step_ids_visited:
-                    if not completed_paths.is_path_part_of_list(current_path):
-                        completed_paths.paths.append(copy.deepcopy(current_path))
-                    return  # Stop traversing this path if we've revisited a step
-                elif step.custom_id is not None:
-                    step_ids_visited.add(step.custom_id)
-
-                # 3. Append step info to the path
-                current_path.nodes.append(
-                    PathNode(
-                        flow=current_path.flow,
-                        step_id=step.id,
-                        lines=step.metadata["line_numbers"],
-                    )
+        # Check if the step is relevant for testable_paths extraction.
+        # We only create new path nodes for ActionFlowStep, CallFlowStep and
+        # CollectInformationFlowStep because these are externally visible
+        # changes in the assistant's behaviour (trackable in the e2e tests).
+        # For other flow steps, we only follow their links.
+        # We decided to ignore calls to other flows in our coverage analysis.
+        should_add_node = isinstance(
+            current_step, (CollectInformationFlowStep, ActionFlowStep, CallFlowStep)
+        )
+        if should_add_node:
+            # Add current step to the current path that is being constructed.
+            current_path.nodes.append(
+                PathNode(
+                    flow=current_path.flow,
+                    step_id=current_step.id,
+                    lines=current_step.metadata["line_numbers"],
                 )
+            )
 
-                # 4. Check if 'END' branch
-                if (
-                    len(step.next.links) == 1
-                    and isinstance(step.next.links[0], StaticFlowStepLink)
-                    and step.next.links[0].target == END_STEP
-                ):
-                    if not completed_paths.is_path_part_of_list(current_path):
-                        completed_paths.paths.append(copy.deepcopy(current_path))
-                    return
-                else:
-                    self._handle_links(
-                        step.next.links,
-                        current_path,
-                        completed_paths,
-                        step_ids_visited,
-                    )
+        if current_step.id in visited_step_ids or self.is_end_of_path(current_step):
+            # Found a cycle, or reached an end step, do not proceed further.
+            all_paths.paths.append(copy.deepcopy(current_path))
+            # Remove the last node from the path if it was added.
+            if should_add_node:
+                current_path.nodes.pop()
+            return
+
+        # Mark current step as visited in this path.
+        visited_step_ids.add(current_step.id)
+
+        # Iterate over all links of the current step.
+        for link in current_step.next.links:
+            self._handle_link(
+                current_path,
+                all_paths,
+                visited_step_ids,
+                link,
+            )
 
-    def _handle_links(
+        # Backtrack the current step and remove it from the path.
+        visited_step_ids.remove(current_step.id)
+
+        # Remove the last node from the path if it was added.
+        if should_add_node:
+            current_path.nodes.pop()
+
+    def _handle_link(
         self,
-        links: List[FlowStepLink],
-        path: FlowPath,
-        collected_paths: FlowPathsList,
-        step_ids_visited: set,
+        current_path: FlowPath,
+        all_paths: FlowPathsList,
+        visited_step_ids: Set[str],
+        link: FlowStepLink,
     ) -> None:
-        """Processes the next step in a flow.
-
-        Potentially recursively calling itself to handle conditional paths and
-        branching.
+        """Handles the next step in a flow.
 
         Args:
-            links: Links listed in the "next" attribute.
-            path: The current path taken in the flow.
-            collected_paths: A list of paths collected so far.
-            step_ids_visited: A set of step IDs that have already been visited
-                to avoid loops.
+            current_path: The current path being constructed.
+            all_paths: The list where completed paths are added.
+            visited_step_ids: A set of steps that have been visited to avoid cycles.
+            link: The link to be followed.
 
         Returns:
-            None: Modifies collected_paths in place by appending new paths
-            as they are completed.
+            None: This function modifies all_paths in place by appending new paths
+            as they are found.
         """
-        steps = self.steps
-
-        for link in links:
-            # Direct step id reference
-            if isinstance(link, StaticFlowStepLink):
-                # Find this id in the flow steps and restart from there
-                for i, step in enumerate(steps):
-                    if step.id == link.target_step_id:
-                        self._go_over_steps(
-                            steps[i:],
-                            copy.deepcopy(path),
-                            collected_paths,
-                            copy.deepcopy(step_ids_visited),
-                        )
-
-            # If conditions
-            elif isinstance(link, (IfFlowStepLink, ElseFlowStepLink)):
-                # Handling conditional paths
-                target_steps: Union[str, List[FlowStep]]
-                if isinstance(link.target_reference, FlowStepSequence):
-                    target_steps = link.target_reference.child_steps
-                else:
-                    target_steps = link.target_reference
-
+        # StaticFlowStepLink is a direct link to the next step.
+        if isinstance(link, StaticFlowStepLink):
+            # Find the step by its id and continue the path.
+            if step := self._get_step_by_step_id(link.target_step_id):
                 self._go_over_steps(
-                    target_steps,
-                    copy.deepcopy(path),
-                    collected_paths,
-                    copy.deepcopy(step_ids_visited),
+                    step,
+                    current_path,
+                    all_paths,
+                    visited_step_ids,
                 )
+                return
+        # IfFlowStepLink and ElseFlowStepLink are conditional links.
+        elif isinstance(link, (IfFlowStepLink, ElseFlowStepLink)):
+            if isinstance(link.target_reference, FlowStepSequence):
+                # If the target is a FlowStepSequence, we need to go over all
+                # child steps of the sequence.
+                for child_step in link.target_reference.child_steps:
+                    self._go_over_steps(
+                        child_step,
+                        current_path,
+                        all_paths,
+                        visited_step_ids,
+                    )
+                return
+            else:
+                # Find the step by its id and continue the path.
+                if step := self._get_step_by_step_id(link.target_reference):
+                    self._go_over_steps(
+                        step,
+                        current_path,
+                        all_paths,
+                        visited_step_ids,
+                    )
+                    return
+
+    def is_end_of_path(self, step: FlowStep) -> bool:
+        """Check if there is no path available from the current step."""
+        if (
+            len(step.next.links) == 1
+            and isinstance(step.next.links[0], StaticFlowStepLink)
+            and step.next.links[0].target == END_STEP
+        ):
+            return True
+        return False
+
+    def _get_step_by_step_id(
+        self,
+        step_id: Optional[str],
+    ) -> Optional[FlowStep]:
+        """Get a step by its id from a list of steps."""
+        for step in self.steps:
+            if step.id == step_id:
+                return step
+        return None

rasa/shared/providers/_utils.py

@@ -1,3 +1,5 @@
+from typing import Optional, Dict, Any
+
 import structlog
 
 from rasa.shared.constants import (
@@ -9,6 +11,11 @@ from rasa.shared.constants import (
     AWS_REGION_NAME_CONFIG_KEY,
     AWS_SESSION_TOKEN_CONFIG_KEY,
     AWS_SESSION_TOKEN_ENV_VAR,
+    AZURE_API_BASE_ENV_VAR,
+    API_BASE_CONFIG_KEY,
+    AZURE_API_VERSION_ENV_VAR,
+    API_VERSION_CONFIG_KEY,
+    DEPLOYMENT_CONFIG_KEY,
 )
 from rasa.shared.exceptions import ProviderClientValidationError
 from litellm import validate_environment
@@ -77,3 +84,80 @@ def validate_aws_setup_for_litellm_clients(
             missing_environment_variables=missing_environment_variables,
         )
         raise ProviderClientValidationError(event_info)
+
+
+def validate_azure_client_setup(
+    api_base: Optional[str],
+    api_version: Optional[str],
+    deployment: Optional[str],
+) -> None:
+    """Validates the Azure setup for LiteLLM Router clients to ensure
+     that all required configuration parameters are set.
+
+    Raises:
+        ProviderClientValidationError: If any required Azure configurations
+            is missing.
+    """
+
+    def generate_event_info_for_missing_setting(
+        setting: str,
+        setting_env_var: Optional[str] = None,
+        setting_config_key: Optional[str] = None,
+    ) -> str:
+        """Generate a part of the message with instructions on what to set
+        for the missing client setting.
+        """
+        info = "Set {setting} with {options}. "
+        options = ""
+        if setting_env_var is not None:
+            options += f"environment variable '{setting_env_var}'"
+        if setting_config_key is not None and setting_env_var is not None:
+            options += " or "
+        if setting_config_key is not None:
+            options += f"config key '{setting_config_key}'"
+
+        return info.format(setting=setting, options=options)
+
+    # All required settings for Azure OpenAI client
+    settings: Dict[str, Dict[str, Any]] = {
+        "API Base": {
+            "current_value": api_base,
+            "env_var": AZURE_API_BASE_ENV_VAR,
+            "config_key": API_BASE_CONFIG_KEY,
+        },
+        "API Version": {
+            "current_value": api_version,
+            "env_var": AZURE_API_VERSION_ENV_VAR,
+            "config_key": API_VERSION_CONFIG_KEY,
+        },
+        "Deployment Name": {
+            "current_value": deployment,
+            "env_var": None,
+            "config_key": DEPLOYMENT_CONFIG_KEY,
+        },
+    }
+
+    missing_settings = [
+        setting_name
+        for setting_name, setting_info in settings.items()
+        if setting_info["current_value"] is None
+    ]
+
+    if missing_settings:
+        event_info = f"Client settings not set: " f"{', '.join(missing_settings)}. "
+
+        for missing_setting in missing_settings:
+            if settings[missing_setting]["current_value"] is not None:
+                continue
+            event_info += generate_event_info_for_missing_setting(
+                missing_setting,
+                settings[missing_setting]["env_var"],
+                settings[missing_setting]["config_key"],
+            )
+
+        structlogger.error(
+            "azure_openai_llm_client.not_configured",
+            event_info=event_info,
+            missing_settings=missing_settings,
+        )
+        raise ProviderClientValidationError(event_info)

rasa/shared/providers/llm/_base_litellm_client.py

@@ -9,7 +9,11 @@ from litellm import (
     validate_environment,
 )
 
-from rasa.shared.constants import API_BASE_CONFIG_KEY, API_KEY
+from rasa.shared.constants import (
+    API_BASE_CONFIG_KEY,
+    API_KEY,
+    _VALIDATE_ENVIRONMENT_MISSING_KEYS_KEY,
+)
 from rasa.shared.exceptions import (
     ProviderClientAPIException,
     ProviderClientValidationError,
@@ -23,8 +27,6 @@ from rasa.shared.utils.io import suppress_logs, resolve_environment_variables
 
 structlogger = structlog.get_logger()
 
-_VALIDATE_ENVIRONMENT_MISSING_KEYS_KEY = "missing_keys"
-
 # Suppress LiteLLM info and debug logs - Global level.
 logging.getLogger("LiteLLM").setLevel(logging.WARNING)
 

rasa/shared/providers/llm/azure_openai_llm_client.py

@@ -9,9 +9,6 @@ from rasa.shared.constants import (
     OPENAI_API_VERSION_ENV_VAR,
     AZURE_API_BASE_ENV_VAR,
     AZURE_API_VERSION_ENV_VAR,
-    API_BASE_CONFIG_KEY,
-    API_VERSION_CONFIG_KEY,
-    DEPLOYMENT_CONFIG_KEY,
     AZURE_API_KEY_ENV_VAR,
     OPENAI_API_TYPE_ENV_VAR,
     OPENAI_API_KEY_ENV_VAR,
@@ -23,6 +20,7 @@ from rasa.shared.exceptions import ProviderClientValidationError
 from rasa.shared.providers._configs.azure_openai_client_config import (
     AzureOpenAIClientConfig,
 )
+from rasa.shared.providers._utils import validate_azure_client_setup
 from rasa.shared.providers.llm._base_litellm_client import _BaseLiteLLMClient
 from rasa.shared.utils.io import raise_deprecation_warning
 
@@ -295,65 +293,8 @@ class AzureOpenAILLMClient(_BaseLiteLLMClient):
     def validate_client_setup(self) -> None:
         """Validates that all required configuration parameters are set."""
 
-        def generate_event_info_for_missing_setting(
-            setting: str,
-            setting_env_var: Optional[str] = None,
-            setting_config_key: Optional[str] = None,
-        ) -> str:
-            """Generate a part of the message with instructions on what to set
-            for the missing client setting.
-            """
-            info = "Set {setting} with {options}. "
-            options = ""
-            if setting_env_var is not None:
-                options += f"environment variable '{setting_env_var}'"
-            if setting_config_key is not None and setting_env_var is not None:
-                options += " or "
-            if setting_config_key is not None:
-                options += f"config key '{setting_config_key}'"
-
-            return info.format(setting=setting, options=options)
-
-        # All required settings for Azure OpenAI client
-        settings: Dict[str, Dict[str, Any]] = {
-            "API Base": {
-                "current_value": self.api_base,
-                "env_var": AZURE_API_BASE_ENV_VAR,
-                "config_key": API_BASE_CONFIG_KEY,
-            },
-            "API Version": {
-                "current_value": self.api_version,
-                "env_var": AZURE_API_VERSION_ENV_VAR,
-                "config_key": API_VERSION_CONFIG_KEY,
-            },
-            "Deployment Name": {
-                "current_value": self.deployment,
-                "env_var": None,
-                "config_key": DEPLOYMENT_CONFIG_KEY,
-            },
-        }
-
-        missing_settings = [
-            setting_name
-            for setting_name, setting_info in settings.items()
-            if setting_info["current_value"] is None
-        ]
-
-        if missing_settings:
-            event_info = f"Client settings not set: " f"{', '.join(missing_settings)}. "
-
-            for missing_setting in missing_settings:
-                if settings[missing_setting]["current_value"] is not None:
-                    continue
-                event_info += generate_event_info_for_missing_setting(
-                    missing_setting,
-                    settings[missing_setting]["env_var"],
-                    settings[missing_setting]["config_key"],
-                )
-
-            structlogger.error(
-                "azure_openai_llm_client.not_configured",
-                event_info=event_info,
-                missing_settings=missing_settings,
-            )
-            raise ProviderClientValidationError(event_info)
+        return validate_azure_client_setup(
+            api_base=self.api_base,
+            api_version=self.api_version,
+            deployment=self.deployment,
+        )

rasa/shared/providers/router/_base_litellm_router_client.py

@@ -2,7 +2,7 @@ from typing import Any, Dict, List
 import os
 import structlog
 
-from litellm import Router
+from litellm import Router, validate_environment
 
 from rasa.shared.constants import (
     MODEL_LIST_KEY,
@@ -14,11 +14,18 @@ from rasa.shared.constants import (
     API_KEY,
     MODEL_CONFIG_KEY,
     USE_CHAT_COMPLETIONS_ENDPOINT_CONFIG_KEY,
+    API_BASE_CONFIG_KEY,
+    _VALIDATE_ENVIRONMENT_MISSING_KEYS_KEY,
+    AZURE_OPENAI_PROVIDER,
+    API_VERSION_CONFIG_KEY,
+    AZURE_API_BASE_ENV_VAR,
+    AZURE_API_VERSION_ENV_VAR,
 )
 from rasa.shared.exceptions import ProviderClientValidationError
 from rasa.shared.providers._configs.litellm_router_client_config import (
     LiteLLMRouterClientConfig,
 )
+from rasa.shared.providers._utils import validate_azure_client_setup
 from rasa.shared.utils.io import resolve_environment_variables
 
 structlogger = structlog.get_logger()
@@ -62,6 +69,7 @@ class _BaseLiteLLMRouterClient:
             resolved_model_configurations = (
                 self._resolve_env_vars_in_model_configurations()
             )
+            self._validate_model_configurations(resolved_model_configurations)
             self._router_client = Router(
                 model_list=resolved_model_configurations, **router_settings
             )
@@ -181,3 +189,49 @@ class _BaseLiteLLMRouterClient:
             )
             model_configuration_with_resolved_keys.append(resolved_model_configuration)
         return model_configuration_with_resolved_keys
+
+    def _validate_model_configurations(
+        self, resolved_model_configurations: List[Dict[str, Any]]
+    ) -> None:
+        """Validates the model configurations.
+
+        Args:
+            resolved_model_configurations: (List[Dict[str, Any]]) The list of model
+                configurations with resolved environment variables.
+
+        Raises:
+            ProviderClientValidationError: If the model configurations are invalid.
+        """
+        for model_configuration in resolved_model_configurations:
+            litellm_params = model_configuration.get(LITELLM_PARAMS_KEY, {})
+
+            model = litellm_params.get(MODEL_CONFIG_KEY)
+            provider, deployment = model.split("/", 1)
+            api_base = litellm_params.get(API_BASE_CONFIG_KEY)
+
+            if provider.lower() == AZURE_OPENAI_PROVIDER:
+                validate_azure_client_setup(
+                    api_base=api_base or os.getenv(AZURE_API_BASE_ENV_VAR),
+                    api_version=litellm_params.get(API_VERSION_CONFIG_KEY)
+                    or os.getenv(AZURE_API_VERSION_ENV_VAR),
+                    deployment=deployment,
+                )
+            else:
+                validation_info = validate_environment(
+                    model=model,
+                    api_key=litellm_params.get(API_KEY),
+                    api_base=api_base,
+                )
+                if missing_environment_variables := validation_info.get(
+                    _VALIDATE_ENVIRONMENT_MISSING_KEYS_KEY
+                ):
+                    event_info = (
+                        f"Environment variables: {missing_environment_variables} "
+                        f"not set. Required for API calls."
+                    )
+                    structlogger.error(
+                        "base_litellm_router_client.validate_environment_variables",
+                        event_info=event_info,
+                        missing_environment_variables=missing_environment_variables,
+                    )
+                    raise ProviderClientValidationError(event_info)