rasa-pro 3.14.0.dev20250922__py3-none-any.whl → 3.14.0rc1__py3-none-any.whl

rasa/shared/exceptions.py

@@ -163,9 +163,25 @@ class ProviderClientAPIException(RasaException):
         return s
 
 
+class LLMToolResponseDecodeError(ProviderClientAPIException):
+    """Raised when a JSON decoding error occurs in LLM tool response."""
+
+
 class ProviderClientValidationError(RasaException):
     """Raised for errors that occur during validation of the API client."""
 
 
 class FinetuningDataPreparationException(RasaException):
     """Raised when there is an error in data preparation for fine-tuning."""
+
+
+class AgentInitializationException(RasaException):
+    """Raised when there is an error during the initialization of an agent."""
+
+
+class AgentAuthInitializationException(RasaException):
+    """Raised when there is an error during the initialization of agent auth client."""
+
+
+class AuthenticationError(RasaException):
+    """Raised when there is an authentication error."""

rasa/shared/importers/rasa.py

@@ -74,7 +74,7 @@ class RasaFileImporter(TrainingDataImporter):
     @cached_method
     def get_flows(self) -> FlowsList:
         """Retrieves training stories / rules (see parent class for full docstring)."""
-        return utils.flows_from_paths(self._flow_files)
+        return utils.flows_from_paths(self._flow_files, self.get_domain())
 
     @cached_method
     def get_conversation_tests(self) -> StoryGraph:

rasa/shared/importers/utils.py

@@ -51,8 +51,14 @@ def story_graph_from_paths(
     return StoryGraph(story_steps)
 
 
-def flows_from_paths(files: List[Text]) -> FlowsList:
-    """Returns the flows from paths."""
+def flows_from_paths(files: List[Text], domain: Optional[Domain] = None) -> FlowsList:
+    """Returns the flows from paths.
+
+    Args:
+        files: List of flow file paths to load.
+        domain: Optional domain for validation. If provided, exit_if conditions
+               will be validated against defined slots.
+    """
     from rasa.shared.core.flows.yaml_flows_io import YAMLFlowsReader
 
     flows = FlowsList(underlying_flows=[])
@@ -60,7 +66,7 @@ def flows_from_paths(files: List[Text]) -> FlowsList:
         flows = flows.merge(
             YAMLFlowsReader.read_from_file(file), ignore_duplicates=False
         )
-    flows.validate()
+    flows.validate(domain)
     return flows
 
 

rasa/shared/providers/llm/_base_litellm_client.py

@@ -21,7 +21,7 @@ from rasa.shared.providers._ssl_verification_utils import (
     ensure_ssl_certificates_for_litellm_non_openai_based_clients,
     ensure_ssl_certificates_for_litellm_openai_based_clients,
 )
-from rasa.shared.providers.llm.llm_response import LLMResponse, LLMUsage
+from rasa.shared.providers.llm.llm_response import LLMResponse, LLMToolCall, LLMUsage
 from rasa.shared.utils.io import resolve_environment_variables, suppress_logs
 
 structlogger = structlog.get_logger()
@@ -126,7 +126,9 @@ class _BaseLiteLLMClient:
             raise ProviderClientValidationError(event_info)
 
     @suppress_logs(log_level=logging.WARNING)
-    def completion(self, messages: Union[List[dict], List[str], str]) -> LLMResponse:
+    def completion(
+        self, messages: Union[List[dict], List[str], str], **kwargs: Any
+    ) -> LLMResponse:
         """Synchronously generate completions for given list of messages.
 
         Args:
@@ -138,6 +140,7 @@ class _BaseLiteLLMClient:
                 - a list of messages. Each message is a string and will be formatted
                     as a user message.
                 - a single message as a string which will be formatted as user message.
+            **kwargs: Additional parameters to pass to the completion call.
 
         Returns:
             List of message completions.
@@ -147,15 +150,19 @@ class _BaseLiteLLMClient:
         """
         try:
             formatted_messages = self._get_formatted_messages(messages)
-            arguments = resolve_environment_variables(self._completion_fn_args)
-            response = completion(messages=formatted_messages, **arguments)
+            arguments = cast(
+                Dict[str, Any], resolve_environment_variables(self._completion_fn_args)
+            )
+            response = completion(
+                messages=formatted_messages, **{**arguments, **kwargs}
+            )
             return self._format_response(response)
         except Exception as e:
-            raise ProviderClientAPIException(e)
+            raise ProviderClientAPIException(e) from e
 
     @suppress_logs(log_level=logging.WARNING)
     async def acompletion(
-        self, messages: Union[List[dict], List[str], str]
+        self, messages: Union[List[dict], List[str], str], **kwargs: Any
     ) -> LLMResponse:
         """Asynchronously generate completions for given list of messages.
 
@@ -168,6 +175,7 @@ class _BaseLiteLLMClient:
                 - a list of messages. Each message is a string and will be formatted
                     as a user message.
                 - a single message as a string which will be formatted as user message.
+            **kwargs: Additional parameters to pass to the completion call.
 
         Returns:
             List of message completions.
@@ -177,8 +185,12 @@ class _BaseLiteLLMClient:
         """
         try:
             formatted_messages = self._get_formatted_messages(messages)
-            arguments = resolve_environment_variables(self._completion_fn_args)
-            response = await acompletion(messages=formatted_messages, **arguments)
+            arguments = cast(
+                Dict[str, Any], resolve_environment_variables(self._completion_fn_args)
+            )
+            response = await acompletion(
+                messages=formatted_messages, **{**arguments, **kwargs}
+            )
             return self._format_response(response)
         except Exception as e:
             message = ""
@@ -197,7 +209,7 @@ class _BaseLiteLLMClient:
                     "In case you are getting OpenAI connection errors, such as missing "
                     "API key, your configuration is incorrect."
                 )
