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

rasa/shared/providers/router/_base_litellm_router_client.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import os
+from copy import deepcopy
 from typing import Any, Dict, List
 
 import structlog
@@ -18,6 +19,7 @@ from rasa.shared.constants import (
     USE_CHAT_COMPLETIONS_ENDPOINT_CONFIG_KEY,
 )
 from rasa.shared.exceptions import ProviderClientValidationError
+from rasa.shared.providers._configs.azure_entra_id_config import AzureEntraIDOAuthConfig
 from rasa.shared.providers._configs.litellm_router_client_config import (
     LiteLLMRouterClientConfig,
 )
@@ -61,12 +63,8 @@ class _BaseLiteLLMRouterClient:
         self._extra_parameters = kwargs or {}
         self.additional_client_setup()
         try:
-            resolved_model_configurations = (
-                self._resolve_env_vars_in_model_configurations()
-            )
-            self._router_client = Router(
-                model_list=resolved_model_configurations, **router_settings
-            )
+            # We instantiate a router client here to validate the configuration.
+            self._router_client = self._create_router_client()
         except Exception as e:
             event_info = "Cannot instantiate a router client."
             structlogger.error(
@@ -145,6 +143,14 @@ class _BaseLiteLLMRouterClient:
     @property
     def router_client(self) -> Router:
         """Returns the instantiated LiteLLM Router client."""
+        # In ca se oauth is used, due to a bug in LiteLLM,
+        # azure_ad_token_provider is not working as expected.
+        # To work around this, we create a new client every
+        # time we need to make a call which will
+        # ensure that the token is always fresh.
+        # GitHub issue for LiteLLm: https://github.com/BerriAI/litellm/issues/4417
+        if self._has_oauth():
+            return self._create_router_client()
         return self._router_client
 
     @property
@@ -175,11 +181,36 @@ class _BaseLiteLLMRouterClient:
             **self._litellm_extra_parameters,
         }
 
+    def _create_router_client(self) -> Router:
+        resolved_model_configurations = self._resolve_env_vars_in_model_configurations()
+        return Router(model_list=resolved_model_configurations, **self.router_settings)
+
+    def _has_oauth(self) -> bool:
+        for model_configuration in self.model_configurations:
+            if model_configuration.get("litellm_params", {}).get("oauth", None):
+                return True
+        return False
+
     def _resolve_env_vars_in_model_configurations(self) -> List:
         model_configuration_with_resolved_keys = []
         for model_configuration in self.model_configurations:
             resolved_model_configuration = resolve_environment_variables(
-                model_configuration
+                deepcopy(model_configuration)
             )
+
+            if not isinstance(resolved_model_configuration, dict):
+                continue
+
+            lite_llm_params = resolved_model_configuration.get("litellm_params", {})
+            if lite_llm_params.get("oauth", None):
+                oauth_config_dict = lite_llm_params.pop("oauth")
+                oauth_config = AzureEntraIDOAuthConfig.from_dict(oauth_config_dict)
+                credential = oauth_config.create_azure_credential()
+                # token_provider = get_bearer_token_provider(
+                #     credential, *oauth_config.scopes
+                # )
+                resolved_model_configuration["litellm_params"]["azure_ad_token"] = (
+                    credential.get_token(*oauth_config.scopes).token
+                )
             model_configuration_with_resolved_keys.append(resolved_model_configuration)
         return model_configuration_with_resolved_keys

rasa/shared/utils/llm.py

