rasa-pro 3.12.8__tar.gz → 3.12.10__tar.gz

{rasa_pro-3.12.8 → rasa_pro-3.12.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: rasa-pro
-Version: 3.12.8
+Version: 3.12.10
 Summary: State-of-the-art open-core Conversational AI framework for Enterprises that natively leverages generative AI for effortless assistant development.
 Keywords: nlp,machine-learning,machine-learning-library,bot,bots,botkit,rasa conversational-agents,conversational-ai,chatbot,chatbot-framework,bot-framework
 Author: Rasa Technologies GmbH
@@ -63,12 +63,12 @@ Requires-Dist: keras (==2.14.0)
 Requires-Dist: langchain (>=0.2.17,<0.3.0)
 Requires-Dist: langchain-community (>=0.2.19,<0.3.0)
 Requires-Dist: langcodes (>=3.5.0,<4.0.0)
-Requires-Dist: litellm (==1.52.6)
+Requires-Dist: litellm (>=1.68.0,<1.69.0)
 Requires-Dist: matplotlib (>=3.7,<3.8)
 Requires-Dist: mattermostwrapper (>=2.2,<2.3)
 Requires-Dist: networkx (>=3.1,<3.2)
 Requires-Dist: numpy (>=1.26.4,<1.27.0)
-Requires-Dist: openai (>=1.55.3,<1.56.0)
+Requires-Dist: openai (>=1.68.2,<1.69.0)
 Requires-Dist: openpyxl (>=3.1.5,<4.0.0)
 Requires-Dist: opentelemetry-api (>=1.16.0,<1.17.0)
 Requires-Dist: opentelemetry-exporter-jaeger (>=1.16.0,<1.17.0)

{rasa_pro-3.12.8 → rasa_pro-3.12.10}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "rasa-pro"
-version = "3.12.8"
+version = "3.12.10"
 description = "State-of-the-art open-core Conversational AI framework for Enterprises that natively leverages generative AI for effortless assistant development."
 authors = [ "Rasa Technologies GmbH <hi@rasa.com>",]
 maintainers = [ "Tom Bocklisch <tom@rasa.com>",]
@@ -154,7 +154,7 @@ structlog-sentry = ">=2.0.3,<2.1.0"
 langchain = "~0.2.17"
 langchain-community = "~0.2.19"
 jinja2 = "~3.1.6"
-openai = "~1.55.3"
+openai = "~1.68.2"
 dnspython = "2.6.1"
 wheel = ">=0.45.1" # pinning this to same version as Poetry, removing doesnot update lock file
 certifi = ">=2024.07.04"
@@ -183,7 +183,7 @@ qdrant-client = "~1.9.1"
 psutil = "^5.9.5"
 tenacity = "~8.4.1" # pinned down because of langchain
 types-protobuf = "4.25.0.20240417"
-litellm = "1.52.6" # pinned because later versions cause issues with Sagemaker
+litellm = "~1.68.0"
 openpyxl = "^3.1.5"
 diskcache = "~5.6.3"
 skops = "~0.10.0"
@@ -332,6 +332,8 @@ convention = "google"
 
 
 
+
+
 [tool.poetry.group.dev.dependencies]
 ruff = ">=0.3.5,<0.4.0"
 docker = "~7.1.0"

{rasa_pro-3.12.8 → rasa_pro-3.12.10}/rasa/core/actions/action.py

@@ -898,7 +898,7 @@ class RemoteAction(Action):
                 draft["buttons"].extend(buttons)
 
             # Avoid overwriting `draft` values with empty values
-            response = {k: v for k, v in response.items() if v}
+            response = {k: v for k, v in response.items() if v is not None}
             draft.update(response)
             bot_messages.append(create_bot_utterance(draft))
 

{rasa_pro-3.12.8 → rasa_pro-3.12.10}/rasa/core/channels/studio_chat.py

@@ -16,6 +16,7 @@ import structlog
 from sanic import Sanic
 
 from rasa.core.channels.socketio import SocketBlueprint, SocketIOInput
+from rasa.core.exceptions import AgentNotReady
 from rasa.hooks import hookimpl
 from rasa.plugin import plugin_manager
 from rasa.shared.core.constants import ACTION_LISTEN_NAME
@@ -149,8 +150,15 @@ class StudioChatInput(SocketIOInput):
         """
         await on_new_message(message)
 
-        if not self.agent:
+        if not self.agent or not self.agent.is_ready():
             structlogger.error("studio_chat.on_message_proxy.agent_not_initialized")
+            await self.emit_error(
+                "The Rasa Pro model could not be loaded. "
+                "Please check the training and deployment logs "
+                "for more information.",
+                message.sender_id,
+                AgentNotReady("The Rasa Pro model could not be loaded."),
+            )
             return
 
         tracker = await self.agent.tracker_store.retrieve(message.sender_id)
@@ -160,6 +168,17 @@ class StudioChatInput(SocketIOInput):
 
         await self.on_tracker_updated(tracker)
 
+    async def emit_error(self, message: str, room: str, e: Exception) -> None:
+        await self.emit(
+            "error",
+            {
+                "message": message,
+                "error": str(e),
+                "exception": str(type(e).__name__),
+            },
+            room=room,
+        )
+
     async def handle_tracker_update(self, sid: str, data: Dict) -> None:
         from rasa.shared.core.trackers import DialogueStateTracker
 
@@ -200,15 +219,12 @@ class StudioChatInput(SocketIOInput):
                     error=e,
                     sender_id=data["sender_id"],
                 )
-                await self.emit(
-                    "error",
-                    {
-                        "message": "An error occurred while updating the conversation.",
-                        "error": str(e),
-                        "exception": str(type(e).__name__),
-                    },
-                    room=sid,
+                await self.emit_error(
+                    "An error occurred while updating the conversation.",
+                    data["sender_id"],
+                    e,
                 )
+
         if not tracker:
             # in case the tracker couldn't be updated, we retrieve the prior
             # version and use that to populate the update

{rasa_pro-3.12.8 → rasa_pro-3.12.10}/rasa/core/channels/voice_ready/audiocodes.py

@@ -6,7 +6,18 @@ import uuid
 from collections import defaultdict
 from dataclasses import asdict
 from datetime import datetime, timedelta, timezone
-from typing import Any, Awaitable, Callable, Dict, List, Optional, Set, Text, Union
+from typing import (
+    Any,
+    Awaitable,
+    Callable,
+    Dict,
+    List,
+    Optional,
+    Set,
+    Text,
+    Tuple,
+    Union,
+)
 
 import structlog
 from jsonschema import ValidationError, validate
@@ -76,35 +87,45 @@ class Conversation:
 
     @staticmethod
     def get_metadata(activity: Dict[Text, Any]) -> Optional[Dict[Text, Any]]:
-        """Get metadata from the activity."""
-        return asdict(map_call_params(activity["parameters"]))
+        """Get metadata from the activity.
+
+        ONLY used for activities NOT for events (see _handle_event)."""
+        return activity.get("parameters")
 
     @staticmethod
-    def _handle_event(event: Dict[Text, Any]) -> Text:
-        """Handle start and DTMF event and return the corresponding text."""
+    def _handle_event(event: Dict[Text, Any]) -> Tuple[Text, Dict[Text, Any]]:
+        """Handle events and return a tuple of text and metadata.
+
+        Args:
+            event: The event to handle.
+
+        Returns:
+            Tuple of text and metadata.
+            text is either /session_start or /vaig_event_<event_name>
+            metadata is a dictionary with the event parameters.
+        """
         structlogger.debug("audiocodes.handle.event", event_payload=event)
         if "name" not in event:
             structlogger.warning(
                 "audiocodes.handle.event.no_name_key", event_payload=event
             )
-            return ""
+            return "", {}
 
         if event["name"] == EVENT_START:
             text = f"{INTENT_MESSAGE_PREFIX}{USER_INTENT_SESSION_START}"
+            metadata = asdict(map_call_params(event.get("parameters", {})))
         elif event["name"] == EVENT_DTMF:
             text = f"{INTENT_MESSAGE_PREFIX}vaig_event_DTMF"
-            event_params = {"value": event["value"]}
-            text += json.dumps(event_params)
+            metadata = {"value": event["value"]}
         else:
             # handle other events described by Audiocodes
             # https://techdocs.audiocodes.com/voice-ai-connect/#VAIG_Combined/inactivity-detection.htm?TocPath=Bot%2520integration%257CReceiving%2520notifications%257C_____3
             text = f"{INTENT_MESSAGE_PREFIX}vaig_event_{event['name']}"
-            event_params = {**event.get("parameters", {})}
+            metadata = {**event.get("parameters", {})}
             if "value" in event:
-                event_params["value"] = event["value"]
-            text += json.dumps(event_params)
+                metadata["value"] = event["value"]
 
-        return text
+        return text, metadata
 
     def is_active_conversation(self, now: datetime, delta: timedelta) -> bool:
         """Check if the conversation is active."""
@@ -139,21 +160,29 @@ 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])
             if activity["type"] == ACTIVITY_MESSAGE:
                 text = activity["text"]
+                metadata = self.get_metadata(activity)
             elif activity["type"] == ACTIVITY_EVENT:
-                text = self._handle_event(activity)
+                text, metadata = self._handle_event(activity)
             else:
                 structlogger.warning(
                     "audiocodes.handle.activities.unknown_activity_type",
                     activity=activity,
                 )
+                continue
+
             if not text:
                 continue
-            metadata = self.get_metadata(activity)
             user_msg = UserMessage(
                 text=text,
                 input_channel=input_channel_name,
@@ -392,30 +421,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_pro-3.12.8 → rasa_pro-3.12.10}/rasa/shared/core/flows/flow.py

@@ -38,6 +38,7 @@ 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,
@@ -466,161 +467,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()
+        visited_step_ids: Set[str] = set()
 
-        self._go_over_steps(steps, current_path, flow_paths_list, step_ids_visited)
-
-        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,
+            )
+
+        # Backtrack the current step and remove it from the path.
+        visited_step_ids.remove(current_step.id)
 
-    def _handle_links(
+        # 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_pro-3.12.8 → rasa_pro-3.12.10}/rasa/version.py

@@ -1,3 +1,3 @@
 # this file will automatically be changed,
 # do not add anything but the version number here!
-__version__ = "3.12.8"
+__version__ = "3.12.10"