-            raise ProviderClientAPIException(e, message)
+            raise ProviderClientAPIException(e, message) from e
 
     def _get_formatted_messages(
         self, messages: Union[List[dict], List[str], str]
@@ -246,12 +258,32 @@ class _BaseLiteLLMClient:
                 else 0
             )
             formatted_response.usage = LLMUsage(prompt_tokens, completion_tokens)
+
+        # Extract tool calls from all choices
+        formatted_response.tool_calls = self._extract_tool_calls(response)
+
         structlogger.debug(
             "base_litellm_client.formatted_response",
             formatted_response=formatted_response.to_dict(),
         )
         return formatted_response
 
+    def _extract_tool_calls(self, response: Any) -> List[LLMToolCall]:
+        """Extract tool calls from response choices.
+
+        Args:
+            response: List of response choices from LiteLLM
+
+        Returns:
+            List of LLMToolCall objects, empty if no tool calls found
+        """
+        return [
+            LLMToolCall.from_litellm(tool_call)
+            for choice in response.choices
+            if choice.message.tool_calls
+            for tool_call in choice.message.tool_calls
+        ]
+
     def _format_text_completion_response(self, response: Any) -> LLMResponse:
         """Parses the LiteLLM text completion response to Rasa format."""
         formatted_response = LLMResponse(

rasa/shared/providers/llm/litellm_router_llm_client.py

@@ -122,7 +122,9 @@ class LiteLLMRouterLLMClient(_BaseLiteLLMRouterClient, _BaseLiteLLMClient):
             raise ProviderClientAPIException(e)
 
     @suppress_logs(log_level=logging.WARNING)
-    def completion(self, messages: Union[List[dict], List[str], str]) -> LLMResponse:
+    def completion(
+        self, messages: Union[List[dict], List[str], str], **kwargs: Any
+    ) -> LLMResponse:
         """
         Synchronously generate completions for given list of messages.
 
@@ -140,6 +142,7 @@ class LiteLLMRouterLLMClient(_BaseLiteLLMRouterClient, _BaseLiteLLMClient):
                 - a list of messages. Each message is a string and will be formatted
                     as a user message.
                 - a single message as a string which will be formatted as user message.
+            **kwargs: Additional parameters to pass to the completion call.
         Returns:
             List of message completions.
         Raises:
@@ -150,7 +153,7 @@ class LiteLLMRouterLLMClient(_BaseLiteLLMRouterClient, _BaseLiteLLMClient):
         try:
             formatted_messages = self._format_messages(messages)
             response = self.router_client.completion(
-                messages=formatted_messages, **self._completion_fn_args
+                messages=formatted_messages, **{**self._completion_fn_args, **kwargs}
             )
             return self._format_response(response)
         except Exception as e:
@@ -158,7 +161,7 @@ class LiteLLMRouterLLMClient(_BaseLiteLLMRouterClient, _BaseLiteLLMClient):
 
     @suppress_logs(log_level=logging.WARNING)
     async def acompletion(
-        self, messages: Union[List[dict], List[str], str]
+        self, messages: Union[List[dict], List[str], str], **kwargs: Any
     ) -> LLMResponse:
         """
         Asynchronously generate completions for given list of messages.
@@ -177,6 +180,7 @@ class LiteLLMRouterLLMClient(_BaseLiteLLMRouterClient, _BaseLiteLLMClient):
                 - a list of messages. Each message is a string and will be formatted
                     as a user message.
                 - a single message as a string which will be formatted as user message.
+            **kwargs: Additional parameters to pass to the completion call.
         Returns:
             List of message completions.
         Raises:
@@ -187,7 +191,7 @@ class LiteLLMRouterLLMClient(_BaseLiteLLMRouterClient, _BaseLiteLLMClient):
         try:
             formatted_messages = self._format_messages(messages)
             response = await self.router_client.acompletion(
-                messages=formatted_messages, **self._completion_fn_args
+                messages=formatted_messages, **{**self._completion_fn_args, **kwargs}
             )
             return self._format_response(response)
         except Exception as e:

rasa/shared/providers/llm/llm_client.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Dict, List, Protocol, Union, runtime_checkable
+from typing import Any, Dict, List, Protocol, Union, runtime_checkable
 
 from rasa.shared.providers.llm.llm_response import LLMResponse
 
@@ -32,7 +32,9 @@ class LLMClient(Protocol):
         """
         ...
 
-    def completion(self, messages: Union[List[dict], List[str], str]) -> LLMResponse:
+    def completion(
+        self, messages: Union[List[dict], List[str], str], **kwargs: Any
+    ) -> LLMResponse:
         """
         Synchronously generate completions for given list of messages.
 
@@ -48,13 +50,14 @@ class LLMClient(Protocol):
                 - a list of messages. Each message is a string and will be formatted
                     as a user message.
                 - a single message as a string which will be formatted as user message.
+            **kwargs: Additional parameters to pass to the completion call.
         Returns:
             LLMResponse
         """
         ...
 
     async def acompletion(
-        self, messages: Union[List[dict], List[str], str]
+        self, messages: Union[List[dict], List[str], str], **kwargs: Any
     ) -> LLMResponse:
         """
         Asynchronously generate completions for given list of messages.
@@ -71,6 +74,7 @@ class LLMClient(Protocol):
                 - a list of messages. Each message is a string and will be formatted
                     as a user message.
                 - a single message as a string which will be formatted as user message.
+            **kwargs: Additional parameters to pass to the completion call.
         Returns:
             LLMResponse
         """

rasa/shared/providers/llm/llm_response.py

@@ -1,9 +1,15 @@
 import functools
+import json
 import time
 from dataclasses import asdict, dataclass, field
 from typing import Any, Awaitable, Callable, Dict, List, Optional, Text, Union
 
 import structlog
+from litellm.utils import ChatCompletionMessageToolCall
+from pydantic import BaseModel
+
+from rasa.shared.constants import KEY_TOOL_CALLS
+from rasa.shared.exceptions import LLMToolResponseDecodeError
 
 structlogger = structlog.get_logger()
 
@@ -38,6 +44,53 @@ class LLMUsage:
         return asdict(self)
 
 
+class LLMToolCall(BaseModel):
+    """A class representing a response from an LLM tool call."""
+
+    id: str
+    """The ID of the tool call."""
+
+    tool_name: str
+    """The name of the tool that was called."""
+
+    tool_args: Dict[str, Any]
+    """The arguments passed to the tool call."""
+
+    type: str = "function"
+    """The type of the tool call."""
+
+    @classmethod
+    def from_dict(cls, data: Dict[Text, Any]) -> "LLMToolCall":
+        """Creates an LLMToolResponse from a dictionary."""
+        return cls(**data)
+
+    @classmethod
+    def from_litellm(cls, data: ChatCompletionMessageToolCall) -> "LLMToolCall":
+        """Creates an LLMToolResponse from a dictionary."""
+        try:
+            tool_args = json.loads(data.function.arguments)
+        except json.JSONDecodeError as e:
+            structlogger.error(
+                "llm_response.litellm_tool_call.invalid_arguments",
+                tool_name=data.function.name,
+                tool_call=data.function.arguments,
+            )
+            raise LLMToolResponseDecodeError(
+                original_exception=e,
+                message=(
+                    f"Invalid arguments for tool call - `{data.function.name}`: "
+                    f"`{data.function.arguments}`"
+                ),
+            ) from e
+
+        return cls(
+            id=data.id,
+            tool_name=data.function.name,
+            tool_args=tool_args,
+            type=data.type,
+        )
+
+
 @dataclass
 class LLMResponse:
     id: str
@@ -62,12 +115,22 @@ class LLMResponse:
     latency: Optional[float] = None
     """Optional field to store the latency of the LLM API call."""
 
+    tool_calls: Optional[List[LLMToolCall]] = None
+    """The list of tool calls the model generated for the input prompt."""
+
     @classmethod
     def from_dict(cls, data: Dict[Text, Any]) -> "LLMResponse":
         """Creates an LLMResponse from a dictionary."""
         usage_data = data.get("usage", {})
         usage_obj = LLMUsage.from_dict(usage_data) if usage_data else None
 
+        tool_calls_data = data.get(KEY_TOOL_CALLS, [])
+        tool_calls_obj = (
+            [LLMToolCall.from_dict(tool) for tool in tool_calls_data]
+            if tool_calls_data
+            else None
+        )
+
         return cls(
             id=data["id"],
             choices=data["choices"],
@@ -76,6 +139,7 @@ class LLMResponse:
             usage=usage_obj,
             additional_info=data.get("additional_info"),
             latency=data.get("latency"),
+            tool_calls=tool_calls_obj,
         )
 
     @classmethod
@@ -92,6 +156,8 @@ class LLMResponse:
         result = asdict(self)
         if self.usage:
             result["usage"] = self.usage.to_dict()
+        if self.tool_calls:
+            result[KEY_TOOL_CALLS] = [tool.model_dump() for tool in self.tool_calls]
         return result
 
 

rasa/shared/providers/llm/self_hosted_llm_client.py

@@ -237,7 +237,7 @@ class SelfHostedLLMClient(_BaseLiteLLMClient):
             raise ProviderClientAPIException(e)
 
     async def acompletion(
-        self, messages: Union[List[dict], List[str], str]
+        self, messages: Union[List[dict], List[str], str], **kwargs: Any
     ) -> LLMResponse:
         """Asynchronous completion of the model with the given messages.
 
@@ -255,15 +255,18 @@ class SelfHostedLLMClient(_BaseLiteLLMClient):
                 - a list of messages. Each message is a string and will be formatted
                     as a user message.
                 - a single message as a string which will be formatted as user message.
+            **kwargs: Additional parameters to pass to the completion call.
 
         Returns:
             The completion response.
         """
         if self._use_chat_completions_endpoint:
-            return await super().acompletion(messages)
+            return await super().acompletion(messages, **kwargs)
         return await self._atext_completion(messages)
 
-    def completion(self, messages: Union[List[dict], List[str], str]) -> LLMResponse:
+    def completion(
+        self, messages: Union[List[dict], List[str], str], **kwargs: Any
+    ) -> LLMResponse:
         """Completion of the model with the given messages.
 
         Method overrides the base class method to call the appropriate
@@ -273,12 +276,13 @@ class SelfHostedLLMClient(_BaseLiteLLMClient):
 
         Args:
             messages: The messages to be used for completion.
+            **kwargs: Additional parameters to pass to the completion call.
 
         Returns:
             The completion response.
         """
         if self._use_chat_completions_endpoint:
-            return super().completion(messages)
+            return super().completion(messages, **kwargs)
         return self._text_completion(messages)
 
     @staticmethod

rasa/shared/utils/common.py

@@ -17,6 +17,7 @@ from typing import (
     Optional,
     Sequence,
     Text,
+    Tuple,
     Type,
 )
 
@@ -102,9 +103,12 @@ def sort_list_of_dicts_by_first_key(dicts: List[Dict]) -> List[Dict]:
 
 def cached_method(f: Callable[..., Any]) -> Callable[..., Any]:
     """Caches method calls based on the call's `args` and `kwargs`.
+
     Works for `async` and `sync` methods. Don't apply this to functions.
+
     Args:
         f: The decorated method whose return value should be cached.
+
     Returns:
         The return value which the method gives for the first call with the given
         arguments.
@@ -358,6 +362,7 @@ def validate_environment(
     component_name: str,
 ) -> None:
     """Make sure all needed requirements for a component are met.
+
     Args:
          required_env_vars: List of environment variables that should be set
          required_packages: List of packages that should be installed
@@ -389,3 +394,22 @@ Sign up at: https://feedback.rasa.com
 {separator}
 """
     print_success(message)
+
+
+def conditional_import(module_name: str, class_name: str) -> Tuple[Any, bool]:
+    """Conditionally import a class, returning (class, is_available) tuple.
+
+    Args:
+        module_name: The module path to import from
+        class_name: The class name to import
+
+    Returns:
+        A tuple of (class, is_available) where class is the imported class
+        or None if import failed, and is_available is a boolean indicating
+        whether the import was successful.
+    """
+    try:
+        module = __import__(module_name, fromlist=[class_name])
+        return getattr(module, class_name), True
+    except ImportError:
+        return None, False

rasa/shared/utils/health_check/health_check.py

@@ -1,7 +1,10 @@
 import os
-from typing import Any, Dict, Optional
+from typing import TYPE_CHECKING, Any, Dict, Optional
 
 from rasa.exceptions import HealthCheckError
+
+if TYPE_CHECKING:
+    pass
 from rasa.shared.constants import (
     LLM_API_HEALTH_CHECK_DEFAULT_VALUE,
     LLM_API_HEALTH_CHECK_ENV_VAR,
@@ -63,6 +66,7 @@ def perform_llm_health_check(
     log_source_component: str,
 ) -> None:
     """Try to instantiate the LLM Client to validate the provided config.
+
     If the LLM_API_HEALTH_CHECK environment variable is true, perform a test call
     to the LLM API. If config contains multiple models, perform a test call for each
     model in the model group.
@@ -125,6 +129,7 @@ def perform_embeddings_health_check(
     log_source_component: str,
 ) -> None:
     """Try to instantiate the Embedder to validate the provided config.
+
     If the LLM_API_HEALTH_CHECK environment variable is true, perform a test call
     to the Embeddings API. If config contains multiple models, perform a test call for
     each model in the model group.
@@ -240,8 +245,7 @@ def send_test_embeddings_api_request(
 
 
 def is_api_health_check_enabled() -> bool:
-    """Determines whether the API health check is enabled based on an environment
-    variable.
+    """Determines whether the API health check is enabled.
 
     Returns:
         bool: True if the API health check is enabled, False otherwise.

rasa/shared/utils/llm.py

@@ -29,7 +29,8 @@ import rasa.cli.telemetry
 import rasa.cli.utils
 import rasa.shared.utils.cli
 import rasa.shared.utils.io
-from rasa.core.available_endpoints import AvailableEndpoints
+from rasa.core.config.available_endpoints import AvailableEndpoints
+from rasa.core.config.configuration import Configuration
 from rasa.shared.constants import (
     CONFIG_NAME_KEY,
     CONFIG_PIPELINE_KEY,
@@ -49,7 +50,15 @@ from rasa.shared.constants import (
     RASA_PATTERN_INTERNAL_ERROR_USER_INPUT_TOO_LONG,
     ROUTER_CONFIG_KEY,
 )
-from rasa.shared.core.events import BotUttered, UserUttered
+from rasa.shared.core.events import (
+    AgentCancelled,
+    AgentCompleted,
+    AgentInterrupted,
+    AgentResumed,
+    AgentStarted,
+    BotUttered,
+    UserUttered,
+)
 from rasa.shared.core.slots import BooleanSlot, CategoricalSlot, Slot
 from rasa.shared.engine.caching import get_local_cache_location
 from rasa.shared.exceptions import (
@@ -112,7 +121,7 @@ DEPLOYMENT_CENTRIC_PROVIDERS = [AZURE_OPENAI_PROVIDER]
 
 # Placeholder messages used in the transcript for
 # instances where user input results in an error
-ERROR_PLACEHOLDER = {
+ERROR_PLACEHOLDER: Dict[str, str] = {
     RASA_PATTERN_INTERNAL_ERROR_USER_INPUT_TOO_LONG: "[User sent really long message]",
     RASA_PATTERN_INTERNAL_ERROR_USER_INPUT_EMPTY: "",
     "default": "[User input triggered an error]",
@@ -225,6 +234,7 @@ def tracker_as_readable_transcript(
     ai_prefix: str = AI,
     max_turns: Optional[int] = 20,
     turns_wrapper: Optional[Callable[[List[str]], List[str]]] = None,
+    highlight_agent_turns: bool = False,
 ) -> str:
     """Creates a readable dialogue from a tracker.
 
@@ -234,6 +244,7 @@ def tracker_as_readable_transcript(
         ai_prefix: the prefix to use for ai utterances
         max_turns: the maximum number of turns to include in the transcript
         turns_wrapper: optional function to wrap the turns in a custom way
+        highlight_agent_turns: whether to highlight agent turns in the transcript
 
     Example:
         >>> tracker = Tracker(
@@ -251,7 +262,9 @@ def tracker_as_readable_transcript(
     Returns:
     A string representing the transcript of the tracker
     """
-    transcript = []
+    transcript: List[str] = []
+
+    current_ai_prefix = ai_prefix
 
     # using `applied_events` rather than `events` means that only events after the
     # most recent `Restart` or `SessionStarted` are included in the transcript
@@ -266,9 +279,20 @@ def tracker_as_readable_transcript(
             else:
                 message = sanitize_message_for_prompt(event.text)
             transcript.append(f"{human_prefix}: {message}")
-
         elif isinstance(event, BotUttered):
-            transcript.append(f"{ai_prefix}: {sanitize_message_for_prompt(event.text)}")
+            transcript.append(
+                f"{current_ai_prefix}: {sanitize_message_for_prompt(event.text)}"
+            )
+
+        if highlight_agent_turns:
+            if isinstance(event, AgentStarted) or isinstance(event, AgentResumed):
+                current_ai_prefix = event.agent_id
+            elif (
+                isinstance(event, AgentCompleted)
+                or isinstance(event, AgentCancelled)
+                or isinstance(event, AgentInterrupted)
+            ):
+                current_ai_prefix = ai_prefix
 
     # turns_wrapper to count multiple utterances by bot/user as single turn
     if turns_wrapper:
@@ -739,7 +763,7 @@ def get_prompt_template(
                 log_source_method=log_source_method,
             )
             return prompt_template
-    except (FileIOException, FileNotFoundException):
+    except (FileIOException, FileNotFoundException) as e:
         structlogger.warning(
             "utils.llm.get_prompt_template" ".failed_to_read_custom_prompt_template",
             event_info=(
@@ -747,6 +771,7 @@ def get_prompt_template(
             ),
             log_source_component=log_source_component,
             log_source_method=log_source_method,
+            error=str(e),
         )
     return default_prompt_template
 
@@ -899,7 +924,7 @@ def resolve_model_client_config(
     if model_groups:
         endpoints = AvailableEndpoints(model_groups=model_groups)
     else:
-        endpoints = AvailableEndpoints.get_instance()
+        endpoints = Configuration.get_instance().endpoints
     if endpoints.model_groups is None:
         _raise_invalid_config_exception(
             reason=(
@@ -1015,14 +1040,12 @@ def _get_llm_command_generator_config(
     return None
 
 
-def _get_command_generator_prompt(
+def _get_compact_llm_command_generator_prompt(
     config: Dict[Text, Any], endpoints: Dict[Text, Any]
 ) -> Text:
     """Get the command generator prompt based on the config."""
     from rasa.dialogue_understanding.generator.single_step.compact_llm_command_generator import (  # noqa: E501
-        DEFAULT_COMMAND_PROMPT_TEMPLATE_FILE_NAME,
-        FALLBACK_COMMAND_PROMPT_TEMPLATE_FILE_NAME,
-        MODEL_PROMPT_MAPPER,
+        CompactLLMCommandGenerator,
     )
 
     model_config = _get_llm_command_generator_config(config)
@@ -1032,9 +1055,9 @@ def _get_command_generator_prompt(
     )
     return get_default_prompt_template_based_on_model(
         llm_config=llm_config 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,
+        model_prompt_mapping=CompactLLMCommandGenerator.get_model_prompt_mapper(),
+        default_prompt_path=CompactLLMCommandGenerator.get_default_prompt_template_file_name(),
+        fallback_prompt_path=CompactLLMCommandGenerator.get_fallback_prompt_template_file_name(),
     )
 
 
@@ -1073,7 +1096,7 @@ def get_system_default_prompts(
     )
 
     return SystemPrompts(
-        command_generator=_get_command_generator_prompt(config, endpoints),
+        command_generator=_get_compact_llm_command_generator_prompt(config, endpoints),
         enterprise_search=_get_enterprise_search_prompt(config),
         contextual_response_rephraser=DEFAULT_RESPONSE_VARIATION_PROMPT_TEMPLATE,
     )