@@ -667,35 +667,94 @@ def get_prompt_template(
     """
     try:
         if jinja_file_path is not None:
-            return rasa.shared.utils.io.read_file(jinja_file_path)
+            prompt_template = rasa.shared.utils.io.read_file(jinja_file_path)
+            structlogger.info(
+                "utils.llm.get_prompt_template.custom_prompt_template_read_successfull",
+                event_info=(
+                    f"Custom prompt template read successfully from "
+                    f"`{jinja_file_path}`."
+                ),
+                prompt_file_path=jinja_file_path,
+            )
+            return prompt_template
     except (FileIOException, FileNotFoundException):
         structlogger.warning(
-            "Failed to read custom prompt template. Using default template instead.",
-            jinja_file_path=jinja_file_path,
+            "utils.llm.get_prompt_template.failed_to_read_custom_prompt_template",
+            event_info=(
+                "Failed to read custom prompt template. Using default template instead."
+            ),
         )
     return default_prompt_template
 
 
 def get_default_prompt_template_based_on_model(
-    config: Dict[str, Any],
+    llm_config: Dict[str, Any],
     model_prompt_mapping: Dict[str, Any],
+    default_prompt_path: str,
     fallback_prompt_path: str,
 ) -> Text:
     """Returns the default prompt template based on the model name.
 
     Args:
-        config: The model config.
+        llm_config: The model config.
         model_prompt_mapping: The mapping of model name to prompt template.
-        fallback_prompt_path: The fallback prompt path.
+        default_prompt_path: The default prompt path of the component.
+        fallback_prompt_path: The fallback prompt path for all other models
+            that do not have a mapping in the model_prompt_mapping.
 
     Returns:
         The default prompt template.
     """
-    provider = config.get(PROVIDER_CONFIG_KEY)
-    model = config.get(MODEL_CONFIG_KEY, "")
+    _llm_config = deepcopy(llm_config)
+    if MODELS_CONFIG_KEY in _llm_config:
+        _llm_config = _llm_config[MODELS_CONFIG_KEY][0]
+    provider = _llm_config.get(PROVIDER_CONFIG_KEY)
+    model = _llm_config.get(MODEL_CONFIG_KEY)
+    if not model:
+        # If the model is not defined, we default to the default prompt template.
+        structlogger.info(
+            "utils.llm.get_default_prompt_template_based_on_model.using_default_prompt_template",
+            event_info=(
+                f"Model not defined in the config. Default prompt template read from"
+                f" - `{default_prompt_path}`."
+            ),
+            default_prompt_path=default_prompt_path,
+        )
+        return importlib.resources.read_text(
+            DEFAULT_PROMPT_PACKAGE_NAME, default_prompt_path
+        )
+
     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)
+    if prompt_file_path := model_prompt_mapping.get(model_name):
+        # If the model is found in the mapping, we use the model-specific prompt
+        # template.
+        structlogger.info(
+            "utils.llm.get_default_prompt_template_based_on_model.using_model_specific_prompt_template",
+            event_info=(
+                f"Using model-specific default prompt template. Default prompt "
+                f"template read from - `{prompt_file_path}`."
+            ),
+            default_prompt_path=prompt_file_path,
+            model_name=model_name,
+        )
+        return importlib.resources.read_text(
+            DEFAULT_PROMPT_PACKAGE_NAME, prompt_file_path
+        )
+
+    # If the model is not found in the mapping, we default to the fallback prompt
+    # template.
+    structlogger.info(
+        "utils.llm.get_default_prompt_template_based_on_model.using_fallback_prompt_template",
+        event_info=(
+            f"Model not found in the model prompt mapping. Fallback prompt template "
+            f"read from - `{fallback_prompt_path}`."
+        ),
+        fallback_prompt_path=fallback_prompt_path,
+        model_name=model_name,
+    )
+    return importlib.resources.read_text(
+        DEFAULT_PROMPT_PACKAGE_NAME, fallback_prompt_path
+    )
 
 
 def allowed_values_for_slot(slot: Slot) -> Union[str, None]:

rasa/telemetry.py

@@ -15,7 +15,7 @@ from collections import defaultdict
 from datetime import datetime
 from functools import wraps
 from pathlib import Path
-from typing import Any, Callable, Dict, List, Optional, Text, Tuple
+from typing import Any, Callable, Dict, List, Optional, Text, Tuple, Type, cast
 
 import importlib_resources
 import requests
@@ -1126,12 +1126,12 @@ def _get_llm_command_generator_config(config: Dict[str, Any]) -> Optional[Dict]:
     """
     from rasa.dialogue_understanding.generator import (
         CompactLLMCommandGenerator,
+        LLMBasedCommandGenerator,
         LLMCommandGenerator,
         MultiStepLLMCommandGenerator,
         SingleStepLLMCommandGenerator,
     )
     from rasa.dialogue_understanding.generator.constants import (
-        DEFAULT_LLM_CONFIG,
         FLOW_RETRIEVAL_KEY,
         LLM_CONFIG_KEY,
     )
@@ -1162,6 +1162,12 @@ def _get_llm_command_generator_config(config: Dict[str, Any]) -> Optional[Dict]:
 
     def extract_llm_command_generator_llm_client_settings(component: Dict) -> Dict:
         """Extracts settings related to LLM command generator."""
+        component_class_lookup = {
+            LLMCommandGenerator.__name__: LLMCommandGenerator,
+            SingleStepLLMCommandGenerator.__name__: SingleStepLLMCommandGenerator,
+            MultiStepLLMCommandGenerator.__name__: MultiStepLLMCommandGenerator,
+            CompactLLMCommandGenerator.__name__: CompactLLMCommandGenerator,
+        }
         llm_config = component.get(LLM_CONFIG_KEY, {})
         # Config at this stage is not yet resolved, so read from `model_group`
         llm_model_group_id = llm_config.get(MODEL_GROUP_CONFIG_KEY)
@@ -1169,7 +1175,11 @@ def _get_llm_command_generator_config(config: Dict[str, Any]) -> Optional[Dict]:
             MODEL_NAME_CONFIG_KEY
         )
         if llm_model_group_id is None and llm_model_name is None:
-            llm_model_name = DEFAULT_LLM_CONFIG[MODEL_CONFIG_KEY]
+            component_clz = cast(
+                Type[LLMBasedCommandGenerator],
+                component_class_lookup[component["name"]],
+            )
+            llm_model_name = component_clz.get_default_llm_config()[MODEL_CONFIG_KEY]
 
         custom_prompt_used = (
             PROMPT_CONFIG_KEY in component or PROMPT_TEMPLATE_CONFIG_KEY in component

rasa/tracing/instrumentation/attribute_extractors.py

@@ -58,9 +58,7 @@ from rasa.shared.core.trackers import DialogueStateTracker
 from rasa.shared.core.training_data.structures import StoryGraph
 from rasa.shared.importers.importer import TrainingDataImporter
 from rasa.shared.nlu.constants import INTENT_NAME_KEY, SET_SLOT_COMMAND
-from rasa.shared.utils.llm import (
-    combine_custom_and_default_config,
-)
+from rasa.shared.utils.llm import combine_custom_and_default_config
 from rasa.tracing.constants import (
     PROMPT_TOKEN_LENGTH_ATTRIBUTE_NAME,
     REQUEST_BODY_SIZE_IN_BYTES_ATTRIBUTE_NAME,
@@ -375,14 +373,13 @@ def extract_attrs_for_llm_based_command_generator(
     self: "LLMBasedCommandGenerator",
     prompt: str,
 ) -> Dict[str, Any]:
-    from rasa.dialogue_understanding.generator.constants import DEFAULT_LLM_CONFIG
     from rasa.dialogue_understanding.generator.flow_retrieval import (
         DEFAULT_EMBEDDINGS_CONFIG,
     )
 
     attributes = extract_llm_config(
         self,
-        default_llm_config=DEFAULT_LLM_CONFIG,
+        default_llm_config=self.get_default_llm_config(),
         default_embeddings_config=DEFAULT_EMBEDDINGS_CONFIG,
     )
 

rasa/validator.py

@@ -1429,7 +1429,7 @@ class Validator:
                     event_info=(
                         f"{count} response{' is' if count == 1 else 's are'} "
                         f"missing translations for some languages. "
-                        "Run 'rasa data validate language' for details."
+                        "Run 'rasa data validate translations' for details."
                     ),
                 )
             if flow_warnings:
@@ -1440,7 +1440,7 @@ class Validator:
                     event_info=(
                         f"{count} flow{' is' if count == 1 else 's are'} "
                         f"missing translations for some languages. "
-                        "Run 'rasa data validate language' for details."
+                        "Run 'rasa data validate translations' for details."
                     ),
                 )
         else:

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.0rc1"
+__version__ = "3.12.0rc3"

