rasa-pro 3.14.0rc3__py3-none-any.whl → 3.14.1__py3-none-any.whl

rasa/core/policies/flows/agent_executor.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import asyncio
-from typing import Any, Dict, List, Optional, cast
+from typing import Any, Dict, List, Optional, Tuple, cast
 
 import structlog
 
@@ -24,6 +24,7 @@ from rasa.core.policies.flows.flow_step_result import (
     PauseFlowReturnPrediction,
 )
 from rasa.core.utils import get_slot_names_from_exit_conditions
+from rasa.dialogue_understanding.patterns.cancel import CancelPatternFlowStackFrame
 from rasa.dialogue_understanding.patterns.internal_error import (
     InternalErrorPatternFlowStackFrame,
 )
@@ -31,6 +32,7 @@ from rasa.dialogue_understanding.stack.dialogue_stack import DialogueStack
 from rasa.dialogue_understanding.stack.frames.flow_stack_frame import (
     AgentStackFrame,
     AgentState,
+    BaseFlowStackFrame,
 )
 from rasa.shared.agents.utils import get_protocol_type
 from rasa.shared.core.constants import (
@@ -46,9 +48,11 @@ from rasa.shared.core.events import (
     AgentResumed,
     AgentStarted,
     Event,
+    FlowCancelled,
     SlotSet,
     deserialise_events,
 )
+from rasa.shared.core.flows.flows_list import FlowsList
 from rasa.shared.core.flows.steps import (
     CallFlowStep,
 )
@@ -85,6 +89,7 @@ async def run_agent(
     step: CallFlowStep,
     tracker: DialogueStateTracker,
     slots: List[Slot],
+    flows: FlowsList,
 ) -> FlowStepResult:
     """Run an agent call step."""
     structlogger.debug(
@@ -177,9 +182,13 @@ async def run_agent(
     elif output.status == AgentStatus.COMPLETED:
         return _handle_agent_completed(output, final_events, stack, step)
     elif output.status == AgentStatus.FATAL_ERROR:
-        return _handle_agent_fatal_error(output, final_events, stack, step)
+        return _handle_agent_fatal_error(
+            output, final_events, stack, step, flows, tracker
+        )
     else:
-        return _handle_agent_unknown_status(output, final_events, stack, step)
+        return _handle_agent_unknown_status(
+            output, final_events, stack, step, flows, tracker
+        )
 
 
 async def _call_agent_with_retry(
@@ -299,6 +308,8 @@ def _handle_agent_unknown_status(
     final_events: List[Event],
     stack: DialogueStack,
     step: CallFlowStep,
+    flows: FlowsList,
+    tracker: DialogueStateTracker,
 ) -> FlowStepResult:
     """Handle unknown agent status.
 
@@ -307,6 +318,8 @@ def _handle_agent_unknown_status(
         final_events: List of events to be added to the final result
         stack: The dialogue stack
         step: The flow step that called the agent
+        flows: All flows
+        tracker: The dialogue state tracker
 
     Returns:
         FlowStepResult indicating to continue with internal error pattern
@@ -320,8 +333,21 @@ def _handle_agent_unknown_status(
         flow_id=step.flow_id,
         status=output.status,
     )
+    # remove the agent stack frame
     remove_agent_stack_frame(stack, step.call)
     final_events.append(AgentCancelled(agent_id=step.call, flow_id=step.flow_id))
+
+    # cancel the current active flow:
+    # push the cancel pattern stack frame and add the flow cancelled event
+    cancel_pattern_stack_frame, flow_cancelled_event = _cancel_flow(
+        stack, flows, tracker, step
+    )
+    if cancel_pattern_stack_frame:
+        stack.push(cancel_pattern_stack_frame)
+    if flow_cancelled_event:
+        final_events.append(flow_cancelled_event)
+
+    # trigger the internal error pattern
     stack.push(InternalErrorPatternFlowStackFrame())
     return ContinueFlowWithNextStep(events=final_events)
 
@@ -418,6 +444,8 @@ def _handle_agent_fatal_error(
     final_events: List[Event],
     stack: DialogueStack,
     step: CallFlowStep,
+    flows: FlowsList,
+    tracker: DialogueStateTracker,
 ) -> FlowStepResult:
     """Handle fatal error from agent execution.
 
@@ -426,13 +454,15 @@ def _handle_agent_fatal_error(
         final_events: List of events to be added to the final result
         stack: The dialogue stack
         step: The flow step that called the agent
+        flows: All flows
+        tracker: The dialogue state tracker
 
     Returns:
         FlowStepResult indicating to continue with internal error pattern
     """
     output.metadata = output.metadata or {}
     _update_agent_events(final_events, output.metadata)
-    # the agent failed, trigger pattern_internal_error
+    # the agent failed, cancel the current flow and trigger pattern_internal_error
     structlogger.error(
         "flow.step.run_agent.fatal_error",
         agent_name=step.call,
@@ -440,16 +470,66 @@ def _handle_agent_fatal_error(
         flow_id=step.flow_id,
         error_message=output.error_message,
     )
+    # remove the agent stack frame
     remove_agent_stack_frame(stack, step.call)
     final_events.append(
         AgentCancelled(
             agent_id=step.call, flow_id=step.flow_id, reason=output.error_message
         )
     )
+
+    # cancel the current active flow:
+    # push the cancel pattern stack frame and add the flow cancelled event
+    cancel_pattern_stack_frame, flow_cancelled_event = _cancel_flow(
+        stack, flows, tracker, step
+    )
+    if cancel_pattern_stack_frame:
+        stack.push(cancel_pattern_stack_frame)
+    if flow_cancelled_event:
+        final_events.append(flow_cancelled_event)
+
+    # push the internal error pattern stack frame
     stack.push(InternalErrorPatternFlowStackFrame())
     return ContinueFlowWithNextStep(events=final_events)
 
 
+def _cancel_flow(
+    stack: DialogueStack,
+    flows: FlowsList,
+    tracker: DialogueStateTracker,
+    step: CallFlowStep,
+) -> Tuple[Optional[CancelPatternFlowStackFrame], Optional[FlowCancelled]]:
+    """Cancel the current active flow.
+
+    Creates a cancel pattern stack frame and a flow cancelled event.
+    """
+    from rasa.dialogue_understanding.commands import CancelFlowCommand
+
+    cancel_pattern_stack_frame = None
+    flow_cancelled_event = None
+
+    top_frame = stack.top()
+
+    if isinstance(top_frame, BaseFlowStackFrame):
+        flow = flows.flow_by_id(step.flow_id)
+        flow_name = (
+            flow.readable_name(language=tracker.current_language)
+            if flow
+            else step.flow_id
+        )
+
+        canceled_frames = CancelFlowCommand.select_canceled_frames(stack)
+
+        cancel_pattern_stack_frame = CancelPatternFlowStackFrame(
+            canceled_name=flow_name,
+            canceled_frames=canceled_frames,
+        )
+
+        flow_cancelled_event = FlowCancelled(step.flow_id, step.id)
+
+    return cancel_pattern_stack_frame, flow_cancelled_event
+
+
 ################################################################################
 # Create predictions
 ################################################################################

rasa/core/policies/flows/flow_exceptions.py

@@ -5,14 +5,17 @@ from rasa.shared.exceptions import RasaException
 class FlowException(RasaException):
     """Exception that is raised when there is a problem with a flow."""
 
-    pass
+    def __init__(self, message: str = "Flow error occurred") -> None:
+        """Initialize FlowException with a message."""
+        super().__init__(message)
 
 
 class FlowCircuitBreakerTrippedException(FlowException):
     """Exception that is raised when the flow circuit breaker tripped.
 
     The circuit breaker gets tripped when a flow seems to be stuck in
-    executing steps and does not make any progress."""
+    executing steps and does not make any progress.
+    """
 
     def __init__(
         self, dialogue_stack: DialogueStack, number_of_steps_taken: int

rasa/core/policies/flows/flow_executor.py

@@ -650,7 +650,7 @@ async def run_step(
         return _run_link_step(initial_events, stack, step)
 
     elif isinstance(step, CallFlowStep):
-        return await _run_call_step(initial_events, stack, step, tracker, slots)
+        return await _run_call_step(initial_events, stack, step, tracker, slots, flows)
 
     elif isinstance(step, SetSlotsFlowStep):
         return _run_set_slot_step(initial_events, step)
@@ -723,12 +723,13 @@ async def _run_call_step(
     step: CallFlowStep,
     tracker: DialogueStateTracker,
     slots: List[Slot],
+    flows: FlowsList,
 ) -> FlowStepResult:
     structlogger.debug("flow.step.run.call")
     if step.is_calling_mcp_tool():
         return await call_mcp_tool(initial_events, stack, step, tracker)
     elif step.is_calling_agent():
-        return await run_agent(initial_events, stack, step, tracker, slots)
+        return await run_agent(initial_events, stack, step, tracker, slots, flows)
     else:
         stack.push(
             UserFlowStackFrame(

rasa/core/policies/flows/mcp_tool_executor.py

@@ -1,4 +1,5 @@
 import json
+from datetime import timedelta
 from typing import Any, Dict, List, Optional
 
 import structlog
@@ -24,6 +25,7 @@ structlogger = structlog.get_logger()
 
 CONFIG_VALUE = "value"
 CONFIG_SLOT = "slot"
+TOOL_CALL_DEFATULT_TIMEOUT = 10  # seconds
 
 
 async def call_mcp_tool(
@@ -102,7 +104,11 @@ async def _execute_mcp_tool_call(
 
         # Call the tool with parameters
         mcp_server = await mcp_server_connection.ensure_active_session()
-        result = await mcp_server.call_tool(step.call, arguments)
+        result = await mcp_server.call_tool(
+            step.call,
+            arguments,
+            read_timeout_seconds=timedelta(seconds=TOOL_CALL_DEFATULT_TIMEOUT),
+        )
 
         # Handle tool execution result
         if result is None or result.isError:

rasa/core/policies/rule_policy.py

@@ -84,7 +84,7 @@ class InvalidRule(RasaException):
     """Exception that can be raised when rules are not valid."""
 
     def __init__(self, message: Text) -> None:
-        super().__init__()
+        super().__init__(message)
         self.message = message
 
     def __str__(self) -> Text:

rasa/dialogue_understanding/commands/cancel_flow_command.py

@@ -56,7 +56,7 @@ class CancelFlowCommand(Command):
         Returns:
         The frames that were canceled.
         """
-        canceled_frames = []
+        canceled_frames: List[str] = []
         # we need to go through the original stack dump in reverse order
         # to find the frames that were canceled. we cancel everything from
         # the top of the stack until we hit the user flow that was canceled.

rasa/dialogue_understanding/patterns/default_flows_for_patterns.yml

@@ -227,28 +227,30 @@ flows:
       - noop: true
         next:
           - if: context.multiple_flows_interrupted
+            then: collect_interrupted_flow_to_continue
+          - else: collect_continue_interrupted_flow_confirmation
+      - id: collect_interrupted_flow_to_continue
+        collect: interrupted_flow_to_continue
+        description: "Fill this slot with the name of the flow the user wants to continue. If the user does not want to continue any of the interrupted flows, fill this slot with 'none'."
+        next:
+          - if: slots.interrupted_flow_to_continue is not "none"
+            then:
+              - action: action_continue_interrupted_flow
+                next: END
+          - else:
+              - action: action_cancel_interrupted_flows
+                next: END
+      - id: collect_continue_interrupted_flow_confirmation
+        collect: continue_interrupted_flow_confirmation
+        description: "If the user wants to continue the interrupted flow, fill this slot with true. If the user does not want to continue the interrupted flow, fill this slot with false."
+        next:
+          - if: slots.continue_interrupted_flow_confirmation
             then:
-              - collect: interrupted_flow_to_continue
-                description: "Fill this slot with the name of the flow the user wants to continue. If the user does not want to continue any of the interrupted flows, fill this slot with 'none'."
-                next:
-                  - if: slots.interrupted_flow_to_continue != "none"
-                    then:
-                      - action: action_continue_interrupted_flow
-                        next: END
-                  - else:
-                      - action: action_cancel_interrupted_flows
-                        next: END
+              - action: action_continue_interrupted_flow
+                next: END
           - else:
-            - collect: continue_interrupted_flow_confirmation
-              description: "If the user wants to continue the interrupted flow, fill this slot with true. If the user does not want to continue the interrupted flow, fill this slot with false."
-              next:
-                - if: slots.continue_interrupted_flow_confirmation
-                  then:
-                    - action: action_continue_interrupted_flow
-                      next: END
-                - else:
-                    - action: action_cancel_interrupted_flows
-                      next: END
+              - action: action_cancel_interrupted_flows
+                next: END
 
   pattern_correction:
     description: Conversation repair flow for managing user input changes or error corrections

rasa/engine/validation.py

@@ -81,6 +81,7 @@ from rasa.shared.constants import (
     ROUTING_STRATEGIES_NOT_REQUIRING_CACHE,
     ROUTING_STRATEGIES_REQUIRING_REDIS_CACHE,
     ROUTING_STRATEGY_CONFIG_KEY,
+    SECRET_DATA_FORMAT_PATTERN,
     SENSITIVE_DATA,
     USE_CHAT_COMPLETIONS_ENDPOINT_CONFIG_KEY,
     VALID_PROVIDERS_FOR_API_TYPE_CONFIG_KEY,
@@ -1359,7 +1360,10 @@ def _validate_usage_of_environment_variables_in_model_group_config(
         for model_config in model_group[MODELS_CONFIG_KEY]:
             for key, value in model_config.items():
                 if isinstance(value, str):
-                    if re.match(r"\${(\w+)}", value) and key not in allowed_env_vars:
+                    if (
+                        re.match(SECRET_DATA_FORMAT_PATTERN, value)
+                        and key not in allowed_env_vars
+                    ):
                         raise ValidationError(
                             code="engine.validation.validate_model_group_configuration_setup"
                             ".invalid_use_of_environment_variables",
@@ -1386,7 +1390,7 @@ def _validate_sensitive_keys_are_an_environment_variables_for_model_groups(
             for key, value in model_config.items():
                 if key in SENSITIVE_DATA:
                     if isinstance(value, str):
-                        if not re.match(r"\${(\w+)}", value):
+                        if not re.match(SECRET_DATA_FORMAT_PATTERN, value):
                             raise ValidationError(
                                 code="engine.validation.validate_model_group_configuration_setup"
                                 ".sensitive_key_string_value_must_be_set_as_env_var",

rasa/model_manager/runner_service.py

@@ -195,7 +195,7 @@ def fetch_remote_model_to_dir(
     try:
         return persistor.retrieve(model_name=model_name, target_path=target_path)
     except FileNotFoundError as e:
-        raise ModelNotFound() from e
+        raise ModelNotFound("Model not found") from e
 
 
 def fetch_size_of_remote_model(

rasa/privacy/privacy_config.py

@@ -211,7 +211,7 @@ def get_cron_trigger(cron_expression: str) -> CronTrigger:
             "privacy_config.invalid_cron_expression",
             cron=cron_expression,
         )
-        raise RasaException from exc
+        raise RasaException("Invalid cron expression") from exc
 
     return cron
 

rasa/shared/agents/auth/auth_strategy/oauth2_auth_strategy.py

@@ -139,20 +139,17 @@ class OAuth2AuthStrategy(AgentAuthStrategy):
                 resp.raise_for_status()
                 token_data = resp.json()
         except httpx.HTTPStatusError as e:
-            raise ValueError(
-                f"OAuth2 token request failed with status {e.response.status_code}: "
-                f"{e.response.text}"
-            ) from e
+            raise e
         except httpx.RequestError as e:
-            raise ValueError(f"OAuth2 token request failed: {e}") from e
+            raise ValueError(f"OAuth2 token request failed - {e}") from e
         except Exception as e:
             raise ValueError(
-                f"Unexpected error during OAuth2 token request: {e}"
+                f"Unexpected error during OAuth2 token request - {e}"
             ) from e
 
         # Validate token data
         if KEY_ACCESS_TOKEN not in token_data:
-            raise ValueError(f"No {KEY_ACCESS_TOKEN} in OAuth2 response")
+            raise ValueError(f"No `{KEY_ACCESS_TOKEN}` in OAuth2 response")
 
         # Set access token and expires at
         self._access_token = token_data[KEY_ACCESS_TOKEN]

rasa/shared/agents/auth/utils.py

@@ -0,0 +1,85 @@
+"""Utilities for agent authentication and secret validation."""
+
+import re
+from typing import Any, Dict
+
+from rasa.exceptions import ValidationError
+from rasa.shared.agents.auth.constants import (
+    CONFIG_API_KEY_KEY,
+    CONFIG_CLIENT_SECRET_KEY,
+    CONFIG_OAUTH_KEY,
+    CONFIG_TOKEN_KEY,
+)
+from rasa.shared.constants import SECRET_DATA_FORMAT_PATTERN
+
+AUTH_SECRETS = [CONFIG_API_KEY_KEY, CONFIG_TOKEN_KEY, CONFIG_CLIENT_SECRET_KEY]
+
+
+def _is_valid_secret_data_format(value: str) -> bool:
+    """Check if a value is in the correct environment variable format.
+
+    Args:
+        value: The value to check
+
+    Returns:
+        True if the value is in format "${env_var}", False otherwise
+    """
+    if not isinstance(value, str):
+        return False
+
+    # Use the common regex pattern for environment variable validation
+    return bool(re.match(SECRET_DATA_FORMAT_PATTERN, value))
+
+
+def _validate_secret_value(value: Any, key: str, context: str) -> None:
+    """Generic function to validate a single secret value.
+
+    Args:
+        value: The value to validate
+        key: The key name for error messages
+        context: Context for error messages
+            (e.g., "agent 'my_agent'", "MCP server 'my_server'")
+    """
+    if isinstance(value, str):
+        if not _is_valid_secret_data_format(value):
+            raise ValidationError(
+                code="validation.sensitive_key_string_value_must_be_set_as_env_var",
+                event_info=(
+                    f"You defined the '{key}' in {context} as a string. The '{key}' "
+                    f"must be set as an environment variable. Please update your "
+                    f"config."
+                ),
+                key=key,
+            )
+    else:
+        raise ValidationError(
+            code="validation.sensitive_key_must_be_set_as_env_var",
+            event_info=(
+                f"You should define the '{key}' in {context} using the environment "
+                f"variable syntax - ${{ENV_VARIABLE_NAME}}. Please update your config."
+            ),
+            key=key,
+        )
+
+
+def validate_secrets_in_params(
+    params: Dict[str, Any], context_name: str = "configuration"
+) -> None:
+    """Validate that secrets in params are in environment variable format.
+
+    Args:
+        params: The parameters dictionary to validate
+        context_name: Name of the context for error messages
+            (e.g., "agent", "MCP server")
+    """
+    for key, value in params.items():
+        if key in AUTH_SECRETS:
+            _validate_secret_value(value, key, context_name)
+        elif key == CONFIG_OAUTH_KEY and isinstance(value, dict):
+            # Handle oauth object specifically - we know it contains client_secret
+            if CONFIG_CLIENT_SECRET_KEY in value:
+                _validate_secret_value(
+                    value[CONFIG_CLIENT_SECRET_KEY],
+                    CONFIG_CLIENT_SECRET_KEY,
+                    context_name,
+                )

rasa/shared/constants.py

@@ -367,3 +367,6 @@ FAQ_DOCUMENT_LINE_SEPARATOR = "\n"
 
 # Constants for the MCP server
 KEY_TOOL_CALLS = "tool_calls"
+
+# Regex pattern for secrets data validation
+SECRET_DATA_FORMAT_PATTERN = r"\${(\w+)}"

rasa/shared/core/training_data/story_reader/story_reader.py

@@ -126,4 +126,4 @@ class StoryParseError(RasaCoreException, ValueError):
 
     def __init__(self, message: Text) -> None:
         self.message = message
-        super(StoryParseError, self).__init__()
+        super(StoryParseError, self).__init__(message)

rasa/shared/exceptions.py

@@ -16,6 +16,17 @@ class RasaException(Exception):
     to the users, but will be ignored in telemetry.
     """
 
+    def __init__(self, message: str, suppress_stack_trace: bool = False, **kwargs: Any):
+        """Initialize the exception.
+
+        Args:
+            message: The error message.
+            suppress_stack_trace: If True, the stack trace will be suppressed in logs.
+            **kwargs: Additional keyword arguments (e.g., cause for exception chaining).
+        """
+        Exception.__init__(self, message)
+        self.suppress_stack_trace = suppress_stack_trace
+
 
 class RasaCoreException(RasaException):
     """Basic exception for errors raised by Rasa Core."""
@@ -113,6 +124,17 @@ class SchemaValidationError(RasaException, jsonschema.ValidationError):
 class InvalidEntityFormatException(RasaException, json.JSONDecodeError):
     """Raised if the format of an entity is invalid."""
 
+    def __init__(self, msg: str, doc: str = "", pos: int = 0):
+        """Initialize the exception.
+
+        Args:
+            msg: The error message.
+            doc: The document that caused the error.
+            pos: The position in the document where the error occurred.
+        """
+        RasaException.__init__(self, msg)
+        json.JSONDecodeError.__init__(self, msg, doc, pos)
+
     @classmethod
     def create_from(
         cls, other: json.JSONDecodeError, msg: Text
@@ -130,8 +152,7 @@ class ConnectionException(RasaException):
 
 
 class ProviderClientAPIException(RasaException):
-    """Raised for errors that occur during API interactions
-    with LLM / embedding providers.
+    """For errors during API interactions with LLM / embedding providers.
 
     Attributes:
         original_exception (Exception): The original exception that was

rasa/shared/providers/llm/litellm_router_llm_client.py

@@ -151,7 +151,7 @@ class LiteLLMRouterLLMClient(_BaseLiteLLMRouterClient, _BaseLiteLLMClient):
         if not self._use_chat_completions_endpoint:
             return self._text_completion(messages)
         try:
-            formatted_messages = self._format_messages(messages)
+            formatted_messages = self._get_formatted_messages(messages)
             response = self.router_client.completion(
                 messages=formatted_messages, **{**self._completion_fn_args, **kwargs}
             )
@@ -189,7 +189,7 @@ class LiteLLMRouterLLMClient(_BaseLiteLLMRouterClient, _BaseLiteLLMClient):
         if not self._use_chat_completions_endpoint:
             return await self._atext_completion(messages)
         try:
-            formatted_messages = self._format_messages(messages)
+            formatted_messages = self._get_formatted_messages(messages)
             response = await self.router_client.acompletion(
                 messages=formatted_messages, **{**self._completion_fn_args, **kwargs}
             )

rasa/shared/utils/llm.py

@@ -23,6 +23,7 @@ from typing import (
 )
 
 import structlog
+from jinja2 import Environment, select_autoescape
 from pydantic import BaseModel, Field
 
 import rasa.cli.telemetry
@@ -718,6 +719,38 @@ def embedder_client_factory(
     return client
 
 
+def validate_jinja2_template(template_content: Text) -> None:
+    """Validate that a template string has valid Jinja2 syntax.
+
+    Args:
+        template_content: The template content to validate
+
+    Raises:
+        jinja2.exceptions.TemplateSyntaxError: If the template has invalid syntax
+        Exception: If there's an error during validation
+    """
+    # Create environment with custom filters
+    env = Environment(
+        autoescape=select_autoescape(
+            disabled_extensions=["jinja2"],
+            default_for_string=False,
+            default=True,
+        )
+    )
+    # Register filters - lazy import to avoid circular dependencies
+    from rasa.dialogue_understanding.generator._jinja_filters import (
+        to_json_escaped_string,
+    )
+    from rasa.dialogue_understanding.generator.constants import (
+        TO_JSON_ESCAPED_STRING_JINJA_FILTER,
+    )
+
+    env.filters[TO_JSON_ESCAPED_STRING_JINJA_FILTER] = to_json_escaped_string
+
+    # Validate Jinja2 syntax
+    env.from_string(template_content)
+
+
 def get_prompt_template(
     jinja_file_path: Optional[Text],
     default_prompt_template: Text,
@@ -1041,7 +1074,7 @@ def _get_llm_command_generator_config(
 
 
 def _get_compact_llm_command_generator_prompt(
-    config: Dict[Text, Any], endpoints: Dict[Text, Any]
+    config: Dict[Text, Any], model_groups: 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
@@ -1051,7 +1084,7 @@ def _get_compact_llm_command_generator_prompt(
     model_config = _get_llm_command_generator_config(config)
     llm_config = resolve_model_client_config(
         model_config=model_config,
-        model_groups=endpoints.get(MODEL_GROUPS_CONFIG_KEY),
+        model_groups=model_groups,
     )
     return get_default_prompt_template_based_on_model(
         llm_config=llm_config or {},
@@ -1086,7 +1119,7 @@ def get_system_default_prompts(
 
     Args:
         config: The config.yml file data.
-        endpoints: The endpoints.yml file data.
+        endpoints: The endpoints configuration dictionary.
 
     Returns:
         SystemPrompts: A Pydantic model containing all default prompts.
@@ -1095,8 +1128,25 @@ def get_system_default_prompts(
         DEFAULT_RESPONSE_VARIATION_PROMPT_TEMPLATE,
     )
 
+    # The Model Manager / Model API service receives the endpoints configuration
+    # as raw YAML text rather than as a file path. However, both
+    # Configuration.initialise_endpoints() and AvailableEndpoints.read_endpoints()
+    # currently only accept a Path input and do not support loading from in-memory
+    # YAML content.
+
+    # Since these classes only support file-based initialization today, we need
+    # to bootstrap the Configuration with an empty AvailableEndpoints instance for now.
+
+    # IMPORTANT: This configuration must be properly initialized with valid endpoints
+    # and available agents once Studio introduces full support for Agent configurations
+    # (A2A and MCP).
+    Configuration.initialise_empty()
+
+    model_groups = endpoints.get(MODEL_GROUPS_CONFIG_KEY)
     return SystemPrompts(
-        command_generator=_get_compact_llm_command_generator_prompt(config, endpoints),
+        command_generator=_get_compact_llm_command_generator_prompt(
+            config, model_groups
+        ),
         enterprise_search=_get_enterprise_search_prompt(config),
         contextual_response_rephraser=DEFAULT_RESPONSE_VARIATION_PROMPT_TEMPLATE,
     )