rasa-pro 3.9.18__py3-none-any.whl → 3.10.16__py3-none-any.whl

rasa/core/policies/intentless_policy.py

@@ -8,13 +8,14 @@ import tiktoken
 from jinja2 import Template
 from langchain.docstore.document import Document
 from langchain.schema.embeddings import Embeddings
-from langchain.vectorstores import FAISS
+from langchain_community.vectorstores.faiss import FAISS
 
 import rasa.shared.utils.io
 from rasa import telemetry
 from rasa.core.constants import (
     CHAT_POLICY_PRIORITY,
     POLICY_PRIORITY,
+    UTTER_SOURCE_METADATA_KEY,
 )
 from rasa.core.policies.policy import Policy, PolicyPrediction, SupportedData
 from rasa.dialogue_understanding.stack.frames import (
@@ -27,7 +28,17 @@ from rasa.engine.storage.resource import Resource
 from rasa.engine.storage.storage import ModelStorage
 from rasa.graph_components.providers.forms_provider import Forms
 from rasa.graph_components.providers.responses_provider import Responses
-from rasa.shared.constants import REQUIRED_SLOTS_KEY
+from rasa.shared.constants import (
+    REQUIRED_SLOTS_KEY,
+    EMBEDDINGS_CONFIG_KEY,
+    LLM_CONFIG_KEY,
+    MODEL_CONFIG_KEY,
+    MODEL_NAME_CONFIG_KEY,
+    PROMPT_CONFIG_KEY,
+    PROVIDER_CONFIG_KEY,
+    OPENAI_PROVIDER,
+    TIMEOUT_CONFIG_KEY,
+)
 from rasa.shared.core.constants import ACTION_LISTEN_NAME
 from rasa.shared.core.domain import KEY_RESPONSES_TEXT, Domain
 from rasa.shared.core.events import (
@@ -42,6 +53,10 @@ from rasa.shared.core.trackers import DialogueStateTracker
 from rasa.shared.exceptions import FileIOException, RasaCoreException
 from rasa.shared.nlu.constants import PREDICTED_CONFIDENCE_KEY
 from rasa.shared.nlu.training_data.training_data import TrainingData
+from rasa.shared.providers.embedding._langchain_embedding_client_adapter import (
+    _LangchainEmbeddingClientAdapter,
+)
+from rasa.shared.providers.llm.llm_client import LLMClient
 from rasa.shared.utils.io import deep_container_fingerprint
 from rasa.shared.utils.llm import (
     AI,
@@ -55,6 +70,8 @@ from rasa.shared.utils.llm import (
     llm_factory,
     sanitize_message_for_prompt,
     tracker_as_readable_transcript,
+    try_instantiate_llm_client,
+    try_instantiate_embedder,
 )
 from rasa.utils.ml_utils import (
     extract_ai_response_examples,
@@ -64,11 +81,12 @@ from rasa.utils.ml_utils import (
     persist_faiss_vector_store,
     response_for_template,
 )
+from rasa.dialogue_understanding.patterns.chitchat import FLOW_PATTERN_CHITCHAT
+from rasa.shared.core.constants import ACTION_TRIGGER_CHITCHAT
 from rasa.utils.log_utils import log_llm
 
 if TYPE_CHECKING:
     from rasa.core.featurizers.tracker_featurizers import TrackerFeaturizer
-    from langchain.llms.base import BaseLLM
 
 structlogger = structlog.get_logger()
 
@@ -87,18 +105,16 @@ MAX_NUMBER_OF_TOKENS_FOR_SAMPLES = 900
 # the config property name for the confidence of the nlu prediction
 NLU_ABSTENTION_THRESHOLD = "nlu_abstention_threshold"
 
-PROMPT = "prompt"
-
 DEFAULT_LLM_CONFIG = {
-    "_type": "openai",
-    "request_timeout": 5,
+    PROVIDER_CONFIG_KEY: OPENAI_PROVIDER,
+    MODEL_CONFIG_KEY: DEFAULT_OPENAI_CHAT_MODEL_NAME,
     "temperature": 0.0,
-    "model_name": DEFAULT_OPENAI_CHAT_MODEL_NAME,
     "max_tokens": DEFAULT_OPENAI_MAX_GENERATED_TOKENS,
+    TIMEOUT_CONFIG_KEY: 5,
 }
 
 DEFAULT_EMBEDDINGS_CONFIG = {
-    "_type": "openai",
+    PROVIDER_CONFIG_KEY: OPENAI_PROVIDER,
     "model": DEFAULT_OPENAI_EMBEDDING_MODEL_NAME,
 }
 
@@ -106,8 +122,6 @@ DEFAULT_INTENTLESS_PROMPT_TEMPLATE = importlib.resources.open_text(
     "rasa.core.policies", "intentless_prompt_template.jinja2"
 ).name
 
-EMBEDDINGS_CONFIG_KEY = "embeddings"
-LLM_CONFIG_KEY = "llm"
 INTENTLESS_PROMPT_TEMPLATE_FILE_NAME = "intentless_policy_prompt.jinja2"
 
 
@@ -163,6 +177,21 @@ def filter_responses(responses: Responses, forms: Forms, flows: FlowsList) -> Re
         for name, variants in responses.data.items()
         if name not in combined_responses
     }
+
+    pattern_chitchat = flows.flow_by_id(FLOW_PATTERN_CHITCHAT)
+
+    # The following condition is highly unlikely, but mypy requires the case
+    # of pattern_chitchat == None to be addressed
+    if not pattern_chitchat:
+        return Responses(data=filtered_responses)
+
+    # if action_trigger_chitchat, filter out "utter_free_chitchat_response"
+    has_action_trigger_chitchat = pattern_chitchat.has_action_step(
+        ACTION_TRIGGER_CHITCHAT
+    )
+    if has_action_trigger_chitchat:
+        filtered_responses.pop("utter_free_chitchat_response", None)
+
     return Responses(data=filtered_responses)
 
 
@@ -366,7 +395,7 @@ class IntentlessPolicy(Policy):
             NLU_ABSTENTION_THRESHOLD: 0.9,
             LLM_CONFIG_KEY: DEFAULT_LLM_CONFIG,
             EMBEDDINGS_CONFIG_KEY: DEFAULT_EMBEDDINGS_CONFIG,
-            PROMPT: DEFAULT_INTENTLESS_PROMPT_TEMPLATE,
+            PROMPT_CONFIG_KEY: DEFAULT_INTENTLESS_PROMPT_TEMPLATE,
         }
 
     @staticmethod
@@ -405,7 +434,7 @@ class IntentlessPolicy(Policy):
         self.conversation_samples_index = samples_docsearch
         self.embedder = self._create_plain_embedder(config)
         self.prompt_template = prompt_template or rasa.shared.utils.io.read_file(
-            self.config[PROMPT]
+            self.config[PROMPT_CONFIG_KEY]
         )
         self.trace_prompt_tokens = self.config.get("trace_prompt_tokens", False)
 
@@ -416,9 +445,10 @@ class IntentlessPolicy(Policy):
         Returns:
         The embedder.
         """
-        return embedder_factory(
+        client = embedder_factory(
             config.get(EMBEDDINGS_CONFIG_KEY), DEFAULT_EMBEDDINGS_CONFIG
         )
+        return _LangchainEmbeddingClientAdapter(client)
 
     def embeddings_property(self, prop: str) -> Optional[str]:
         """Returns the property of the embeddings config."""
@@ -458,6 +488,13 @@ class IntentlessPolicy(Policy):
             A policy must return its resource locator so that potential children nodes
             can load the policy from the resource.
         """
+        try_instantiate_llm_client(
+            self.config.get(LLM_CONFIG_KEY),
+            DEFAULT_LLM_CONFIG,
+            "intentless_policy.train",
+            "IntentlessPolicy",
+        )
+
         responses = filter_responses(responses, forms, flows or FlowsList([]))
         telemetry.track_intentless_policy_train()
         response_texts = [r for r in extract_ai_response_examples(responses.data)]
@@ -500,11 +537,12 @@ class IntentlessPolicy(Policy):
 
         structlogger.info("intentless_policy.training.completed")
         telemetry.track_intentless_policy_train_completed(
-            embeddings_type=self.embeddings_property("_type"),
-            embeddings_model=self.embeddings_property("model")
-            or self.embeddings_property("model_name"),
-            llm_type=self.llm_property("_type"),
-            llm_model=self.llm_property("model") or self.llm_property("model_name"),
+            embeddings_type=self.embeddings_property(PROVIDER_CONFIG_KEY),
+            embeddings_model=self.embeddings_property(MODEL_CONFIG_KEY)
+            or self.embeddings_property(MODEL_NAME_CONFIG_KEY),
+            llm_type=self.llm_property(PROVIDER_CONFIG_KEY),
+            llm_model=self.llm_property(MODEL_CONFIG_KEY)
+            or self.llm_property(MODEL_NAME_CONFIG_KEY),
         )
 
         self.persist()
@@ -578,11 +616,12 @@ class IntentlessPolicy(Policy):
         )
 
         telemetry.track_intentless_policy_predict(
-            embeddings_type=self.embeddings_property("_type"),
-            embeddings_model=self.embeddings_property("model")
-            or self.embeddings_property("model_name"),
-            llm_type=self.llm_property("_type"),
-            llm_model=self.llm_property("model") or self.llm_property("model_name"),
+            embeddings_type=self.embeddings_property(PROVIDER_CONFIG_KEY),
+            embeddings_model=self.embeddings_property(MODEL_CONFIG_KEY)
+            or self.embeddings_property(MODEL_NAME_CONFIG_KEY),
+            llm_type=self.llm_property(PROVIDER_CONFIG_KEY),
+            llm_model=self.llm_property(MODEL_CONFIG_KEY)
+            or self.llm_property(MODEL_NAME_CONFIG_KEY),
             score=score,
         )
 
@@ -595,7 +634,9 @@ class IntentlessPolicy(Policy):
         else:
             events = []
 
-        return self._prediction(result, events=events)
+        action_metadata = {UTTER_SOURCE_METADATA_KEY: self.__class__.__name__}
+
+        return self._prediction(result, events=events, action_metadata=action_metadata)
 
     async def generate_answer(
         self,
@@ -619,9 +660,10 @@ class IntentlessPolicy(Policy):
         )
         return await self._generate_llm_answer(llm, prompt)
 
-    async def _generate_llm_answer(self, llm: "BaseLLM", prompt: str) -> Optional[str]:
+    async def _generate_llm_answer(self, llm: LLMClient, prompt: str) -> Optional[str]:
         try:
-            return await llm.apredict(prompt)
+            llm_response = await llm.acompletion(prompt)
+            return llm_response.choices[0]
         except Exception as e:
             # unfortunately, langchain does not wrap LLM exceptions which means
             # we have to catch all exceptions here
@@ -685,6 +727,7 @@ class IntentlessPolicy(Policy):
             number_of_samples=NUMBER_OF_CONVERSATION_SAMPLES,
             max_number_of_tokens=MAX_NUMBER_OF_TOKENS_FOR_SAMPLES,
         )