{rasa_pro-3.12.0rc1.dist-info → rasa_pro-3.12.0rc3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: rasa-pro
-Version: 3.12.0rc1
+Version: 3.12.0rc3
 Summary: State-of-the-art open-core Conversational AI framework for Enterprises that natively leverages generative AI for effortless assistant development.
 Home-page: https://rasa.com
 Keywords: nlp,machine-learning,machine-learning-library,bot,bots,botkit,rasa conversational-agents,conversational-ai,chatbot,chatbot-framework,bot-framework
@@ -64,6 +64,7 @@ Requires-Dist: jsonschema (>=4.22)
 Requires-Dist: keras (==2.14.0)
 Requires-Dist: langchain (>=0.2.0,<0.3.0)
 Requires-Dist: langchain-community (>=0.2.0,<0.3.0)
+Requires-Dist: langcodes (>=3.5.0,<4.0.0)
 Requires-Dist: litellm (>=1.52.6,<1.53.0)
 Requires-Dist: matplotlib (>=3.7,<3.8)
 Requires-Dist: mattermostwrapper (>=2.2,<2.3)
@@ -157,15 +158,14 @@ Description-Content-Type: text/markdown
 
 <div align="center">
 
-[![Build Status](https://github.com/RasaHQ/rasa-private/workflows/Continuous%20Integration/badge.svg)](https://github.com/RasaHQ/rasa-private/actions)
 [![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=RasaHQ_rasa&metric=alert_status)](https://sonarcloud.io/summary/new_code?id=RasaHQ_rasa)
-[![Documentation Status](https://img.shields.io/badge/docs-stable-brightgreen.svg)](https://rasa.com/docs/rasa-pro/)
+[![Documentation Status](https://img.shields.io/badge/docs-stable-brightgreen.svg)](https://rasa.com/docs/docs/pro/intro)
+![Python version support](https://img.shields.io/pypi/pyversions/rasa-pro)
 
 </div>
 
 <hr />
 
-
 Rasa Pro is a framework for building scalable, dynamic conversational AI assistants that integrate large language models (LLMs) to enable more contextually aware and agentic interactions. Whether you’re new to conversational AI or an experienced developer, Rasa Pro offers enhanced flexibility, control, and performance for mission-critical applications.
 
 Building on the foundation of Rasa Open Source, Rasa Pro adds advanced features like CALM (Conversational AI with Language Models) and Dialogue Understanding (DU), which enable developers to shift from traditional intent-driven systems to LLM-based agents. This allows for more robust, responsive interactions that adhere strictly to business logic, while reducing risks like prompt injection and minimizing hallucinations.
@@ -178,20 +178,18 @@ Building on the foundation of Rasa Open Source, Rasa Pro adds advanced features
 - **Robustness and Control:** Maintain strict adherence to business logic, preventing unwanted behaviors like prompt injection and hallucinations, leading to more reliable responses and secure interactions.
 - **Built-in Security:** Safeguard sensitive data, control access, and ensure secure deployment, essential for production environments that demand high levels of security and compliance.
 
+A [free developer license](https://rasa.com/docs/pro/intro/#who-rasa-pro-is-for) is available so you can explore and get to know Rasa Pro. It allows you to take your assistant live in production a limited capacity. A paid license is required for larger-scale production use, but all code is visible and can be customized as needed.
 
+To get started right now, you can
 
-A [free developer license](https://rasa.com/docs/rasa-pro/developer-edition/) is available so you can explore and get to know Rasa Pro. For small production deployments, the Extended Developer License allows you to take your assistant live in a limited capacity. A paid license is required for larger-scale production use, but all code is visible and can be customized as needed.
-
-To get started right now, you can 
-
-`pip install rasa-pro` 
+`pip install rasa-pro`
 
-Check out our 
+Check out our
 
-- [Rasa-pro Quickstart](https://rasa.com/docs/rasa-pro/installation/quickstart/),
-- [Conversational AI with Language Models (CALM) conceptual rundown](https://rasa.com/docs/rasa-pro/calm/),
-- [Rasa Pro / CALM tutorial](https://rasa.com/docs/rasa-pro/tutorial), and
-- [Rasa pro changelog](https://rasa.com/docs/rasa/rasa-pro-changelog/)
+- [Rasa-pro Quickstart](https://rasa.com/docs/learn/quickstart/pro),
+- [Conversational AI with Language Models (CALM) conceptual rundown](https://rasa.com/docs/learn/concepts/calm),
+- [Rasa Pro / CALM tutorial](https://rasa.com/docs/pro/tutorial), and
+- [Rasa pro changelog](https://rasa.com/docs/reference/changelogs/rasa-pro-changelog)
 
 for more. Also feel free to reach out to us on the [Rasa forum](https://forum.rasa.com/).