rasa-pro 3.21.0.dev2__tar.gz → 3.21.0.dev3__tar.gz

{rasa_pro-3.21.0.dev2 → rasa_pro-3.21.0.dev3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rasa-pro
-Version: 3.21.0.dev2
+Version: 3.21.0.dev3
 Summary: State-of-the-art open-core Conversational AI framework for Enterprises that natively leverages generative AI for effortless assistant development.
 License-File: NOTICE
 Keywords: nlp,machine-learning,machine-learning-library,bot,bots,botkit,rasa conversational-agents,conversational-ai,chatbot,chatbot-framework,bot-framework

{rasa_pro-3.21.0.dev2 → rasa_pro-3.21.0.dev3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "rasa-pro"
-version = "3.21.0.dev2"
+version = "3.21.0.dev3"
 description = "State-of-the-art open-core Conversational AI framework for Enterprises that natively leverages generative AI for effortless assistant development."
 authors = [ "Rasa Technologies GmbH <hi@rasa.com>",]
 maintainers = [ "Tom Bocklisch <tom@rasa.com>",]

{rasa_pro-3.21.0.dev2 → rasa_pro-3.21.0.dev3}/rasa/cli/project_env.py

@@ -60,9 +60,10 @@ def resolve_project_dir(
 def load_project_dotenv(cli_project_path: Optional[str] = None) -> None:
     """Load the project's ``.env`` file into ``os.environ``.
 
-    Makes credentials such as ``RASA_LICENSE`` and the LLM keys referenced via
-    ``api_key_env`` in ``integrations.yml`` available even when the process has
-    no shell environment. Existing variables are never overwritten.
+    Makes credentials such as ``RASA_LICENSE`` and the LLM keys referenced by
+    ``api_key`` environment placeholders in ``integrations.yml`` available even
+    when the process has no shell environment. Existing variables are never
+    overwritten.
 
     The file is resolved with :func:`resolve_project_dir`. When the project was
     not explicitly specified (no ``--project-path`` and no

{rasa_pro-3.21.0.dev2 → rasa_pro-3.21.0.dev3}/rasa/cli/project_templates/mantle/integrations.yml

@@ -8,7 +8,7 @@ model_groups:
     models:
       - provider: openai
         model: gpt-5.2
-        api_key_env: OPENAI_API_KEY
+        api_key: ${OPENAI_API_KEY}
 
 channels:
   rest:

{rasa_pro-3.21.0.dev2 → rasa_pro-3.21.0.dev3}/rasa/cli/tools/skills_data/mantle/mantle-configuring-agent/SKILL.md

@@ -122,10 +122,8 @@ Notes:
 
 Holds the model groups, the input channels customers reach the agent through,
 optional MCP servers, and optional Langfuse tracing. Never put a literal key in
-this file. Use `api_key_env` on a model entry, where it names an environment
-variable and works for every provider. `${ENV_VAR}` expansion happens in the
-`channels:` and `mcp_servers:` blocks, which are read with environment variables
-expanded; `llm:` and `model_groups:` are not.
+this file. Use `api_key: ${ENV_VAR}` on a model entry (the whole value must be
+`${ENV_VAR}`). Omit `api_key` for keyless self-hosted servers.
 
 ```yaml integrations.yml
 llm:
@@ -137,7 +135,7 @@ model_groups:
       - provider: openai
         model: gpt-5.1
         api_base: https://api.openai.com/v1
-        api_key_env: OPENAI_API_KEY  # env var NAME, not ${...}
+        api_key: ${OPENAI_API_KEY}
 
 channels:
   rest: { enabled: true }        # REST input (evaluation / HTTP channel)
@@ -458,8 +456,9 @@ See `/mantle/runtime-loop` (Start a conversation).
 
 ## Don't
 
-- Don't put secrets literally in any of these files. Use `api_key_env` on model
-  entries and `${ENV_VAR}` in `channels:` and `mcp_servers:`.
+- Don't put secrets literally in any of these files. Use
+  `api_key: ${ENV_VAR}` on model entries and `${ENV_VAR}` in `channels:` and
+  `mcp_servers:`.
 - Don't nest `rules`, `prompts`, `references`, `conversation`, `tool_timeout`, or
   `session_config` inside the `agent:` block. They are top-level siblings, and
   nesting them is ignored silently.

{rasa_pro-3.21.0.dev2 → rasa_pro-3.21.0.dev3}/rasa/core/channels/inspector-nextgen/e2e/agents/mantle/integrations.yml

@@ -7,7 +7,7 @@ model_groups:
       - provider: openai
         model: gpt-5.1-2025-11-13
         api_base: https://api.openai.com/v1
-        api_key_env: OPENAI_API_KEY
+        api_key: ${OPENAI_API_KEY}
 
 # Input channels for the assistant. In CALM v2, channels are declared here
 # rather than in credentials.yml. Required by the simulation/evaluation

{rasa_pro-3.21.0.dev2 → rasa_pro-3.21.0.dev3}/rasa/core/policies/flows/flow_executor.py

@@ -34,6 +34,8 @@ from rasa.core.policies.flows.flow_step_result import (
 )
 from rasa.core.policies.flows.mcp_tool_executor import call_mcp_tool
 from rasa.core.utils import cancel_flow_and_push_internal_error
+from rasa.dialogue_understanding.patterns.chitchat import ChitchatPatternFlowStackFrame
+from rasa.dialogue_understanding.patterns.clarify import ClarifyPatternFlowStackFrame
 from rasa.dialogue_understanding.patterns.collect_information import (
     FLOW_PATTERN_COLLECT_INFORMATION,
     CollectInformationPatternFlowStackFrame,
@@ -165,6 +167,36 @@ def _continuable_user_flow_frames(
     return continuable
 
 
+def _has_interrupted_agent_without_running_digression_above(
+    stack: DialogueStack, flows: FlowsList
+) -> bool:
+    """Check whether the top-most interrupted agent is waiting to be offered.
+
+    An unfinished INTERRUPT user flow *above* the agent means a later digression
+    interrupted it and is still running; that flow's own completion makes the
+    offer. An INTERRUPT flow *below* the agent is its host and does not count.
+
+    Args:
+        stack: The dialogue stack.
+        flows: All flows, used to tell whether an INTERRUPT flow has steps left.
+
+    Returns:
+        True if an INTERRUPTED agent frame is on the stack and no continuable
+        INTERRUPT user flow sits above the top-most one.
+    """
+    for index in range(len(stack.frames) - 1, -1, -1):
+        frame = stack.frames[index]
+        if isinstance(frame, AgentStackFrame) and frame.state == AgentState.INTERRUPTED:
+            interrupt_frames_above = [
+                frame_above
+                for frame_above in stack.frames[index + 1 :]
+                if isinstance(frame_above, UserFlowStackFrame)
+                and frame_above.frame_type == FlowStackFrameType.INTERRUPT
+            ]
+            return not _continuable_user_flow_frames(interrupt_frames_above, flows)
+    return False
+
+
 def select_next_step_id(
     current: FlowStep,
     condition_evaluation_context: Dict[str, Any],
@@ -407,8 +439,27 @@ def trigger_pattern_continue_interrupted(
         isinstance(current_frame, UserFlowStackFrame)
         and current_frame.frame_type == FlowStackFrameType.INTERRUPT
     )
+
+    # ENG-3395: chitchat and clarification digressions interrupt a waiting agent
+    # too, and the agent frame is left INTERRUPTED. Without this, the agent-calling
+    # flow is walked to its END and the agent frame is silently discarded.
+    #
+    # Deliberately narrower than the search case: pattern_chitchat and
+    # pattern_clarification complete within the same turn they are pushed, so
+    # triggering unconditionally would append a "would you like to continue?"
+    # prompt to every chitchat interjection, and would ask it in the same turn as
+    # the clarification question - capturing the user's clarification answer in
+    # `continue_interrupted_flow_confirmation` instead. Only an interrupted agent
+    # actually needs the offer; a plain flow underneath simply resumes on its own.
+    is_agent_interrupting_pattern = isinstance(
+        current_frame,
+        (ChitchatPatternFlowStackFrame, ClarifyPatternFlowStackFrame),
+    ) and _has_interrupted_agent_without_running_digression_above(stack, flows)
+
     if not (
-        is_user_interrupt or isinstance(current_frame, SearchPatternFlowStackFrame)
+        is_user_interrupt
+        or isinstance(current_frame, SearchPatternFlowStackFrame)
+        or is_agent_interrupting_pattern
     ):
         return None
 

{rasa_pro-3.21.0.dev2 → rasa_pro-3.21.0.dev3}/rasa/engine/validation.py

@@ -96,6 +96,9 @@ from rasa.shared.core.slots import Slot
 from rasa.shared.core.training_data.structures import StoryGraph
 from rasa.shared.exceptions import RasaException
 from rasa.shared.nlu.training_data.message import Message
+from rasa.shared.providers.model_group_validation import (
+    validate_model_group_credentials,
+)
 from rasa.shared.utils.common import display_research_study_prompt
 
 TypeAnnotation = Union[TypeVar, Text, Type, Optional[AvailableEndpoints]]
@@ -1384,44 +1387,6 @@ def _validate_usage_of_environment_variables_in_model_group_config(
                         )
 
 
-def _validate_sensitive_keys_are_an_environment_variables_for_model_groups(
-    model_groups: List[Dict[str, Any]],
-) -> None:
-    # the api key can only be set as 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 in SENSITIVE_DATA:
-                    if isinstance(value, str):
-                        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",
-                                event_info=(
-                                    f"You defined the '{key}' in model group "
-                                    f"'{model_group[MODEL_GROUP_ID_CONFIG_KEY]}' as a "
-                                    f"string. The '{key}' must be set as an "
-                                    f"environment variable. Please update your config."
-                                ),
-                                key=key,
-                                model_group_id=model_group[MODEL_GROUP_ID_CONFIG_KEY],
-                            )
-                    else:
-                        raise ValidationError(
-                            code="engine.validation.validate_model_group_configuration_setup"
-                            ".sensitive_key_must_be_set_as_env_var",
-                            event_info=(
-                                f"You should define the '{key}' in model group "
-                                f"'{model_group[MODEL_GROUP_ID_CONFIG_KEY]}' using the "
-                                f"environment variable syntax - "
-                                f"${{ENV_VARIABLE_NAME}}. "
-                                f"Please update your config."
-                            ),
-                            key=key,
-                            model_group_id=model_group[MODEL_GROUP_ID_CONFIG_KEY],
-                        )
-
-
 def validate_model_group_configuration_setup() -> None:
     """Validates the model group configuration setup in endpoints.yml."""
     endpoints = Configuration.get_instance().endpoints
@@ -1440,9 +1405,7 @@ def validate_model_group_configuration_setup() -> None:
     _validate_usage_of_environment_variables_in_model_group_config(
         endpoints.model_groups
     )
-    _validate_sensitive_keys_are_an_environment_variables_for_model_groups(
-        endpoints.model_groups
-    )
+    validate_model_group_credentials(endpoints.model_groups)
     _validate_model_group_router_setting(endpoints.model_groups)
 
 

{rasa_pro-3.21.0.dev2 → rasa_pro-3.21.0.dev3}/rasa/mantle/config/validation.py

@@ -29,12 +29,18 @@ from rasa.shared.constants import ROUTER_CONFIG_KEY
 from rasa.shared.exceptions import RasaException
 from rasa.shared.project_structure import V2_AGENT_FILE, V2_INTEGRATIONS_FILE
 from rasa.shared.providers._configs.model_group_config import ModelGroupConfig
+from rasa.shared.providers.model_group_validation import (
+    validate_model_group_credentials,
+)
 from rasa.shared.utils.yaml import read_yaml_file
 from rasa.tracing.exceptions import InvalidLangfuseConfigException
 from rasa.tracing.langfuse_config import validate_langfuse_config_mapping
 
 _INVALID_TRACING_CODE = "mantle.validation.config.invalid_tracing"
 _INVALID_MCP_SERVER_CODE = "mantle.validation.config.invalid_mcp_server"
+_INVALID_MODEL_GROUP_CREDENTIALS_CODE = (
+    "mantle.validation.config.invalid_model_group_credentials"
+)
 
 
 def validate_agent(project_root: Path) -> list[ValidationFinding]:
@@ -380,6 +386,7 @@ def _validate_model_groups_section(model_groups: Any) -> list[ValidationFinding]
                 )
             )
             continue
+        findings.extend(_validate_model_group_credentials(entry, index))
         if group.model_group_id in seen_ids:
             findings.append(
                 ValidationFinding(
@@ -412,6 +419,30 @@ def _validate_model_groups_section(model_groups: Any) -> list[ValidationFinding]
     return findings
 
 
+def _validate_model_group_credentials(
+    model_group: dict[str, Any], index: int
+) -> list[ValidationFinding]:
+    """Validate model credentials with the shared CALM model-group rules."""
+    models = model_group.get("models")
+    if not isinstance(models, list):
+        return []
+
+    try:
+        validate_model_group_credentials([model_group])
+    except RasaValidationError as error:
+        return [
+            ValidationFinding(
+                code=_INVALID_MODEL_GROUP_CREDENTIALS_CODE,
+                message=(
+                    f"Model group at index {index} in "
+                    f"'{V2_INTEGRATIONS_FILE}' has invalid credentials: "
+                    f"{error.info or error}"
+                ),
+            )
+        ]
+    return []
+
+
 def _validate_tracing_section(tracing_section: Any) -> list[ValidationFinding]:
     """Validate the optional ``tracing:`` section of ``integrations.yml``.
 

{rasa_pro-3.21.0.dev2 → rasa_pro-3.21.0.dev3}/rasa/mantle/llm/client.py

@@ -19,19 +19,22 @@ Usage::
 
 from __future__ import annotations
 
-import os
-from copy import deepcopy
 from typing import TYPE_CHECKING, Any, Dict, List, Mapping, Optional, Union
 
 import structlog
 
 from rasa.agents.schemas.agent_tool_schema import AgentToolSchema
+from rasa.exceptions import ValidationError
 from rasa.mantle.model_archive.bootstrap import ModelBootstrap
 from rasa.mantle.prompts.messages import LlmMessage
 from rasa.mantle.prompts.token_budget import PROMPT_ONLY_LLM_CONFIG_KEYS
-from rasa.shared.constants import API_KEY
+from rasa.shared.constants import MODELS_CONFIG_KEY
+from rasa.shared.exceptions import InvalidConfigException
 from rasa.shared.providers.llm.llm_client import LLMClient as _ProviderClient
 from rasa.shared.providers.llm.llm_response import LLMResponse, measure_llm_latency
+from rasa.shared.providers.model_group_validation import (
+    validate_model_group_credentials,
+)
 from rasa.shared.utils.llm import acompletion_with_streaming, llm_factory
 
 if TYPE_CHECKING:
@@ -40,7 +43,6 @@ if TYPE_CHECKING:
 structlogger = structlog.get_logger()
 
 _DEFAULT_LLM_CONFIG: Dict[str, Any] = {}
-_API_KEY_ENV_CONFIG_KEY = "api_key_env"
 
 # Provider-supported, non-secret per-call overrides that hooks may set via
 # ``ModelRequestPayload.model_settings``. Credentials, provider/model, and tools
@@ -133,33 +135,6 @@ def resolve_llm_model_name(llm_config: Mapping[str, Any]) -> str:
     return ""
 
 
-def _resolve_api_key_env(config: Dict[str, Any]) -> Dict[str, Any]:
-    """Resolve environment-based credentials throughout a model group."""
-    resolved = deepcopy(config)
-
-    def _resolve(value: Any) -> None:
-        if isinstance(value, dict):
-            env_var_name = value.get(_API_KEY_ENV_CONFIG_KEY)
-            if isinstance(env_var_name, str):
-                value.pop(_API_KEY_ENV_CONFIG_KEY)
-                api_key = os.environ.get(env_var_name)
-                if api_key:
-                    value[API_KEY] = api_key
-                else:
-                    structlogger.warning(
-                        "mantle.llm.api_key_env.not_set",
-                        env_var=env_var_name,
-                    )
-            for nested_value in value.values():
-                _resolve(nested_value)
-        elif isinstance(value, list):
-            for nested_value in value:
-                _resolve(nested_value)
-
-    _resolve(resolved)
-    return resolved
-
-
 def _format_messages_for_log(messages: List[LlmMessage]) -> str:
     """Render the message list as a readable transcript for debug logging.
 
@@ -254,16 +229,22 @@ class LLMClient:
     def from_bootstrap(cls, bootstrap: ModelBootstrap) -> "LLMClient":
         """Build client from the project's integrations.yml LLM config.
 
-        Resolves ``api_key_env`` entries — where the value is an environment
-        variable *name* — into the corresponding ``api_key`` value so the
-        config that reaches ``llm_factory`` never contains the raw
-        ``api_key_env`` key (an engine convention unknown to LiteLLM).
+        Model-group credentials use ``api_key`` environment references, matching
+        the shared CALM model-group configuration.
         """
-        llm_config = _resolve_api_key_env(dict(bootstrap.llm))
+        llm_config = dict(bootstrap.llm)
         # Prompt-construction knobs (e.g. max_prompt_tokens) are not provider
         # settings — strip them before the config reaches llm_factory.
         for prompt_only_key in PROMPT_ONLY_LLM_CONFIG_KEYS:
             llm_config.pop(prompt_only_key, None)
+        if MODELS_CONFIG_KEY in llm_config:
+            try:
+                validate_model_group_credentials([llm_config])
+            except ValidationError as error:
+                raise InvalidConfigException(
+                    "The orchestrator model group has invalid credentials: "
+                    f"{error.info or error}"
+                ) from error
         client = llm_factory(llm_config, _DEFAULT_LLM_CONFIG)
         return cls(client)
 

{rasa_pro-3.21.0.dev2 → rasa_pro-3.21.0.dev3}/rasa/mantle/llm/tool_schemas.py

@@ -22,8 +22,6 @@ Always present; schema is hard-coded.
 * ``cancel_skill`` — abandon the active skill and emit ``FlowCancelled``
 * ``listen`` — end the turn without a message, except on guided collect,
   post-search answer calls, and pending tool confirmation
-* ``hangup`` — end the conversation after a goodbye, except on post-search
-  answer calls and pending tool confirmation (still offered during collect)
 
 Dynamic set_fields tool
 -----------------------
@@ -224,20 +222,6 @@ def should_offer_complete_skill(
     return skill_has_prose(skill)
 
 
-def should_offer_hangup(
-    *,
-    knowledge_searched: bool,
-    pending_tool_confirmation: object | None,
-) -> bool:
-    """Return whether the LLM ``hangup`` tool belongs in this turn's schema.
-
-    Withheld after ``search_knowledge`` and while a tool confirmation is
-    pending, so hangup cannot skip a grounded answer or a confirmation
-    question. Still offered during collect.
-    """
-    return not knowledge_searched and pending_tool_confirmation is None
-
-
 # ---------------------------------------------------------------------------
 # Helpers
 # ---------------------------------------------------------------------------
@@ -383,29 +367,6 @@ def _build_listen_schema() -> Dict[str, Any]:
     }
 
 
-def _build_hangup_schema() -> Dict[str, Any]:
-    """Build the static ``hangup`` schema (no parameters).
-
-    The model calls this to end the conversation after a goodbye. Offered on
-    routing and active-skill turns, including during collect. Withheld on
-    post-search answer calls and pending tool confirmation so hangup cannot
-    skip a grounded answer or a confirmation question.
-    """
-    return {
-        "type": _TOOL_FUNCTION,
-        "function": {
-            "name": TOOL_HANGUP,
-            "description": (
-                "End the conversation after a goodbye. Speak a brief goodbye "
-                "in the same response, then call this. Do not use it to "
-                "finish a skill (complete_skill) or decline a request "
-                "(cannot_help)."
-            ),
-            "parameters": {"type": "object", "properties": {}, "required": []},
-        },
-    }
-
-
 def _build_correct_schema(
     correctable_memory_items: Sequence["CorrectableMemoryItem"],
 ) -> Optional[Dict[str, Any]]:
@@ -898,9 +859,9 @@ def build_llm_tools_for_turn(
         knowledge_searched: Whether ``search_knowledge`` has already been called
             this turn. When ``True``, only ``activate``,
             ``search_knowledge`` and ``cannot_help`` are offered; the active
-            skill's lifecycle, collect, builder, ``listen``, and ``hangup``
+            skill's lifecycle, collect, builder, and ``listen``
             tools are dropped so the grounded answer does not re-drive the
-            skill, end silently, or hang up before presenting the retrieved
+            skill or end silently before presenting the retrieved
             information.
         pending_tool_confirmation: Optional pending confirmation payload when a
             builder tool is paused on ``requires_confirmation``. When set, a
@@ -910,8 +871,7 @@ def build_llm_tools_for_turn(
             orchestrator computes this for the turn (false on guided collect,
             post-search, and pending confirmation). Required so a caller cannot
             omit the engine decision. Post-search and pending confirmation also
-            withhold ``listen`` here even if the flag is ``True``. ``hangup`` is
-            withheld on those same two gates but remains offered during collect.
+            withhold ``listen`` here even if the flag is ``True``.
 
     Returns:
         Canonical :class:`AgentToolSchema` objects. Convert to LiteLLM/OpenAI
@@ -969,17 +929,11 @@ def build_llm_tools_for_turn(
     ):
         schemas.append(_build_listen_schema())
 
-    if should_offer_hangup(
-        knowledge_searched=knowledge_searched,
-        pending_tool_confirmation=pending_tool_confirmation,
-    ):
-        schemas.append(_build_hangup_schema())
-
     # Once search_knowledge has run this turn, the only tools kept are
     # activate + search_knowledge (re-query) plus cannot_help and, when a
     # confirmation is pending, resolve_tool_confirmation. The active skill's
-    # lifecycle / collect / builder / listen / hangup tools are dropped so the
-    # grounded answer does not re-drive the skill, end silently, or hang up;
+    # lifecycle / collect / builder / listen tools are dropped so the
+    # grounded answer does not re-drive the skill or end silently;
     # they return on a later turn once no search has run, or after an activate.
     # Mirrors the active-skill prompt trim.
     if knowledge_searched:

{rasa_pro-3.21.0.dev2 → rasa_pro-3.21.0.dev3}/rasa/mantle/model_archive/bootstrap.py

@@ -32,6 +32,9 @@ from rasa.shared.project_structure import (
     V2_INTEGRATIONS_FILE,
     V2_SNAPSHOT_DIR,
 )
+from rasa.shared.providers.model_group_validation import (
+    validate_model_group_credentials,
+)
 from rasa.shared.utils.llm import resolve_model_client_config
 from rasa.shared.utils.yaml import read_yaml_file
 
@@ -431,6 +434,13 @@ def resolve_integration_llm_config(
         )
 
     result = dict(resolved)
+    try:
+        validate_model_group_credentials([result])
+    except ValidationError as error:
+        raise InvalidConfigException(
+            f"The orchestrator model group in '{V2_INTEGRATIONS_FILE}' has "
+            f"invalid credentials: {error.info or error}"
+        ) from error
     if llm_config.max_prompt_tokens is not None:
         result[MAX_PROMPT_TOKENS_CONFIG_KEY] = llm_config.max_prompt_tokens
     return result

{rasa_pro-3.21.0.dev2 → rasa_pro-3.21.0.dev3}/rasa/mantle/model_archive/references_index.py

@@ -22,6 +22,7 @@ from rasa.core.information_retrieval.ingestion.text_splitter import (
     RecursiveCharacterTextSplitter,
 )
 from rasa.core.policies.enterprise_search_policy_config import DEFAULT_EMBEDDINGS_CONFIG
+from rasa.exceptions import ValidationError
 from rasa.mantle.config.agent_spec import (
     AgentSpec,
     ReferenceChunkingConfig,
@@ -36,6 +37,9 @@ from rasa.shared.project_structure import (
     V2_REFERENCES_DIR,
     V2_SKILLS_DIR,
 )
+from rasa.shared.providers.model_group_validation import (
+    validate_model_group_credentials,
+)
 from rasa.shared.utils.llm import embedder_factory, resolve_model_client_config
 from rasa.shared.utils.yaml import read_config_file
 
@@ -78,6 +82,19 @@ def build_references_embedder(
             "references",
             model_groups=model_groups,
         )
+        if embeddings_config is None:
+            raise InvalidConfigException(
+                f"Could not resolve references embeddings model group "
+                f"'{group_id}' from {V2_INTEGRATIONS_FILE}."
+            )
+        try:
+            validate_model_group_credentials([embeddings_config])
+        except ValidationError as error:
+            raise InvalidConfigException(
+                f"The references embeddings model group '{group_id}' in "
+                f"'{V2_INTEGRATIONS_FILE}' has invalid credentials: "
+                f"{error.info or error}"
+            ) from error
     return embedder_factory(embeddings_config, DEFAULT_EMBEDDINGS_CONFIG)
 
 

{rasa_pro-3.21.0.dev2 → rasa_pro-3.21.0.dev3}/rasa/mantle/orchestration/skill_executor.py

@@ -122,7 +122,6 @@ from rasa.mantle.llm.tool_schemas import (
     TOOL_CANNOT_HELP,
     TOOL_COMPLETE_SKILL,
     TOOL_CORRECT,
-    TOOL_HANGUP,
     TOOL_LISTEN,
     TOOL_RESOLVE_TOOL_CONFIRMATION,
     TOOL_SEARCH_KNOWLEDGE,
@@ -4882,10 +4881,6 @@ class SkillExecutor:
                 "Cannot run other tools while declining the request."
             )
 
-        if tool_name == TOOL_HANGUP:
-            self._hangup_requested = True
-            return json.dumps({"ok": True})
-
         if tool_name == TOOL_ACTIVATE:
             return self._dispatch_activate(tool_args, tracker_handle, memory_values)
         if tool_name == TOOL_COMPLETE_SKILL:

{rasa_pro-3.21.0.dev2 → rasa_pro-3.21.0.dev3}/rasa/mantle/prompts/system_prompt.py

@@ -20,7 +20,6 @@ from typing import TYPE_CHECKING, List, Optional, Sequence
 from rasa.mantle.config.agent_spec import AgentSpec, resolve_ack_enabled
 from rasa.mantle.llm.tool_schemas import (
     should_offer_complete_skill,
-    should_offer_hangup,
 )
 from rasa.mantle.prompts import state
 from rasa.mantle.prompts.memory_lines import (
@@ -199,10 +198,6 @@ def build_system_prompt(
             activate_available,
             context.listen_available,
             complete_skill_available,
-            hangup_available=should_offer_hangup(
-                knowledge_searched=context.knowledge_searched,
-                pending_tool_confirmation=context.pending_tool_confirmation,
-            ),
         )
     )
 
@@ -344,7 +339,6 @@ def _lifecycle_tools_section(
     activate_available: bool,
     listen_available: bool,
     complete_skill_available: bool,
-    hangup_available: bool,
 ) -> str:
     catalog = context.bootstrap.skill_catalog
     active_target_id = state.active_target_id(context.tracker)
@@ -376,7 +370,6 @@ def _lifecycle_tools_section(
         cannot_help_available=cannot_help_available,
         activate_available=activate_available,
         listen_available=listen_available,
-        hangup_available=hangup_available,
     )
 
 

{rasa_pro-3.21.0.dev2 → rasa_pro-3.21.0.dev3}/rasa/mantle/prompts/templates/lifecycle_tools.jinja2

@@ -26,11 +26,6 @@
   and need that answer. Do not call it if the user just asked something, if
   you still owe a reply or another tool, or together with text or other tools.
 {% endif %}
-{% if hangup_available %}
-- When the user is done with the whole conversation (goodbye, nothing else
-  today), say a brief goodbye in the same response and call `hangup()`. Do
-  not use it to finish the current skill or decline an unsupported request.
-{% endif %}
 {% if has_active_skill %}
 {% if complete_skill_available %}
 - When the user is done with the active topic, call `complete_skill()`.