+
         extra_ai_responses = self.extract_ai_responses(conversation_samples)
 
         # put conversation responses in front of sampled examples,
@@ -876,6 +919,18 @@ class IntentlessPolicy(Policy):
         **kwargs: Any,
     ) -> "IntentlessPolicy":
         """Loads a trained policy (see parent class for full docstring)."""
+        try_instantiate_llm_client(
+            config.get(LLM_CONFIG_KEY),
+            DEFAULT_LLM_CONFIG,
+            "intentless_policy.load",
+            IntentlessPolicy.__name__,
+        )
+        try_instantiate_embedder(
+            config.get(EMBEDDINGS_CONFIG_KEY),
+            DEFAULT_EMBEDDINGS_CONFIG,
+            "intentless_policy.load",
+            IntentlessPolicy.__name__,
+        )
         responses_docsearch = None
         samples_docsearch = None
         prompt_template = None
@@ -901,7 +956,6 @@ class IntentlessPolicy(Policy):
             structlogger.warning(
                 "intentless_policy.load.failed", error=e, resource_name=resource.name
             )
-
         return cls(
             config,
             model_storage,
@@ -916,7 +970,7 @@ class IntentlessPolicy(Policy):
     def fingerprint_addon(cls, config: Dict[str, Any]) -> Optional[str]:
         """Add a fingerprint of the knowledge base for the graph."""
         prompt_template = get_prompt_template(
-            config.get("prompt"),
+            config.get(PROMPT_CONFIG_KEY),
             DEFAULT_INTENTLESS_PROMPT_TEMPLATE,
         )
         return deep_container_fingerprint(prompt_template)

rasa/core/processor.py

@@ -3,12 +3,12 @@ import copy
 import logging
 import structlog
 import os
+import re
 from pathlib import Path
 import tarfile
 import time
 from types import LambdaType
 from typing import Any, Dict, List, Optional, TYPE_CHECKING, Text, Tuple, Union
-
 from rasa.core.actions.action_exceptions import ActionExecutionRejection
 from rasa.core.actions.forms import FormAction
 from rasa.core.http_interpreter import RasaNLUHttpInterpreter
@@ -101,6 +101,9 @@ logger = logging.getLogger(__name__)
 structlogger = structlog.get_logger()
 
 MAX_NUMBER_OF_PREDICTIONS = int(os.environ.get("MAX_NUMBER_OF_PREDICTIONS", "10"))
+MAX_NUMBER_OF_PREDICTIONS_CALM = int(
+    os.environ.get("MAX_NUMBER_OF_PREDICTIONS_CALM", "1000")
+)
 
 
 class MessageProcessor:
@@ -114,6 +117,7 @@ class MessageProcessor:
         generator: NaturalLanguageGenerator,
         action_endpoint: Optional[EndpointConfig] = None,
         max_number_of_predictions: int = MAX_NUMBER_OF_PREDICTIONS,
+        max_number_of_predictions_calm: int = MAX_NUMBER_OF_PREDICTIONS_CALM,
         on_circuit_break: Optional[LambdaType] = None,
         http_interpreter: Optional[RasaNLUHttpInterpreter] = None,
         endpoints: Optional["AvailableEndpoints"] = None,
@@ -122,7 +126,6 @@ class MessageProcessor:
         self.nlg = generator
         self.tracker_store = tracker_store
         self.lock_store = lock_store
-        self.max_number_of_predictions = max_number_of_predictions
         self.on_circuit_break = on_circuit_break
         self.action_endpoint = action_endpoint
         self.model_filename, self.model_metadata, self.graph_runner = self._load_model(
@@ -130,6 +133,10 @@ class MessageProcessor:
         )
         self.endpoints = endpoints
 
+        self.max_number_of_predictions = max_number_of_predictions
+        self.max_number_of_predictions_calm = max_number_of_predictions_calm
+        self.is_calm_assistant = self._is_calm_assistant()
+
         if self.model_metadata.assistant_id is None:
             rasa.shared.utils.io.raise_warning(
                 f"The model metadata does not contain a value for the "
@@ -751,20 +758,17 @@ class MessageProcessor:
                     message=processed_message, domain=self.domain
                 )
 
-            # Invalid use of slash syntax
+            # Invalid use of slash syntax, sanitize the message before passing
+            # it to the graph
             if (
                 processed_message.starts_with_slash_syntax()
                 and not processed_message.has_intent()
                 and not processed_message.has_commands()
             ):
-                parse_data = self._parse_invalid_use_of_slash_syntax(
-                    processed_message, tracker, only_output_properties
-                )
+                message = self._sanitize_message(message)
 
             # Intent or commands are not explicitly present. Pass message to graph.
-            elif not (
-                processed_message.has_intent() or processed_message.has_commands()
-            ):
+            if not (processed_message.has_intent() or processed_message.has_commands()):
                 parse_data = await self._parse_message_with_graph(
                     message, tracker, only_output_properties
                 )
@@ -788,44 +792,16 @@ class MessageProcessor:
 
         return parse_data
 
-    def _parse_invalid_use_of_slash_syntax(
-        self,
-        message: Message,
-        tracker: Optional[DialogueStateTracker] = None,
-        only_output_properties: bool = True,
-    ) -> Dict[Text, Any]:
-        structlogger.warning(
-            "processor.message.parse.invalid_use_of_slash_syntax",
-            event_info=(
-                "Message starts with '/', but no intents or commands are"
-                "passed. Returning CannotHandleCommand() as a fallback."
-            ),
-            message=message.get(TEXT),
-        )
-        parse_data: Dict[Text, Any] = {
-            TEXT: "",
-            INTENT: {INTENT_NAME_KEY: None, PREDICTED_CONFIDENCE_KEY: 0.0},
-            ENTITIES: [],
-        }
-        parse_data.update(
-            message.as_dict(only_output_properties=only_output_properties)
-        )
-        commands = parse_data.get(COMMANDS, [])
-        commands += [
-            CannotHandleCommand(RASA_PATTERN_CANNOT_HANDLE_INVALID_INTENT).as_dict()
-        ]
-
-        if (
-            tracker is not None
-            and tracker.has_coexistence_routing_slot
-            and tracker.get_slot(ROUTE_TO_CALM_SLOT) is None
-        ):
-            # if we are currently not routing to either CALM or dm1
-            # we make a sticky routing to CALM
-            commands += [SetSlotCommand(ROUTE_TO_CALM_SLOT, True).as_dict()]
-
-        parse_data[COMMANDS] = commands
-        return parse_data
+    def _sanitize_message(self, message: UserMessage) -> UserMessage:
+        """Sanitize user message by removing prepended slashes before the
+        actual content.
+        """
+        # Regex pattern to match leading slashes and any whitespace before
+        # actual content
+        pattern = r"^[/\s]+"
+        # Remove the matched pattern from the beginning of the message
+        message.text = re.sub(pattern, "", message.text).strip()
+        return message
 
     async def _parse_message_with_commands_and_intents(
         self,
@@ -1003,11 +979,15 @@ class MessageProcessor:
     ) -> int:
         """Select the action limit based on the tracker state.
 
-        Usually, we want to limit the number of predictions to the number of actions
-        that have been executed in the conversation so far. However, if the
-        conversation is currently in a state where the user is correcting the flow
-        we want to allow for more predictions to be made as we might be traversing
-        through a long flow.
+        This function determines the maximum number of predictions that should be
+        made during a dialogue conversation. Typically, the number of predictions
+        is limited to the number of actions executed so far in the conversation.
+        However, in certain states (e.g., when the user is correcting the
+        conversation flow), more predictions may be allowed as the system traverses
+        through a long dialogue flow.
+
+        Additionally, if the `ROUTE_TO_CALM_SLOT` is present in the tracker slots,
+        the action limit is adjusted to a separate limit for CALM-based flows.
 
         Args:
             tracker: instance of DialogueStateTracker.
@@ -1015,6 +995,18 @@ class MessageProcessor:
         Returns:
         The maximum number of predictions to make.
         """
+        # Check if it is a CALM assistant and if so, that the `ROUTE_TO_CALM_SLOT`
+        # is either not present or set to `True`.
+        # If it does, use the specific prediction limit for CALM assistants.
+        # Otherwise, use the default prediction limit.
+        if self.is_calm_assistant and (
+            not tracker.has_coexistence_routing_slot
+            or tracker.get_slot(ROUTE_TO_CALM_SLOT)
+        ):
+            max_number_of_predictions = self.max_number_of_predictions_calm
+        else:
+            max_number_of_predictions = self.max_number_of_predictions
+
         reversed_events = list(tracker.events)[::-1]
         is_conversation_in_flow_correction = False
         for e in reversed_events:
@@ -1029,8 +1021,10 @@ class MessageProcessor:
             # allow for more predictions to be made as we might be traversing through
             # a long flow. We multiply the number of predictions by 10 to allow for
             # more predictions to be made - the factor is a best guess.
-            return self.max_number_of_predictions * 5
-        return self.max_number_of_predictions
+            return max_number_of_predictions * 5
+
+        # Return the default
+        return max_number_of_predictions
 
     def is_action_limit_reached(
         self, tracker: DialogueStateTracker, should_predict_another_action: bool
@@ -1420,3 +1414,27 @@ class MessageProcessor:
         ]
 
         return len(filtered_commands) > 0
+
+    def _is_calm_assistant(self) -> bool:
+        """Inspects the nodes of the graph schema to determine whether
+        any node is associated with the `FlowPolicy`, which is indicative of a
+        CALM assistant setup.
+
+        Returns:
+            bool: True if any node in the graph schema uses `FlowPolicy`.
+        """
+        # Get the graph schema's nodes from the graph runner.
+        nodes: dict[str, Any] = self.graph_runner._graph_schema.nodes  # type: ignore[attr-defined]
+
+        flow_policy_class_path = "rasa.core.policies.flow_policy.FlowPolicy"
+        # Iterate over the nodes and check if any node uses `FlowPolicy`.
+        for node_name, schema_node in nodes.items():
+            if (
+                schema_node.uses is not None
+                and f"{schema_node.uses.__module__}.{schema_node.uses.__name__}"
+                == flow_policy_class_path
+            ):
+                return True
+
+        # Return False if no node is found using `FlowPolicy`.
+        return False

rasa/core/run.py

@@ -9,12 +9,12 @@ from functools import partial
 from typing import (
     Any,
     Callable,
+    Dict,
     List,
     Optional,
     Text,
     Tuple,
     Union,
-    Dict,
 )
 
 from sanic import Sanic
@@ -24,7 +24,6 @@ import rasa.core.utils
 import rasa.shared.utils.common
 import rasa.shared.utils.io
 import rasa.utils
-from rasa.utils import licensing
 import rasa.utils.common
 import rasa.utils.io
 from rasa import server, telemetry
@@ -34,9 +33,11 @@ from rasa.core.agent import Agent
 from rasa.core.channels import console
 from rasa.core.channels.channel import InputChannel
 from rasa.core.utils import AvailableEndpoints
+from rasa.nlu.persistor import StorageType
 from rasa.plugin import plugin_manager
 from rasa.shared.exceptions import RasaException
 from rasa.shared.utils.yaml import read_config_file
+from rasa.utils import licensing
 
 logger = logging.getLogger()  # get the root logger
 
@@ -210,7 +211,7 @@ def serve_application(
     jwt_private_key: Optional[Text] = None,
     jwt_method: Optional[Text] = None,
     endpoints: Optional[AvailableEndpoints] = None,
-    remote_storage: Optional[Text] = None,
+    remote_storage: Optional[StorageType] = None,
     log_file: Optional[Text] = None,
     ssl_certificate: Optional[Text] = None,
     ssl_keyfile: Optional[Text] = None,
@@ -295,7 +296,7 @@ def serve_application(
 async def load_agent_on_start(
     model_path: Text,
     endpoints: AvailableEndpoints,
-    remote_storage: Optional[Text],
+    remote_storage: Optional[StorageType],
     app: Sanic,
     loop: AbstractEventLoop,
 ) -> Agent:

rasa/core/tracker_store.py

@@ -26,10 +26,10 @@ from typing import (
 from boto3.dynamodb.conditions import Key
 from pymongo.collection import Collection
 
-import rasa.core.utils as core_utils
 import rasa.shared.utils.cli
 import rasa.shared.utils.common
 import rasa.shared.utils.io
+import rasa.utils.json_utils
 from rasa.plugin import plugin_manager
 from rasa.shared.core.constants import ACTION_LISTEN_NAME
 from rasa.core.brokers.broker import EventBroker
@@ -705,7 +705,7 @@ class DynamoTrackerStore(TrackerStore, SerializedTrackerAsDict):
 
         DynamoDB cannot store `float`s, so we'll convert them to `Decimal`s.
         """
-        return core_utils.replace_floats_with_decimals(
+        return rasa.utils.json_utils.replace_floats_with_decimals(
             SerializedTrackerAsDict.serialise_tracker(tracker)
         )
 
@@ -747,12 +747,16 @@ class DynamoTrackerStore(TrackerStore, SerializedTrackerAsDict):
             events_with_floats = []
             for dialogue in dialogues:
                 if dialogue.get("events"):
-                    events = core_utils.replace_decimals_with_floats(dialogue["events"])
+                    events = rasa.utils.json_utils.replace_decimals_with_floats(
+                        dialogue["events"]
+                    )
                     events_with_floats += events
         else:
             events = dialogues[0].get("events", [])
             # `float`s are stored as `Decimal` objects - we need to convert them back
-            events_with_floats = core_utils.replace_decimals_with_floats(events)
+            events_with_floats = rasa.utils.json_utils.replace_decimals_with_floats(
+                events
+            )
 
         if self.domain is None:
             slots = []

rasa/core/training/interactive.py

@@ -1688,7 +1688,7 @@ def run_interactive_learning(
         p = None
 
     app = run.configure_app(port=port, conversation_id="default", enable_api=True)
-    endpoints = AvailableEndpoints.read_endpoints(server_args.get("endpoints"))
+    endpoints = AvailableEndpoints.get_instance(server_args.get("endpoints"))
 
     # before_server_start handlers make sure the agent is loaded before the
     # interactive learning IO starts