rasa-pro 3.12.7.dev2__py3-none-any.whl → 3.12.9__py3-none-any.whl

rasa/dialogue_understanding/generator/multi_step/multi_step_llm_command_generator.py

@@ -52,6 +52,10 @@ from rasa.shared.exceptions import ProviderClientAPIException
 from rasa.shared.nlu.constants import TEXT
 from rasa.shared.nlu.training_data.message import Message
 from rasa.shared.providers.llm.llm_response import LLMResponse
+from rasa.shared.utils.constants import (
+    LOG_COMPONENT_SOURCE_METHOD_FINGERPRINT_ADDON,
+    LOG_COMPONENT_SOURCE_METHOD_INIT,
+)
 from rasa.shared.utils.io import deep_container_fingerprint, raise_deprecation_warning
 from rasa.shared.utils.llm import (
     allowed_values_for_slot,
@@ -330,6 +334,8 @@ class MultiStepLLMCommandGenerator(LLMBasedCommandGenerator):
         return get_prompt_template(
             config.get("prompt_templates", {}).get(key, {}).get(FILE_PATH_KEY),
             default_value,
+            log_source_component=MultiStepLLMCommandGenerator.__name__,
+            log_source_method=LOG_COMPONENT_SOURCE_METHOD_INIT,
         )
 
     @classmethod
@@ -786,17 +792,24 @@ class MultiStepLLMCommandGenerator(LLMBasedCommandGenerator):
     @classmethod
     def fingerprint_addon(cls, config: Dict[str, Any]) -> Optional[str]:
         """Add a fingerprint for the graph."""
+        get_prompt_template_log_params = {
+            "log_source_component": MultiStepLLMCommandGenerator.__name__,
+            "log_source_method": LOG_COMPONENT_SOURCE_METHOD_FINGERPRINT_ADDON,
+        }
+
         handle_flows_template = get_prompt_template(
             config.get("prompt_templates", {})
             .get(HANDLE_FLOWS_KEY, {})
             .get(FILE_PATH_KEY),
             DEFAULT_HANDLE_FLOWS_TEMPLATE,
+            **get_prompt_template_log_params,
         )
         fill_slots_template = get_prompt_template(
             config.get("prompt_templates", {})
             .get(FILL_SLOTS_KEY, {})
             .get(FILE_PATH_KEY),
             DEFAULT_FILL_SLOTS_TEMPLATE,
+            **get_prompt_template_log_params,
         )
 
         llm_config = resolve_model_client_config(

rasa/dialogue_understanding/generator/single_step/compact_llm_command_generator.py

@@ -1,5 +1,5 @@
 import copy
-from typing import Any, Dict, List, Optional, Text
+from typing import Any, Dict, List, Literal, Optional, Text
 
 import structlog
 
@@ -58,6 +58,10 @@ from rasa.shared.exceptions import ProviderClientAPIException
 from rasa.shared.nlu.constants import LLM_COMMANDS, LLM_PROMPT, TEXT
 from rasa.shared.nlu.training_data.message import Message
 from rasa.shared.providers.llm.llm_response import LLMResponse
+from rasa.shared.utils.constants import (
+    LOG_COMPONENT_SOURCE_METHOD_FINGERPRINT_ADDON,
+    LOG_COMPONENT_SOURCE_METHOD_INIT,
+)
 from rasa.shared.utils.io import deep_container_fingerprint
 from rasa.shared.utils.llm import (
     allowed_values_for_slot,
@@ -187,8 +191,8 @@ class CompactLLMCommandGenerator(LLMBasedCommandGenerator):
         )
 
         # Get the prompt template from the config or the default prompt template.
-        self.prompt_template = self.resolve_component_prompt_template(
-            self.config, prompt_template
+        self.prompt_template = self._resolve_component_prompt_template(
+            self.config, prompt_template, log_context=LOG_COMPONENT_SOURCE_METHOD_INIT
         )
 
         # Set the command syntax version to v2
@@ -539,7 +543,9 @@ class CompactLLMCommandGenerator(LLMBasedCommandGenerator):
         # and update the llm config with the resolved llm config.
         _config_copy = copy.deepcopy(config)
         _config_copy[LLM_CONFIG_KEY] = llm_config
-        prompt_template = cls.resolve_component_prompt_template(_config_copy)
+        prompt_template = cls._resolve_component_prompt_template(
+            _config_copy, log_context=LOG_COMPONENT_SOURCE_METHOD_FINGERPRINT_ADDON
+        )
 
         return deep_container_fingerprint(
             [prompt_template, llm_config, embedding_config]
@@ -555,20 +561,26 @@ class CompactLLMCommandGenerator(LLMBasedCommandGenerator):
         return CommandSyntaxVersion.v2
 
     @staticmethod
-    def resolve_component_prompt_template(
-        config: Dict[str, Any], prompt_template: Optional[str] = None
+    def _resolve_component_prompt_template(
+        config: Dict[str, Any],
+        prompt_template: Optional[str] = None,
+        log_context: Optional[Literal["init", "fingerprint_addon"]] = None,
     ) -> Optional[str]:
         """Get the prompt template from the config or the default prompt template."""
         # Get the default prompt template based on the model name.
         default_command_prompt_template = get_default_prompt_template_based_on_model(
-            config.get(LLM_CONFIG_KEY, {}) or {},
-            MODEL_PROMPT_MAPPER,
-            DEFAULT_COMMAND_PROMPT_TEMPLATE_FILE_NAME,
-            FALLBACK_COMMAND_PROMPT_TEMPLATE_FILE_NAME,
+            llm_config=config.get(LLM_CONFIG_KEY, {}) or {},
+            model_prompt_mapping=MODEL_PROMPT_MAPPER,
+            default_prompt_path=DEFAULT_COMMAND_PROMPT_TEMPLATE_FILE_NAME,
+            fallback_prompt_path=FALLBACK_COMMAND_PROMPT_TEMPLATE_FILE_NAME,
+            log_source_component=CompactLLMCommandGenerator.__name__,
+            log_source_method=log_context,
         )
 
         # Return the prompt template either from the config or the default prompt.
         return prompt_template or get_prompt_template(
             config.get(PROMPT_TEMPLATE_CONFIG_KEY),
             default_command_prompt_template,
+            log_source_component=CompactLLMCommandGenerator.__name__,
+            log_source_method=log_context,
         )

rasa/dialogue_understanding/generator/single_step/single_step_llm_command_generator.py

@@ -1,5 +1,5 @@
 import importlib.resources
-from typing import Any, Dict, Optional, Text
+from typing import Any, Dict, Literal, Optional, Text
 
 import structlog
 
@@ -25,8 +25,12 @@ from rasa.shared.constants import (
     PROMPT_CONFIG_KEY,
     PROMPT_TEMPLATE_CONFIG_KEY,
 )
+from rasa.shared.utils.constants import LOG_COMPONENT_SOURCE_METHOD_FINGERPRINT_ADDON
 from rasa.shared.utils.io import deep_container_fingerprint
-from rasa.shared.utils.llm import get_prompt_template, resolve_model_client_config
+from rasa.shared.utils.llm import (
+    get_prompt_template,
+    resolve_model_client_config,
+)
 
 DEFAULT_COMMAND_PROMPT_TEMPLATE = importlib.resources.read_text(
     "rasa.dialogue_understanding.generator.prompt_templates",
@@ -72,9 +76,6 @@ class SingleStepLLMCommandGenerator(CompactLLMCommandGenerator):
                     "Please use the config parameter 'prompt_template' instead. "
                 ),
             )
-        self.prompt_template = self.resolve_component_prompt_template(
-            config, prompt_template
-        )
 
         # Set the command syntax version to v1
         CommandSyntaxManager.set_syntax_version(
@@ -95,7 +96,9 @@ class SingleStepLLMCommandGenerator(CompactLLMCommandGenerator):
     @classmethod
     def fingerprint_addon(cls: Any, config: Dict[str, Any]) -> Optional[str]:
         """Add a fingerprint for the graph."""
-        prompt_template = cls.resolve_component_prompt_template(config)
+        prompt_template = cls._resolve_component_prompt_template(
+            config, log_context=LOG_COMPONENT_SOURCE_METHOD_FINGERPRINT_ADDON
+        )
         llm_config = resolve_model_client_config(
             config.get(LLM_CONFIG_KEY), SingleStepLLMCommandGenerator.__name__
         )
@@ -117,17 +120,29 @@ class SingleStepLLMCommandGenerator(CompactLLMCommandGenerator):
         return CommandSyntaxVersion.v1
 
     @staticmethod
-    def resolve_component_prompt_template(
-        config: Dict[str, Any], prompt_template: Optional[str] = None
+    def _resolve_component_prompt_template(
+        config: Dict[str, Any],
+        prompt_template: Optional[str] = None,
+        log_context: Optional[Literal["init", "fingerprint_addon"]] = None,
     ) -> Optional[str]:
         """Get the prompt template from the config or the default prompt template."""
-        # Get the default prompt template based on the model name.
-        config_prompt = (
+        # Case when model is being loaded
+        if prompt_template is not None:
+            return prompt_template
+
+        # The prompt can be configured in the config via the "prompt" (deprecated) or
+        # "prompt_template" properties
+        prompt_template_path = (
             config.get(PROMPT_CONFIG_KEY)
             or config.get(PROMPT_TEMPLATE_CONFIG_KEY)
             or None
         )
-        return prompt_template or get_prompt_template(
-            config_prompt,
+
+        # Try to load the template from the given path or fallback to the default for
+        # the component
+        return get_prompt_template(
+            prompt_template_path,
             DEFAULT_COMMAND_PROMPT_TEMPLATE,
+            log_source_component=SingleStepLLMCommandGenerator.__name__,
+            log_source_method=log_context,
         )

rasa/dialogue_understanding_test/du_test_case.py

@@ -241,19 +241,27 @@ class DialogueUnderstandingTestStep(BaseModel):
         # Safely extract commands from the step.
         commands = []
         for command in step.get(KEY_COMMANDS, []):
+            parsed_commands = None
             try:
-                commands.extend(
-                    parse_commands(
-                        command,
-                        flows,
-                        clarify_options_optional=True,
-                        additional_commands=custom_command_classes,
-                        default_commands_to_remove=remove_default_commands,
-                    )
+                parsed_commands = parse_commands(
+                    command,
+                    flows,
+                    clarify_options_optional=True,
+                    additional_commands=custom_command_classes,
+                    default_commands_to_remove=remove_default_commands,
                 )
             except (IndexError, ValueError) as e:
                 raise ValueError(f"Failed to parse command '{command}': {e}") from e
 
+            if not parsed_commands:
+                raise ValueError(
+                    f"Failed to parse command '{command}': command parser returned "
+                    f"None. Please make sure that you are using the correct command "
+                    f"syntax and the command arguments are valid."
+                )
+
+            commands.extend(parsed_commands)
+
         # Construct the DialogueUnderstandingTestStep
         return DialogueUnderstandingTestStep(
             actor=ACTOR_USER if ACTOR_USER in step else ACTOR_BOT,

rasa/llm_fine_tuning/paraphrasing/conversation_rephraser.py

@@ -19,6 +19,7 @@ from rasa.shared.constants import (
 )
 from rasa.shared.exceptions import ProviderClientAPIException
 from rasa.shared.providers.mappings import OPENAI_PROVIDER
+from rasa.shared.utils.constants import LOG_COMPONENT_SOURCE_METHOD_INIT
 from rasa.shared.utils.llm import (
     USER,
     get_prompt_template,
@@ -54,6 +55,8 @@ class ConversationRephraser:
         self.prompt_template = get_prompt_template(
             self.config.get(PROMPT_TEMPLATE_CONFIG_KEY),
             DEFAULT_REPHRASING_PROMPT_TEMPLATE,
+            log_source_component=ConversationRephraser.__name__,
+            log_source_method=LOG_COMPONENT_SOURCE_METHOD_INIT,
         )
 
     @staticmethod

rasa/shared/constants.py

@@ -238,6 +238,7 @@ EXTRA_PARAMETERS_KEY = "extra_parameters"
 MODEL_GROUP_ID_KEY = "model_group_id"
 MODEL_LIST_KEY = "model_list"
 LITELLM_PARAMS_KEY = "litellm_params"
+_VALIDATE_ENVIRONMENT_MISSING_KEYS_KEY = "missing_keys"
 
 LLM_API_HEALTH_CHECK_ENV_VAR = "LLM_API_HEALTH_CHECK"
 LLM_API_HEALTH_CHECK_DEFAULT_VALUE = "false"

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/shared/providers/_utils.py

@@ -1,7 +1,11 @@
+from typing import Any, Dict, Optional
+
 import structlog
 from litellm import validate_environment
 
 from rasa.shared.constants import (
+    API_BASE_CONFIG_KEY,
+    API_VERSION_CONFIG_KEY,
     AWS_ACCESS_KEY_ID_CONFIG_KEY,
     AWS_ACCESS_KEY_ID_ENV_VAR,
     AWS_REGION_NAME_CONFIG_KEY,
@@ -10,6 +14,9 @@ from rasa.shared.constants import (
     AWS_SECRET_ACCESS_KEY_ENV_VAR,
     AWS_SESSION_TOKEN_CONFIG_KEY,
     AWS_SESSION_TOKEN_ENV_VAR,
+    AZURE_API_BASE_ENV_VAR,
+    AZURE_API_VERSION_ENV_VAR,
+    DEPLOYMENT_CONFIG_KEY,
 )
 from rasa.shared.exceptions import ProviderClientValidationError
 from rasa.shared.providers.embedding._base_litellm_embedding_client import (
@@ -77,3 +84,79 @@ def validate_aws_setup_for_litellm_clients(
             missing_environment_variables=missing_environment_variables,
         )
         raise ProviderClientValidationError(event_info)
+
+
+def validate_azure_client_setup(
+    api_base: Optional[str],
+    api_version: Optional[str],
+    deployment: Optional[str],
+) -> None:
+    """Validates the Azure setup for LiteLLM Router clients to ensure
+     that all required configuration parameters are set.
+    Raises:
+        ProviderClientValidationError: If any required Azure configurations
+            is missing.
+    """
+
+    def generate_event_info_for_missing_setting(
+        setting: str,
+        setting_env_var: Optional[str] = None,
+        setting_config_key: Optional[str] = None,
+    ) -> str:
+        """Generate a part of the message with instructions on what to set
+        for the missing client setting.
+        """
+        info = "Set {setting} with {options}. "
+        options = ""
+        if setting_env_var is not None:
+            options += f"environment variable '{setting_env_var}'"
+        if setting_config_key is not None and setting_env_var is not None:
+            options += " or "
+        if setting_config_key is not None:
+            options += f"config key '{setting_config_key}'"
+
+        return info.format(setting=setting, options=options)
+
+    # All required settings for Azure OpenAI client
+    settings: Dict[str, Dict[str, Any]] = {
+        "API Base": {
+            "current_value": api_base,
+            "env_var": AZURE_API_BASE_ENV_VAR,
+            "config_key": API_BASE_CONFIG_KEY,
+        },
+        "API Version": {
+            "current_value": api_version,
+            "env_var": AZURE_API_VERSION_ENV_VAR,
+            "config_key": API_VERSION_CONFIG_KEY,
+        },
+        "Deployment Name": {
+            "current_value": deployment,
+            "env_var": None,
+            "config_key": DEPLOYMENT_CONFIG_KEY,
+        },
+    }
+
+    missing_settings = [
+        setting_name
+        for setting_name, setting_info in settings.items()
+        if setting_info["current_value"] is None
+    ]
+
+    if missing_settings:
+        event_info = f"Client settings not set: {', '.join(missing_settings)}. "
+
+        for missing_setting in missing_settings:
+            if settings[missing_setting]["current_value"] is not None:
+                continue
+            event_info += generate_event_info_for_missing_setting(
+                missing_setting,
+                settings[missing_setting]["env_var"],
+                settings[missing_setting]["config_key"],
+            )
+
+        structlogger.error(
+            "azure_openai_llm_client.not_configured",
+            event_info=event_info,
+            missing_settings=missing_settings,
+        )
+        raise ProviderClientValidationError(event_info)