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

rasa/shared/utils/llm.py

@@ -1,3 +1,4 @@
+import importlib.resources
 import json
 from copy import deepcopy
 from functools import wraps
@@ -19,6 +20,8 @@ import structlog
 import rasa.shared.utils.io
 from rasa.core.utils import AvailableEndpoints
 from rasa.shared.constants import (
+    DEFAULT_PROMPT_PACKAGE_NAME,
+    MODEL_CONFIG_KEY,
     MODEL_GROUP_CONFIG_KEY,
     MODEL_GROUP_ID_CONFIG_KEY,
     MODELS_CONFIG_KEY,
@@ -29,9 +32,7 @@ from rasa.shared.constants import (
 )
 from rasa.shared.core.events import BotUttered, UserUttered
 from rasa.shared.core.slots import BooleanSlot, CategoricalSlot, Slot
-from rasa.shared.engine.caching import (
-    get_local_cache_location,
-)
+from rasa.shared.engine.caching import get_local_cache_location
 from rasa.shared.exceptions import (
     FileIOException,
     FileNotFoundException,
@@ -355,13 +356,13 @@ def _combine_single_model_configs(
         )
         # Checks for deprecated keys, resolves aliases and returns a valid config.
         # This is done to ensure that the custom config is valid.
-        return client_config_clazz.from_dict(custom_config).to_dict()
+        return client_config_clazz.from_dict(deepcopy(custom_config)).to_dict()
 
     # If the provider is the same in both configs
     # OR provider is not specified in the custom config
     # perform MERGE by overriding the default config keys and values
     # with custom config keys and values.
-    merged_config = {**default_config.copy(), **custom_config.copy()}
+    merged_config = {**deepcopy(default_config), **deepcopy(custom_config)}
     # Check for deprecated keys, resolve aliases and return a valid config.
     # This is done to ensure that the merged config is valid.
     default_config_clazz = get_client_config_class_from_provider(
@@ -512,7 +513,7 @@ def llm_client_factory(
     Returns:
         Instantiated LLM based on the configuration.
     """
-    config = combine_custom_and_default_config(custom_config, default_config)
+    config = combine_custom_and_default_config(deepcopy(custom_config), default_config)
 
     ensure_cache()
 
@@ -641,7 +642,7 @@ def embedder_client_factory(
     Returns:
         Instantiated Embedder based on the configuration.
     """
-    config = combine_custom_and_default_config(custom_config, default_config)
+    config = combine_custom_and_default_config(deepcopy(custom_config), default_config)
 
     ensure_cache()
 
@@ -675,6 +676,28 @@ def get_prompt_template(
     return default_prompt_template
 
 
+def get_default_prompt_template_based_on_model(
+    config: Dict[str, Any],
+    model_prompt_mapping: Dict[str, Any],
+    fallback_prompt_path: str,
+) -> Text:
+    """Returns the default prompt template based on the model name.
+
+    Args:
+        config: The model config.
+        model_prompt_mapping: The mapping of model name to prompt template.
+        fallback_prompt_path: The fallback prompt path.
+
+    Returns:
+        The default prompt template.
+    """
+    provider = config.get(PROVIDER_CONFIG_KEY)
+    model = config.get(MODEL_CONFIG_KEY, "")
+    model_name = model if provider and provider in model else f"{provider}/{model}"
+    prompt_file_path = model_prompt_mapping.get(model_name, fallback_prompt_path)
+    return importlib.resources.read_text(DEFAULT_PROMPT_PACKAGE_NAME, prompt_file_path)
+
+
 def allowed_values_for_slot(slot: Slot) -> Union[str, None]:
     """Get the allowed values for a slot."""
     if isinstance(slot, BooleanSlot):

rasa/shared/utils/pykwalify_extensions.py

@@ -8,6 +8,11 @@ from typing import Any, Dict, List, Text, Union
 
 from pykwalify.errors import SchemaError
 
+from rasa.shared.utils.constants import (
+    RASA_PRO_BETA_PREDICATES_IN_RESPONSE_CONDITIONS_ENV_VAR_NAME,
+)
+from rasa.utils.beta import ensure_beta_feature_is_enabled
+
 
 def require_response_keys(
     responses: List[Dict[Text, Any]], _: Dict, __: Text
@@ -24,4 +29,23 @@ def require_response_keys(
                 "null 'text' value in response."
             )
 
+        conditions = response.get("condition", [])
+        if isinstance(conditions, str):
+            ensure_beta_feature_is_enabled(
+                "predicates in response conditions",
+                RASA_PRO_BETA_PREDICATES_IN_RESPONSE_CONDITIONS_ENV_VAR_NAME,
+            )
+            continue
+
+        for condition in conditions:
+            if not isinstance(condition, dict):
+                return SchemaError("Condition must be a dictionary.")
+            if not all(key in condition for key in ("type", "name", "value")):
+                return SchemaError(
+                    "Condition must have 'type', 'name', and 'value' keys."
+                )
+
+            if condition.get("type") != "slot":
+                return SchemaError("Condition type must be of type `slot`.")
+
     return True

rasa/shared/utils/schemas/domain.yml

@@ -98,6 +98,11 @@ mapping:
                     type: "any"
                   action:
                     type: "str"
+                  run_action_every_turn:
+                    type: "str"
+                  coexistence_system:
+                    type: "str"
+                    enum: ["NLU", "CALM", "SHARED"]
                   conditions:
                     type: "seq"
                     sequence:
@@ -111,6 +116,27 @@ mapping:
                           active_flow:
                             type: "str"
                             nullable: True
+          validation:
+            type: map
+            required: false
+            mapping:
+              rejections:
+                type: seq
+                required: true
+                sequence:
+                  - type: map
+                    mapping:
+                      if:
+                        type: str
+                        required: true
+                      utter:
+                        type: str
+                        required: true
+              refill_utter:
+                type: str
+                required: false
+                nullable: false
+
   forms:
     type: "map"
     required: False

rasa/telemetry.py

@@ -529,7 +529,6 @@ def _send_request(url: Text, payload: Dict[Text, Any]) -> None:
     """
     if _is_telemetry_debug_enabled():
         print_telemetry_payload(payload)
-        return
 
     write_key = _get_telemetry_write_key()
     if not write_key:
@@ -1126,6 +1125,7 @@ def _get_llm_command_generator_config(config: Dict[str, Any]) -> Optional[Dict]:
     retrieval is enabled, and flow retrieval embedding model.
     """
     from rasa.dialogue_understanding.generator import (
+        CompactLLMCommandGenerator,
         LLMCommandGenerator,
         MultiStepLLMCommandGenerator,
         SingleStepLLMCommandGenerator,
@@ -1155,6 +1155,7 @@ def _get_llm_command_generator_config(config: Dict[str, Any]) -> Optional[Dict]:
                 LLMCommandGenerator.__name__,
                 SingleStepLLMCommandGenerator.__name__,
                 MultiStepLLMCommandGenerator.__name__,
+                CompactLLMCommandGenerator.__name__,
             ]:
                 return component
         return None

rasa/tracing/config.py

@@ -29,6 +29,7 @@ from rasa.dialogue_understanding.commands import (
     FreeFormAnswerCommand,
 )
 from rasa.dialogue_understanding.generator import (
+    CompactLLMCommandGenerator,
     LLMCommandGenerator,
     MultiStepLLMCommandGenerator,
     SingleStepLLMCommandGenerator,
@@ -110,6 +111,7 @@ def configure_tracing(tracer_provider: Optional[TracerProvider]) -> None:
         endpoint_config_class=EndpointConfig,
         grpc_custom_action_executor_class=GRPCCustomActionExecutor,
         single_step_llm_command_generator_class=SingleStepLLMCommandGenerator,
+        compact_llm_command_generator_class=CompactLLMCommandGenerator,
         multi_step_llm_command_generator_class=MultiStepLLMCommandGenerator,
         custom_action_executor_subclasses=custom_action_executor_subclasses,
         flow_retrieval_class=FlowRetrieval,

rasa/tracing/constants.py

@@ -32,6 +32,18 @@ SINGLE_STEP_LLM_COMMAND_GENERATOR_PROMPT_TOKEN_USAGE_METRIC_NAME = (
 SINGLE_STEP_LLM_COMMAND_GENERATOR_LLM_RESPONSE_DURATION_METRIC_NAME = (
     "single_step_llm_command_generator_llm_response_duration"
 )
+COMPACT_LLM_COMMAND_GENERATOR_CPU_USAGE_METRIC_NAME = (
+    "compact_llm_command_generator_cpu_usage"
+)
+COMPACT_LLM_COMMAND_GENERATOR_MEMORY_USAGE_METRIC_NAME = (
+    "compact_llm_command_generator_memory_usage"
+)
+COMPACT_LLM_COMMAND_GENERATOR_PROMPT_TOKEN_USAGE_METRIC_NAME = (
+    "compact_llm_command_generator_prompt_token_usage"
+)
+COMPACT_LLM_COMMAND_GENERATOR_LLM_RESPONSE_DURATION_METRIC_NAME = (
+    "compact_llm_command_generator_llm_response_duration"
+)
 MULTI_STEP_LLM_COMMAND_GENERATOR_CPU_USAGE_METRIC_NAME = (
     "multi_step_llm_command_generator_cpu_usage"
 )

rasa/tracing/instrumentation/instrumentation.py

@@ -41,6 +41,7 @@ from rasa.core.processor import MessageProcessor
 from rasa.core.tracker_store import TrackerStore
 from rasa.dialogue_understanding.commands import Command
 from rasa.dialogue_understanding.generator import (
+    CompactLLMCommandGenerator,
     LLMCommandGenerator,
     MultiStepLLMCommandGenerator,
     SingleStepLLMCommandGenerator,
@@ -64,6 +65,7 @@ from rasa.tracing.instrumentation.intentless_policy_instrumentation import (
 )
 from rasa.tracing.instrumentation.metrics import (
     record_callable_duration_metrics,
+    record_compact_llm_command_generator_metrics,
     record_llm_command_generator_metrics,
     record_multi_step_llm_command_generator_metrics,
     record_request_size_in_bytes,
@@ -286,6 +288,9 @@ LLMCommandGeneratorType = TypeVar("LLMCommandGeneratorType", bound=LLMCommandGen
 SingleStepLLMCommandGeneratorType = TypeVar(
     "SingleStepLLMCommandGeneratorType", bound=SingleStepLLMCommandGenerator
 )
+CompactLLMCommandGeneratorType = TypeVar(
+    "CompactLLMCommandGeneratorType", bound=CompactLLMCommandGenerator
+)
 MultiStepLLMCommandGeneratorType = TypeVar(
     "MultiStepLLMCommandGeneratorType", bound=MultiStepLLMCommandGenerator
 )
@@ -318,6 +323,9 @@ def instrument(
     single_step_llm_command_generator_class: Optional[
         Type[SingleStepLLMCommandGeneratorType]
     ] = None,
+    compact_llm_command_generator_class: Optional[
+        Type[CompactLLMCommandGeneratorType]
+    ] = None,
     multi_step_llm_command_generator_class: Optional[
         Type[MultiStepLLMCommandGeneratorType]
     ] = None,
@@ -368,6 +376,9 @@ def instrument(
     :param single_step_llm_command_generator_class: The `SingleStepLLMCommandGenerator`
         to be instrumented. If `None` is given, no `SingleStepLLMCommandGenerator` will
         be instrumented.
+    :param compact_llm_command_generator_class: The `CompactLLMCommandGenerator`
+        to be instrumented. If `None` is given, no `CompactLLMCommandGenerator` will
+        be instrumented.
     :param multi_step_llm_command_generator_class: The `MultiStepLLMCommandGenerator`
         to be instrumented. If `None` is given, no `MultiStepLLMCommandGenerator` will
         be instrumented.
@@ -492,6 +503,30 @@ def instrument(
         )
         mark_class_as_instrumented(single_step_llm_command_generator_class)
 
+    if compact_llm_command_generator_class is not None and not class_is_instrumented(
+        compact_llm_command_generator_class
+    ):
+        _instrument_method(
+            tracer_provider.get_tracer(compact_llm_command_generator_class.__module__),
+            compact_llm_command_generator_class,
+            "invoke_llm",
+            attribute_extractors.extract_attrs_for_llm_based_command_generator,
+            metrics_recorder=record_compact_llm_command_generator_metrics,
+        )
+        _instrument_method(
+            tracer_provider.get_tracer(compact_llm_command_generator_class.__module__),
+            compact_llm_command_generator_class,
+            "_check_commands_against_startable_flows",
+            attribute_extractors.extract_attrs_for_check_commands_against_startable_flows,
+        )
+        _instrument_perform_health_check_method_for_component(
+            tracer_provider.get_tracer(compact_llm_command_generator_class.__module__),
+            compact_llm_command_generator_class,
+            "perform_llm_health_check",
+            attribute_extractors.extract_attrs_for_performing_health_check,
+        )
+        mark_class_as_instrumented(compact_llm_command_generator_class)
+
     if multi_step_llm_command_generator_class is not None and not class_is_instrumented(
         multi_step_llm_command_generator_class
     ):
@@ -526,6 +561,7 @@ def instrument(
             for llm_based_command_generator_class in (
                 llm_command_generator_class,
                 single_step_llm_command_generator_class,
+                compact_llm_command_generator_class,
                 multi_step_llm_command_generator_class,
             )
         )

rasa/tracing/instrumentation/metrics.py

@@ -6,11 +6,16 @@ from rasa.core.nlg.contextual_response_rephraser import ContextualResponseRephra
 from rasa.core.policies.enterprise_search_policy import EnterpriseSearchPolicy
 from rasa.core.policies.intentless_policy import IntentlessPolicy
 from rasa.dialogue_understanding.generator import (
+    CompactLLMCommandGenerator,
     LLMCommandGenerator,
     MultiStepLLMCommandGenerator,
     SingleStepLLMCommandGenerator,
 )
 from rasa.tracing.constants import (
+    COMPACT_LLM_COMMAND_GENERATOR_CPU_USAGE_METRIC_NAME,
+    COMPACT_LLM_COMMAND_GENERATOR_LLM_RESPONSE_DURATION_METRIC_NAME,
+    COMPACT_LLM_COMMAND_GENERATOR_MEMORY_USAGE_METRIC_NAME,
+    COMPACT_LLM_COMMAND_GENERATOR_PROMPT_TOKEN_USAGE_METRIC_NAME,
     CONTEXTUAL_RESPONSE_REPHRASER_LLM_RESPONSE_DURATION_METRIC_NAME,
     ENTERPRISE_SEARCH_POLICY_LLM_RESPONSE_DURATION_METRIC_NAME,
     INTENTLESS_POLICY_LLM_RESPONSE_DURATION_METRIC_NAME,
@@ -170,6 +175,36 @@ def record_single_step_llm_command_generator_metrics(
     )
 
 
+def record_compact_llm_command_generator_metrics(
+    attributes: Dict[str, Any],
+) -> None:
+    """
+    Record measurements for CompactLLMCommandGenerator specific metrics.
+
+    The recording is done by the opentelemetry.metrics.Histogram instruments.
+    These instruments are registered to the MetricInstrumentProvider internal singleton.
+
+    :param attributes: Extracted tracing attributes
+    :return: None
+    """
+    instrument_provider = MetricInstrumentProvider()
+
+    if not instrument_provider.instruments:
+        return None
+
+    record_llm_based_command_generator_cpu_usage(
+        instrument_provider, COMPACT_LLM_COMMAND_GENERATOR_CPU_USAGE_METRIC_NAME
+    )
+    record_llm_based_command_generator_memory_usage(
+        instrument_provider, COMPACT_LLM_COMMAND_GENERATOR_MEMORY_USAGE_METRIC_NAME
+    )
+    record_llm_based_command_generator_prompt_token(
+        instrument_provider,
+        attributes,
+        COMPACT_LLM_COMMAND_GENERATOR_PROMPT_TOKEN_USAGE_METRIC_NAME,
+    )
+
+
 def record_multi_step_llm_command_generator_metrics(attributes: Dict[str, Any]) -> None:
     """
     Record measurements for MultiStepLLMCommandGenerator specific metrics.
@@ -205,6 +240,7 @@ def record_callable_duration_metrics(
     Record duration of instrumented method calls invoked for the following components:
     - LLMCommandGenerator
     - SingleStepLLMCommandGenerator
+    - CompactLLMCommandGenerator
     - MultiStepLLMCommandGenerator
     - EnterpriseSearchPolicy
     - IntentlessPolicy
@@ -235,6 +271,11 @@ def record_callable_duration_metrics(
             SINGLE_STEP_LLM_COMMAND_GENERATOR_LLM_RESPONSE_DURATION_METRIC_NAME
         )
 
+    if type(self) == CompactLLMCommandGenerator:
+        metric_instrument = instrument_provider.get_instrument(
+            COMPACT_LLM_COMMAND_GENERATOR_LLM_RESPONSE_DURATION_METRIC_NAME
+        )
+
     if type(self) == MultiStepLLMCommandGenerator:
         metric_instrument = instrument_provider.get_instrument(
             MULTI_STEP_LLM_COMMAND_GENERATOR_LLM_RESPONSE_DURATION_METRIC_NAME

rasa/tracing/metric_instrument_provider.py

@@ -4,6 +4,10 @@ from opentelemetry.metrics import get_meter_provider
 from opentelemetry.sdk.metrics import Meter
 
 from rasa.tracing.constants import (
+    COMPACT_LLM_COMMAND_GENERATOR_CPU_USAGE_METRIC_NAME,
+    COMPACT_LLM_COMMAND_GENERATOR_LLM_RESPONSE_DURATION_METRIC_NAME,
+    COMPACT_LLM_COMMAND_GENERATOR_MEMORY_USAGE_METRIC_NAME,
+    COMPACT_LLM_COMMAND_GENERATOR_PROMPT_TOKEN_USAGE_METRIC_NAME,
     CONTEXTUAL_RESPONSE_REPHRASER_LLM_RESPONSE_DURATION_METRIC_NAME,
     DURATION_UNIT_NAME,
     ENTERPRISE_SEARCH_POLICY_LLM_RESPONSE_DURATION_METRIC_NAME,
@@ -43,6 +47,7 @@ class MetricInstrumentProvider(metaclass=Singleton):
         instruments = {
             **self._create_llm_command_generator_instruments(meter),
             **self._create_single_step_llm_command_generator_instruments(meter),
+            **self._create_compact_llm_command_generator_instruments(meter),
             **self._create_multi_step_llm_command_generator_instruments(meter),
             **self._create_llm_response_duration_instruments(meter),
             **self._create_client_request_instruments(meter),
@@ -122,6 +127,41 @@ class MetricInstrumentProvider(metaclass=Singleton):
             SINGLE_STEP_LLM_COMMAND_GENERATOR_LLM_RESPONSE_DURATION_METRIC_NAME: single_step_llm_response_duration_llm_command_generator,  # noqa: E501
         }
 
+    @staticmethod
+    def _create_compact_llm_command_generator_instruments(
+        meter: Meter,
+    ) -> Dict[str, Any]:
+        compact_llm_command_generator_cpu_usage = meter.create_histogram(
+            name=COMPACT_LLM_COMMAND_GENERATOR_CPU_USAGE_METRIC_NAME,
+            description="CPU percentage for CompactLLMCommandGenerator",
+            unit=LLM_BASED_COMMAND_GENERATOR_CPU_MEMORY_USAGE_UNIT_NAME,
+        )
+
+        compact_llm_command_generator_memory_usage = meter.create_histogram(
+            name=COMPACT_LLM_COMMAND_GENERATOR_MEMORY_USAGE_METRIC_NAME,
+            description="RAM memory usage for CompactLLMCommandGenerator",
+            unit=LLM_BASED_COMMAND_GENERATOR_CPU_MEMORY_USAGE_UNIT_NAME,
+        )
+
+        compact_llm_command_generator_prompt_token_usage = meter.create_histogram(
+            name=COMPACT_LLM_COMMAND_GENERATOR_PROMPT_TOKEN_USAGE_METRIC_NAME,
+            description="CompactLLMCommandGenerator prompt token length",
+            unit="1",
+        )
+
+        compact_llm_response_duration_llm_command_generator = meter.create_histogram(
+            name=COMPACT_LLM_COMMAND_GENERATOR_LLM_RESPONSE_DURATION_METRIC_NAME,
+            description="The duration of CompactLLMCommandGenerator's LLM call",
+            unit=DURATION_UNIT_NAME,
+        )
+
+        return {
+            COMPACT_LLM_COMMAND_GENERATOR_CPU_USAGE_METRIC_NAME: compact_llm_command_generator_cpu_usage,  # noqa: E501
+            COMPACT_LLM_COMMAND_GENERATOR_MEMORY_USAGE_METRIC_NAME: compact_llm_command_generator_memory_usage,  # noqa: E501
+            COMPACT_LLM_COMMAND_GENERATOR_PROMPT_TOKEN_USAGE_METRIC_NAME: compact_llm_command_generator_prompt_token_usage,  # noqa: E501
+            COMPACT_LLM_COMMAND_GENERATOR_LLM_RESPONSE_DURATION_METRIC_NAME: compact_llm_response_duration_llm_command_generator,  # noqa: E501
+        }
+
     @staticmethod
     def _create_multi_step_llm_command_generator_instruments(
         meter: Meter,