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

rasa/e2e_test/e2e_test_case.py

@@ -1,8 +1,10 @@
-import logging
 from collections import OrderedDict
+from collections import defaultdict
 from dataclasses import dataclass
 from typing import Any, Dict, List, Optional, Text, Union
 
+import structlog
+
 from rasa.e2e_test.assertions import Assertion
 from rasa.e2e_test.constants import (
     KEY_ASSERTIONS,
@@ -20,10 +22,11 @@ from rasa.e2e_test.constants import (
     KEY_USER_INPUT,
 )
 from rasa.e2e_test.stub_custom_action import StubCustomAction
+from rasa.shared.constants import DOCS_BASE_URL
 from rasa.shared.core.events import BotUttered, SlotSet, UserUttered
 from rasa.shared.exceptions import RasaException
 
-logger = logging.getLogger(__name__)
+structlogger = structlog.get_logger(__name__)
 
 
 @dataclass(frozen=True)
@@ -343,9 +346,10 @@ class ActualStepOutput:
             try:
                 return self.user_uttered_events[0]
             except IndexError:
-                logger.debug(
-                    f"Could not find `UserUttered` event in the ActualStepOutput: "
-                    f"{self}"
+                structlogger.debug(
+                    "e2e_test_case.get_user_uttered_event.no_user_uttered_event",
+                    event_info=f"Could not find `UserUttered` event in the "
+                    f"ActualStepOutput: {self}",
                 )
                 return None
         return None
@@ -395,7 +399,7 @@ class TestCase:
             else:
                 steps.append(TestStep.from_dict(step))
 
-        return TestCase(
+        test_case = TestCase(
             name=input_test_case.get(KEY_TEST_CASE, "default"),
             steps=steps,
             file=file,
@@ -405,6 +409,81 @@ class TestCase:
             fixture_names=input_test_case.get(KEY_FIXTURES),
             metadata_name=input_test_case.get(KEY_METADATA),
         )
+        test_case.validate()
+        return test_case
+
+    def validate(self) -> None:
+        """Validates the test case.
+
+        This method calls all validation methods required for the test case.
+        """
+        if self.uses_assertions():
+            self.validate_duplicate_user_messages_metadata()
+
+    def validate_duplicate_user_messages_metadata(self) -> None:
+        """Validates that duplicate user messages use metadata correctly.
+
+        Ensures that each duplicate user message uses unique metadata.
+
+        Raises warnings if any issues are found.
+        """
+        docs_link = (
+            f"{DOCS_BASE_URL}/testing/e2e-testing-assertions/assertions-how-to-guide/"
+            "#how-to-handle-duplicate-user-text-messages-in-the-same-test-case"
+        )
+        no_metadata_event_info = (
+            "Test case '{name}' has duplicate user steps with text '{text}', "
+            "and user step at line {line} lacks metadata. When using "
+            "duplicate user messages, metadata should be set on each step to ensure "
+            f"correct processing. Please refer to the documentation: {docs_link}"
+        )
+        non_unique_metadata_event_info = (
+            "Test case '{name}' has duplicate user steps with text '{text}', "
+            "and user step at line {line} has duplicate metadata "
+            "name '{metadata_name}'. Metadata names should be unique for each user "
+            "step among duplicates. This may cause issues in processing "
+            f"user messages. Please refer to the documentation: {docs_link}"
+        )
+
+        # Use dict[str, list] structure to group steps by user message text to easily
+        # identify and validate instances with duplicate messages and their metadata.
+        message_steps = defaultdict(list)
+
+        # Collect user steps by text
+        for step in self.steps:
+            if step.actor == KEY_USER_INPUT and step.text:
+                message_steps[step.text].append(step)
+
+        # Check for duplicate messages
+        for text, steps in message_steps.items():
+            if len(steps) <= 1:
+                continue
+
+            metadata_names_used = set()
+            for step in steps:
+                if not step.metadata_name:
+                    structlogger.warning(
+                        "e2e_test_case.validate_duplicate_user_messages_metadata.no_metadata",
+                        event_info=no_metadata_event_info.format(
+                            name=self.name,
+                            text=text,
+                            line=step.line,
+                        ),
+                    )
+                    break
+                elif step.metadata_name in metadata_names_used:
+                    structlogger.warning(
+                        "e2e_test_case.validate_duplicate_user_messages_metadata.non_unique_metadata",
+                        event_info=non_unique_metadata_event_info.format(
+                            name=self.name,
+                            text=text,
+                            line=step.line,
+                            metadata_name=step.metadata_name,
+                        ),
+                    )
+                    break
+                else:
+                    metadata_names_used.add(step.metadata_name)
 
     def as_dict(self) -> Dict[Text, Any]:
         """Returns the test case as a dictionary."""

rasa/engine/validation.py

@@ -18,11 +18,10 @@ from typing import (
     List,
 )
 
+import rasa.utils.common
 import structlog
 import typing_utils
-
-import rasa.utils.common
-from rasa.core import IntentlessPolicy
+from rasa.core import IntentlessPolicy, ContextualResponseRephraser
 from rasa.core.policies.policy import PolicyPrediction
 from rasa.core.utils import AvailableEndpoints
 from rasa.dialogue_understanding.coexistence.constants import (
@@ -67,11 +66,13 @@ from rasa.shared.constants import (
     MODEL_GROUP_ID_CONFIG_KEY,
     ROUTER_CONFIG_KEY,
     MODELS_CONFIG_KEY,
-    ROUTER_STRATEGY_CONFIG_KEY,
-    VALID_ROUTER_STRATEGIES,
-    ROUTER_STRATEGIES_REQUIRING_REDIS_CACHE,
-    ROUTER_STRATEGIES_NOT_REQUIRING_CACHE,
+    MODEL_GROUP_CONFIG_KEY,
+    ROUTING_STRATEGY_CONFIG_KEY,
+    VALID_ROUTING_STRATEGIES,
+    ROUTING_STRATEGIES_REQUIRING_REDIS_CACHE,
+    ROUTING_STRATEGIES_NOT_REQUIRING_CACHE,
     REDIS_HOST_CONFIG_KEY,
+    USE_CHAT_COMPLETIONS_ENDPOINT_CONFIG_KEY,
 )
 from rasa.shared.core.constants import ACTION_RESET_ROUTING, ACTION_TRIGGER_CHITCHAT
 from rasa.shared.core.domain import Domain
@@ -890,13 +891,13 @@ def _validate_component_model_client_config(
         # no llm configuration present
         return
 
-    if MODELS_CONFIG_KEY in component_config[key]:
+    if MODEL_GROUP_CONFIG_KEY in component_config[key]:
         model_group_syntax_used.append(True)
-        model_group_ids.append(component_config[key][MODELS_CONFIG_KEY])
+        model_group_ids.append(component_config[key][MODEL_GROUP_CONFIG_KEY])
 
         if len(component_config[key]) > 1:
             print_error_and_exit(
-                f"You specified a '{MODELS_CONFIG_KEY}' for the '{key}' "
+                f"You specified a '{MODEL_GROUP_CONFIG_KEY}' for the '{key}' "
                 f"config key for the component "
                 f"'{component_name or component_config['name']}'. "
                 "No other parameters are allowed under the "
@@ -908,10 +909,9 @@ def _validate_component_model_client_config(
         # check that api_key is not set in config
         if API_KEY in component_config[key]:
             print_error_and_exit(
-                f"You specified '{API_KEY}' in the config for"
-                f"{component_name or component_config['name']}, which "
-                "is not allowed. Set API keys through "
-                "environment variables."
+                f"You specified '{API_KEY}' in the config for "
+                f"'{component_name or component_config['name']}', which is not allowed."
+                " Set API keys through environment variables."
             )
 
 
@@ -936,34 +936,46 @@ def validate_model_client_configuration_setup(config: Dict[str, Any]) -> None:
     model_group_syntax_used: List[bool] = []
     model_group_ids: List[str] = []
 
-    if "pipeline" not in config:
-        return
-
-    for component in config["pipeline"]:
-        for key in [LLM_CONFIG_KEY, EMBEDDINGS_CONFIG_KEY]:
-            _validate_component_model_client_config(
-                component, key, model_group_syntax_used, model_group_ids
-            )
+    for outer_key in ["pipeline", "policies"]:
+        if outer_key not in config or config[outer_key] is None:
+            continue
 
-        # as flow retrieval is not a component itself, we need to
-        # check it separately
-        if FLOW_RETRIEVAL_KEY in component:
-            if EMBEDDINGS_CONFIG_KEY in component[FLOW_RETRIEVAL_KEY]:
+        for component in config[outer_key]:
+            for key in [LLM_CONFIG_KEY, EMBEDDINGS_CONFIG_KEY]:
                 _validate_component_model_client_config(
-                    component[FLOW_RETRIEVAL_KEY],
-                    EMBEDDINGS_CONFIG_KEY,
-                    model_group_syntax_used,
-                    model_group_ids,
-                    component["name"] + "." + FLOW_RETRIEVAL_KEY,
+                    component, key, model_group_syntax_used, model_group_ids
                 )
 
+            # as flow retrieval is not a component itself, we need to
+            # check it separately
+            if FLOW_RETRIEVAL_KEY in component:
+                if EMBEDDINGS_CONFIG_KEY in component[FLOW_RETRIEVAL_KEY]:
+                    _validate_component_model_client_config(
+                        component[FLOW_RETRIEVAL_KEY],
+                        EMBEDDINGS_CONFIG_KEY,
+                        model_group_syntax_used,
+                        model_group_ids,
+                        component["name"] + "." + FLOW_RETRIEVAL_KEY,
+                    )
+
+    # also include the ContextualResponseRephraser component
+    endpoints = AvailableEndpoints.get_instance()
+    if endpoints.nlg is not None:
+        _validate_component_model_client_config(
+            endpoints.nlg.kwargs,
+            LLM_CONFIG_KEY,
+            model_group_syntax_used,
+            model_group_ids,
+            ContextualResponseRephraser.__name__,
+        )
+
     if not is_uniform_bool_list(model_group_syntax_used):
         print_error_and_exit(
             "Some of your components refer to an LLM using the "
-            f"'{MODELS_CONFIG_KEY}' parameter, other components directly"
-            f"define the LLM under the '{LLM_CONFIG_KEY}' or the "
+            f"'{MODEL_GROUP_CONFIG_KEY}' parameter, other components directly"
+            f" define the LLM under the '{LLM_CONFIG_KEY}' or the "
             f"'{EMBEDDINGS_CONFIG_KEY}' key. You cannot use"
-            "a both types of definition. Please chose one syntax "
+            " both types of definitions. Please chose one syntax "
             "and update your config."
         )
 
@@ -1042,31 +1054,42 @@ def _validate_model_group_router_setting(
         if ROUTER_CONFIG_KEY not in model_group:
             continue
 
+        for model_config in model_group.get(MODELS_CONFIG_KEY, []):
+            if USE_CHAT_COMPLETIONS_ENDPOINT_CONFIG_KEY in model_config:
+                print_error_and_exit(
+                    f"You defined the '{USE_CHAT_COMPLETIONS_ENDPOINT_CONFIG_KEY}' in "
+                    f"the model group '{model_group[MODEL_GROUP_ID_CONFIG_KEY]}'. This "
+                    f"key is not allowed in the model configuration as the router is "
+                    f"defined. Please remove this key from your model configuration "
+                    f"and update it in the '{ROUTER_CONFIG_KEY} configuration, as it "
+                    f"is a router level setting."
+                )
+
         router_config = model_group[ROUTER_CONFIG_KEY]
-        if ROUTER_STRATEGY_CONFIG_KEY in router_config:
-            router_strategy = router_config.get(ROUTER_STRATEGY_CONFIG_KEY)
-            if router_strategy and router_strategy not in VALID_ROUTER_STRATEGIES:
+        if ROUTING_STRATEGY_CONFIG_KEY in router_config:
+            routing_strategy = router_config.get(ROUTING_STRATEGY_CONFIG_KEY)
+            if routing_strategy and routing_strategy not in VALID_ROUTING_STRATEGIES:
                 print_error_and_exit(
-                    f"The router strategy you defined for the model group "
-                    f"'{model_group[MODEL_GROUP_ID_CONFIG_KEY]}' is not valid. "
-                    f"Valid router strategies are categorized as follows:\n"
+                    f"The routing strategy '{routing_strategy}' you defined for the "
+                    f"model group '{model_group[MODEL_GROUP_ID_CONFIG_KEY]}' is not "
+                    f"valid. Valid routing strategies are categorized as follows:\n"
                     f"- Strategies requiring Redis caching: "
-                    f"{', '.join(ROUTER_STRATEGIES_REQUIRING_REDIS_CACHE)}\n"
+                    f"{', '.join(ROUTING_STRATEGIES_REQUIRING_REDIS_CACHE)}\n"
                     f"- Strategies not requiring caching: "
-                    f"{', '.join(ROUTER_STRATEGIES_NOT_REQUIRING_CACHE)}"
+                    f"{', '.join(ROUTING_STRATEGIES_NOT_REQUIRING_CACHE)}"
                 )
             if (
-                router_strategy in ROUTER_STRATEGIES_REQUIRING_REDIS_CACHE
+                routing_strategy in ROUTING_STRATEGIES_REQUIRING_REDIS_CACHE
                 and REDIS_HOST_CONFIG_KEY not in router_config
             ):
                 structlogger.warning(
-                    "validation.router_strategy.redis_host_not_defined",
+                    "validation.routing_strategy.redis_host_not_defined",
                     event_info=(
-                        f"The router strategy '{router_strategy}' requires a Redis host"
-                        f" to be defined. Without a Redis host, the system defaults to "
-                        f"'in-memory' caching. Please add the '{REDIS_HOST_CONFIG_KEY}'"
-                        f" to the router configuration for the model group "
-                        f"'{model_group[MODEL_GROUP_ID_CONFIG_KEY]}'."
+                        f"The routing strategy '{routing_strategy}' requires a Redis "
+                        f"host to be defined. Without a Redis host, the system "
+                        f"defaults to 'in-memory' caching. Please add the "
+                        f"'{REDIS_HOST_CONFIG_KEY}' to the router configuration for "
+                        f"the model group '{model_group[MODEL_GROUP_ID_CONFIG_KEY]}'."
                     ),
                 )
 
@@ -1106,17 +1129,22 @@ def _validate_api_key_is_an_environment_variable(
     for model_group in model_groups:
         for model_config in model_group[MODELS_CONFIG_KEY]:
             for key, value in model_config.items():
-                if (
-                    key == API_KEY
-                    and isinstance(value, str)
-                    and not re.match(r"\${(\w+)}", value)
-                ):
-                    print_error_and_exit(
-                        f"You defined the '{API_KEY}' in model group "
-                        f"'{model_group[MODEL_GROUP_ID_CONFIG_KEY]}' as a string. "
-                        f"The '{API_KEY}' must be set as an environment variable. "
-                        f"Please update your config."
-                    )
+                if key == API_KEY:
+                    if isinstance(value, str):
+                        if not re.match(r"\${(\w+)}", value):
+                            print_error_and_exit(
+                                f"You defined the '{API_KEY}' in model group "
+                                f"'{model_group[MODEL_GROUP_ID_CONFIG_KEY]}' as a "
+                                f"string. The '{API_KEY}' must be set as an environment"
+                                f" variable. Please update your config."
+                            )
+                    else:
+                        print_error_and_exit(
+                            f"You should define the '{API_KEY}' in model group "
+                            f"'{model_group[MODEL_GROUP_ID_CONFIG_KEY]}' using the "
+                            f"environment variable syntax - ${{ENV_VARIABLE_NAME}}. "
+                            f"Please update your config."
+                        )
 
 
 def validate_model_group_configuration_setup() -> None:

rasa/model_service.py

@@ -14,6 +14,7 @@ import rasa.utils.licensing
 from urllib.parse import urlparse
 
 from rasa.utils.log_utils import configure_structlog
+from rasa.utils.sanic_error_handler import register_custom_sanic_error_handler
 
 structlogger = structlog.get_logger()
 
@@ -104,6 +105,8 @@ def main() -> None:
     # list all routes
     list_routes(app)
 
+    register_custom_sanic_error_handler(app)
+
     app.run(host="0.0.0.0", port=MODEL_SERVICE_PORT, legacy=True, motd=False)
 
 

rasa/nlu/tokenizers/whitespace_tokenizer.py

@@ -43,8 +43,6 @@ class WhitespaceTokenizer(Tokenizer):
     def __init__(self, config: Dict[Text, Any]) -> None:
         """Initialize the tokenizer."""
         super().__init__(config)
-        self.emoji_pattern = rasa.utils.io.get_emoji_regex()
-
         if "case_sensitive" in self._config:
             rasa.shared.utils.io.raise_warning(
                 "The option 'case_sensitive' was moved from the tokenizers to the "
@@ -64,18 +62,9 @@ class WhitespaceTokenizer(Tokenizer):
         # Path to the dictionaries on the local filesystem.
         return cls(config)
 
-    def remove_emoji(self, text: Text) -> Text:
-        """Remove emoji if the full text, aka token, matches the emoji regex."""
-        match = self.emoji_pattern.fullmatch(text)
-
-        if match is not None:
-            return ""
-
-        return text
-
     def tokenize(self, message: Message, attribute: Text) -> List[Token]:
-        text = message.get(attribute)
-
+        original_text = message.get(attribute)
+        text = rasa.utils.io.remove_emojis(original_text)
         # we need to use regex instead of re, because of
         # https://stackoverflow.com/questions/12746458/python-unicode-regular-expression-matching-failing-with-some-unicode-characters
 
@@ -94,11 +83,11 @@ class WhitespaceTokenizer(Tokenizer):
             text,
         ).split()
 
-        words = [self.remove_emoji(w) for w in words]
         words = [w for w in words if w]
 
         # if we removed everything like smiles `:)`, use the whole text as 1 token
         if not words:
+            text = original_text
             words = [text]
 
         tokens = self._convert_words_to_tokens(words, text)

rasa/server.py

@@ -78,6 +78,7 @@ from rasa.shared.utils.schemas.events import EVENTS_SCHEMA
 from rasa.shared.utils.yaml import validate_training_data
 from rasa.utils.common import TempDirectoryPath, get_temp_dir_name
 from rasa.utils.endpoints import EndpointConfig
+from rasa.utils.sanic_error_handler import register_custom_sanic_error_handler
 
 if TYPE_CHECKING:
     from ssl import SSLContext
@@ -528,7 +529,7 @@ def add_root_route(app: Sanic) -> None:
                 <p>Hello from Rasa: {rasa.__version__}</p>
                 <a href="./webhooks/inspector/inspect.html">Go to the inspector</a>
                 <script>
-                    window.location.replace("./webhooks/inspector/inspect.html");
+                    window.location.replace("./webhooks/socketio/inspect.html");
                 </script>
             </body>
         </html>
@@ -687,6 +688,7 @@ def create_app(
     app = Sanic("rasa_server")
     app.config.RESPONSE_TIMEOUT = response_timeout
     configure_cors(app, cors_origins)
+    register_custom_sanic_error_handler(app)
 
     # Reset Sanic warnings filter that allows the triggering of Sanic warnings
     warnings.filterwarnings("ignore", category=DeprecationWarning, module=r"sanic.*")

rasa/shared/constants.py

@@ -184,19 +184,19 @@ N_REPHRASES_CONFIG_KEY = "n"
 USE_CHAT_COMPLETIONS_ENDPOINT_CONFIG_KEY = "use_chat_completions_endpoint"
 
 ROUTER_CONFIG_KEY = "router"
-ROUTER_STRATEGY_CONFIG_KEY = "router_strategy"
+ROUTING_STRATEGY_CONFIG_KEY = "routing_strategy"
 REDIS_HOST_CONFIG_KEY = "redis_host"
-ROUTER_STRATEGIES_REQUIRING_REDIS_CACHE = [
+ROUTING_STRATEGIES_REQUIRING_REDIS_CACHE = [
     "cost-based-routing",
     "usage-based-routing",
 ]
-ROUTER_STRATEGIES_NOT_REQUIRING_CACHE = [
+ROUTING_STRATEGIES_NOT_REQUIRING_CACHE = [
     "latency-based-routing",
     "least-busy",
     "simple-shuffle",
 ]
-VALID_ROUTER_STRATEGIES = (
-    ROUTER_STRATEGIES_REQUIRING_REDIS_CACHE + ROUTER_STRATEGIES_NOT_REQUIRING_CACHE
+VALID_ROUTING_STRATEGIES = (
+    ROUTING_STRATEGIES_REQUIRING_REDIS_CACHE + ROUTING_STRATEGIES_NOT_REQUIRING_CACHE
 )
 
 MODELS_CONFIG_KEY = "models"

rasa/shared/core/constants.py

@@ -110,8 +110,8 @@ FLOW_SLOT_NAMES = [FLOW_HASHES_SLOT]
 
 # slots for audio timeout
 SLOT_SILENCE_TIMEOUT = "silence_timeout"
-SILENCE_TIMEOUT_DEFAULT_VALUE = 6.0
 SLOT_CONSECUTIVE_SILENCE_TIMEOUTS = "consecutive_silence_timeouts"
+SILENCE_TIMEOUT_DEFAULT_VALUE = 6.0
 SILENCE_SLOTS = [SLOT_SILENCE_TIMEOUT, SLOT_CONSECUTIVE_SILENCE_TIMEOUTS]
 # slots for knowledge base
 SLOT_LISTED_ITEMS = "knowledge_base_listed_objects"

rasa/shared/core/domain.py

@@ -3,7 +3,6 @@ from __future__ import annotations
 import collections
 import copy
 import json
-import math
 import os
 from dataclasses import dataclass
 from functools import cached_property
@@ -58,7 +57,6 @@ from rasa.shared.core.events import SlotSet, UserUttered
 from rasa.shared.core.slots import (
     AnySlot,
     CategoricalSlot,
-    FloatSlot,
     ListSlot,
     Slot,
     TextSlot,
@@ -1084,7 +1082,6 @@ class Domain:
         self._add_knowledge_base_slots()
         self._add_categorical_slot_default_value()
         self._add_session_metadata_slot()
-        self._add_audio_slots()
 
     def _add_categorical_slot_default_value(self) -> None:
         """Add a default value to all categorical slots.
@@ -1139,29 +1136,6 @@ class Domain:
                 )
             )
 
-    def _add_audio_slots(self) -> None:
-        """Add slots relevant for audio channels."""
-        self.slots.append(
-            FloatSlot(
-                rasa.shared.core.constants.SLOT_SILENCE_TIMEOUT,
-                mappings=[],
-                influence_conversation=False,
-                is_builtin=True,
-                initial_value=rasa.shared.core.constants.SILENCE_TIMEOUT_DEFAULT_VALUE,
-                max_value=math.inf,
-            )
-        )
-        self.slots.append(
-            FloatSlot(
-                rasa.shared.core.constants.SLOT_CONSECUTIVE_SILENCE_TIMEOUTS,
-                mappings=[],
-                influence_conversation=False,
-                is_builtin=True,
-                initial_value=0.0,
-                max_value=math.inf,
-            )
-        )
-
     def _add_knowledge_base_slots(self) -> None:
         """Add slots for the knowledge base action to slots.
 

rasa/shared/core/flows/flows_list.py

@@ -234,12 +234,16 @@ class FlowsList:
             [f for f in self.underlying_flows if not f.is_startable_only_via_link()]
         )
 
-    def available_slot_names(self) -> Set[str]:
+    def available_slot_names(
+        self, ask_before_filling: Optional[bool] = None
+    ) -> Set[str]:
         """Get all slot names collected by flows."""
         return {
             step.collect
             for flow in self.underlying_flows
             for step in flow.get_collect_steps()
+            if ask_before_filling is None
+            or step.ask_before_filling == ask_before_filling
         }
 
     def available_custom_actions(self) -> Set[str]:

rasa/shared/providers/_configs/litellm_router_client_config.py

@@ -14,6 +14,7 @@ from rasa.shared.constants import (
     API_TYPE_CONFIG_KEY,
     MODEL_CONFIG_KEY,
     MODEL_LIST_KEY,
+    USE_CHAT_COMPLETIONS_ENDPOINT_CONFIG_KEY,
 )
 from rasa.shared.providers._configs.model_group_config import (
     ModelGroupConfig,
@@ -29,6 +30,7 @@ _LITELLM_UNSUPPORTED_KEYS = [
     PROVIDER_CONFIG_KEY,
     DEPLOYMENT_CONFIG_KEY,
     API_TYPE_CONFIG_KEY,
+    USE_CHAT_COMPLETIONS_ENDPOINT_CONFIG_KEY,
 ]
 
 
@@ -84,6 +86,7 @@ class LiteLLMRouterClientConfig:
 
     _model_group_config: ModelGroupConfig
     router: Dict[str, Any]
+    _use_chat_completions_endpoint: bool = True
     extra_parameters: dict = field(default_factory=dict)
 
     @property
@@ -98,6 +101,14 @@ class LiteLLMRouterClientConfig:
     def litellm_model_list(self) -> List[Dict[str, Any]]:
         return self._convert_models_to_litellm_model_list()
 
+    @property
+    def litellm_router_settings(self) -> Dict[str, Any]:
+        return self._convert_router_to_litellm_router_settings()
+
+    @property
+    def use_chat_completions_endpoint(self) -> bool:
+        return self._use_chat_completions_endpoint
+
     def __post_init__(self) -> None:
         if not self.router:
             message = "Router cannot be empty."
@@ -121,7 +132,6 @@ class LiteLLMRouterClientConfig:
         Returns:
             LiteLLMRouterClientConfig
         """
-
         model_group_config = ModelGroupConfig.from_dict(config)
 
         # Copy config to avoid mutating the original
@@ -130,13 +140,18 @@ class LiteLLMRouterClientConfig:
         config_copy.pop(MODEL_GROUP_ID_CONFIG_KEY, None)
         config_copy.pop(MODELS_CONFIG_KEY, None)
         # Get the router settings
-        router_settings = config_copy.pop(ROUTER_CONFIG_KEY, None)
+        router_settings = config_copy.pop(ROUTER_CONFIG_KEY, {})
+        # Get the use_chat_completions_endpoint setting
+        use_chat_completions_endpoint = router_settings.get(
+            USE_CHAT_COMPLETIONS_ENDPOINT_CONFIG_KEY, True
+        )
         # The rest is considered as extra parameters
         extra_parameters = config_copy
 
         this = LiteLLMRouterClientConfig(
             _model_group_config=model_group_config,
             router=router_settings,
+            _use_chat_completions_endpoint=use_chat_completions_endpoint,
             extra_parameters=extra_parameters,
         )
         return this
@@ -150,14 +165,17 @@ class LiteLLMRouterClientConfig:
         return d
 
     def to_litellm_dict(self) -> dict:
-        litellm_model_list = self._convert_models_to_litellm_model_list()
-        d = {
+        return {
             **self.extra_parameters,
             MODEL_GROUP_ID_CONFIG_KEY: self.model_group_id,
-            MODEL_LIST_KEY: litellm_model_list,
-            ROUTER_CONFIG_KEY: self.router,
+            MODEL_LIST_KEY: self._convert_models_to_litellm_model_list(),
+            ROUTER_CONFIG_KEY: self._convert_router_to_litellm_router_settings(),
         }
-        return d
+
+    def _convert_router_to_litellm_router_settings(self) -> Dict[str, Any]:
+        _router_settings_copy = copy.deepcopy(self.router)
+        _router_settings_copy.pop(USE_CHAT_COMPLETIONS_ENDPOINT_CONFIG_KEY, None)
+        return _router_settings_copy
 
     def _convert_models_to_litellm_model_list(self) -> List[Dict[str, Any]]:
         litellm_model_list = []
@@ -172,7 +190,7 @@ class LiteLLMRouterClientConfig:
             prefix = get_prefix_from_provider(provider)
 
             # Determine whether to use model or deployment key based on the provider.
-            litellm_model_name_without_prefix = (
+            litellm_model_name = (
                 litellm_model_config[DEPLOYMENT_CONFIG_KEY]
                 if provider in DEPLOYMENT_CENTRIC_PROVIDERS
                 else litellm_model_config[MODEL_CONFIG_KEY]
@@ -180,7 +198,9 @@ class LiteLLMRouterClientConfig:
 
             # Set 'model' to a provider prefixed model name e.g. openai/gpt-4
             litellm_model_config[MODEL_CONFIG_KEY] = (
-                f"{prefix}/{litellm_model_name_without_prefix}"
+                litellm_model_name
+                if f"{prefix}/" in litellm_model_name
+                else f"{prefix}/{litellm_model_name}"
             )
 
             # Remove parameters that are None and not supported by LiteLLM.