rasa-pro 3.21.0.dev4__tar.gz → 3.21.0.dev5__tar.gz

{rasa_pro-3.21.0.dev4 → rasa_pro-3.21.0.dev5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rasa-pro
-Version: 3.21.0.dev4
+Version: 3.21.0.dev5
 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.dev4 → rasa_pro-3.21.0.dev5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "rasa-pro"
-version = "3.21.0.dev4"
+version = "3.21.0.dev5"
 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.dev4 → rasa_pro-3.21.0.dev5}/rasa/agents/protocol/mcp/mcp_base_agent.py

@@ -46,6 +46,7 @@ from rasa.agents.schemas import (
 )
 from rasa.agents.utils import get_slot_value_from_agent_input
 from rasa.builder.telemetry.langfuse_integration.langfuse_compat import observe
+from rasa.core.actions.constants import STREAMED_RESPONSE_TEXT_DELIVERED_KEY
 from rasa.core.available_agents import AgentConfig, AgentMCPServerConfig, ProtocolConfig
 from rasa.core.channels import OutputChannel
 from rasa.core.constants import (
@@ -870,7 +871,7 @@ class MCPBaseAgent(AgentProtocol):
             messages.append({KEY_ROLE: ROLE_USER, KEY_CONTENT: context.user_message})
         return messages
 
-    def create_bot_uttered_for_streamed_content(
+    def create_bot_uttered(
         self,
         text: str,
         agent_input: AgentInput,
@@ -878,14 +879,14 @@ class MCPBaseAgent(AgentProtocol):
         llm_time_to_first_token_ms: Optional[float] = None,
         llm_total_time_ms: Optional[float] = None,
     ) -> BotUttered:
-        """Create a BotUttered event for content streamed directly to the channel.
+        """Create a BotUttered event for LLM-generated content.
 
         Attaches standard agent metadata so the event is correctly attributed
         in the tracker and downstream analytics. LLM timing metrics are included
         when available.
 
         Args:
-            text: The streamed text content.
+            text: The generated text content.
             agent_input: The current agent input (used to read agent/model IDs).
             message_type: The agent message type to set in the event metadata.
             llm_time_to_first_token_ms: Time to first non-empty content delta,
@@ -1345,12 +1346,14 @@ class MCPBaseAgent(AgentProtocol):
         if llm_content is not None and isinstance(llm_content, str):
             llm_content = llm_content.strip()
         if llm_content and llm_response is not None:
-            bot_uttered = self.create_bot_uttered_for_streamed_content(
+            bot_uttered = self.create_bot_uttered(
                 llm_content,
                 agent_input,
                 llm_time_to_first_token_ms=llm_response.llm_time_to_first_token_ms,
                 llm_total_time_ms=llm_response.latency_ms,
             )
+            if output_channel.supports_streaming:
+                bot_uttered.metadata[STREAMED_RESPONSE_TEXT_DELIVERED_KEY] = True
         structlogger.debug(
             "mcp_base_agent.generate_and_send_response.response",
             agent_name=self._name,

{rasa_pro-3.21.0.dev4 → rasa_pro-3.21.0.dev5}/rasa/core/actions/constants.py

@@ -15,11 +15,14 @@ SESSION_START_REJECTION_MESSAGE = (
 
 STREAMING_QUEUE_MAX_SIZE = 32
 
-# Metadata key added to BotUttered events that were constructed from chunks
-# already delivered to the output channel via streaming.  _send_bot_messages
-# checks for this key and skips the send_response() call so the voice channel
-# does not replay content the user has already heard.
-STREAMED_CHUNK_KEY = "streamed_chunk"
+# Metadata key added to BotUttered events whose complete content was already
+# delivered to the output channel via streaming. The processor skips these
+# events during normal delivery.
+STREAMED_RESPONSE_FULLY_DELIVERED_KEY = "streamed_chunk"
+
+# Metadata key added to BotUttered events whose text was already delivered to the
+# output channel via streaming, while other response data still needs delivery.
+STREAMED_RESPONSE_TEXT_DELIVERED_KEY = "streamed_text"
 
 # Internal key attached to each entry in an executor's ``streamed_payloads`` list
 # to record which streaming response (one stream_start/stream_chunk/stream_end

{rasa_pro-3.21.0.dev4 → rasa_pro-3.21.0.dev5}/rasa/core/actions/custom_action_executor.py

@@ -13,7 +13,7 @@ from rasa.core.actions.action_exceptions import DomainNotFound
 from rasa.core.actions.constants import (
     DEFAULT_SELECTIVE_DOMAIN,
     SELECTIVE_DOMAIN,
-    STREAMED_CHUNK_KEY,
+    STREAMED_RESPONSE_FULLY_DELIVERED_KEY,
     STREAMING_RESPONSE_ID_KEY,
 )
 from rasa.shared.constants import DOCS_URL_ACTION_SERVER
@@ -88,7 +88,8 @@ def aggregate_streamed_payloads(
     as separate payloads in their original order so their structured content
     survives :func:`~rasa.core.actions.action.create_bot_utterance`.
 
-    Every returned payload is tagged with :data:`STREAMED_CHUNK_KEY` so that
+    Every returned payload is tagged with
+    :data:`STREAMED_RESPONSE_FULLY_DELIVERED_KEY` so that
     ``_send_bot_messages`` does not re-deliver content the user already received
     mid-stream.
 
@@ -110,7 +111,9 @@ def aggregate_streamed_payloads(
     def flush_text_buffer() -> None:
         nonlocal text_buffer, buffered_response_id
         if text_buffer is not None:
-            aggregated.append({"text": text_buffer, STREAMED_CHUNK_KEY: True})
+            aggregated.append(
+                {"text": text_buffer, STREAMED_RESPONSE_FULLY_DELIVERED_KEY: True}
+            )
             text_buffer = None
             buffered_response_id = None
 
@@ -126,7 +129,7 @@ def aggregate_streamed_payloads(
             # A rich chunk breaks the run of text tokens: flush the text
             # collected so far, then keep the rich chunk as its own payload.
             flush_text_buffer()
-            aggregated.append({**content, STREAMED_CHUNK_KEY: True})
+            aggregated.append({**content, STREAMED_RESPONSE_FULLY_DELIVERED_KEY: True})
             continue
 
         # A new streaming response starts a new message: flush the text buffered

{rasa_pro-3.21.0.dev4 → rasa_pro-3.21.0.dev5}/rasa/core/actions/direct_custom_actions_executor.py

@@ -595,7 +595,8 @@ class DirectCustomActionExecutor(CustomActionExecutor):
         :meth:`~rasa.core.actions.action.RemoteAction.run` can create
         ``BotUttered`` tracker events for them. Consecutive text tokens from the
         same streaming response are aggregated into a single ``BotUttered`` so the
-        transcript shows one composed message; ``STREAMED_CHUNK_KEY`` prevents
+        transcript shows one composed message;
+        ``STREAMED_RESPONSE_FULLY_DELIVERED_KEY`` prevents
         ``_send_bot_messages`` from re-delivering them to the output channel.
 
         Args:

{rasa_pro-3.21.0.dev4 → rasa_pro-3.21.0.dev5}/rasa/core/actions/grpc_custom_action_executor.py

@@ -431,7 +431,7 @@ class GRPCCustomActionExecutor(CustomActionExecutor):
         # events for the partial speech the user heard before the barge-in.
         # Consecutive text tokens from the same streaming response are aggregated
         # into a single BotUttered so the transcript shows one composed message;
-        # STREAMED_CHUNK_KEY prevents _send_bot_messages from re-delivering them.
+        # STREAMED_RESPONSE_FULLY_DELIVERED_KEY prevents re-delivery.
         # Any utter_message() responses the action returned are kept untagged
         # after the streamed entries so they are still delivered by
         # _send_bot_messages. stream_chunk() and utter_message() are distinct

{rasa_pro-3.21.0.dev4 → rasa_pro-3.21.0.dev5}/rasa/core/channels/channel.py

@@ -652,9 +652,9 @@ class OutputChannel:
         """Return True if *text* matches the last streamed response.
 
         Compares the stripped incoming text against the accumulated streaming
-        text from the most recent ``send_response_chunk`` sequence.  Used by
-        channels that stream content directly to the output (e.g. voice) to
-        avoid re-sending the same message delivered via the streaming path.
+        text from the most recent ``send_response_chunk`` sequence. Used by
+        text channels that need to suppress a completed response after direct
+        streaming delivery.
         """
         last = self._accumulated_streaming_text.strip()
         return bool(last) and text.strip() == last

{rasa_pro-3.21.0.dev4 → rasa_pro-3.21.0.dev5}/rasa/core/channels/voice_stream/voice_channel.py

@@ -1055,24 +1055,6 @@ class VoiceOutputChannel(OutputChannel):
             text=text,
             utterance_id=self._utterance_id,
         )
-        skip_reason = (
-            "duplicate_of_streamed_response"
-            if self._is_duplicate_of_last_streamed_response(text)
-            else "stream_interrupted"
-            if self.stream_interrupted
-            else None
-        )
-        if skip_reason:
-            self._utterance_outcome = f"skipped:{skip_reason}"
-            logger.debug(
-                "voice_channel.skip_non_streaming_response",
-                reason=skip_reason,
-                utterance_id=self._utterance_id,
-            )
-            # Nothing was spoken, so the previous utterance's metric snapshot
-            # must not leak into channel diagnostics for this message.
-            self._clear_tts_metrics()
-            return
 
         await self._start_tts_message(recipient_id)
         self.update_silence_timeout()

{rasa_pro-3.21.0.dev4 → rasa_pro-3.21.0.dev5}/rasa/core/nlg/contextual_response_rephraser.py

@@ -4,6 +4,7 @@ import structlog
 from jinja2 import Template
 
 from rasa import telemetry
+from rasa.core.actions.constants import STREAMED_RESPONSE_TEXT_DELIVERED_KEY
 from rasa.core.channels import OutputChannel
 from rasa.core.constants import (
     LLM_TIME_TO_FIRST_TOKEN_MS_KEY,
@@ -477,6 +478,9 @@ class ContextualResponseRephraser(
 
         updated_text = llm_response.choices[0]
 
+        if output_channel.supports_streaming:
+            response[STREAMED_RESPONSE_TEXT_DELIVERED_KEY] = True
+
         if lang_code in translation_response:
             response[KEY_TRANSLATION][lang_code] = updated_text
         else:

{rasa_pro-3.21.0.dev4 → rasa_pro-3.21.0.dev5}/rasa/core/policies/enterprise_search_policy.py

@@ -12,6 +12,7 @@ from jinja2 import Template
 from pydantic import ValidationError
 
 import rasa.shared.utils.io
+from rasa.core.actions.constants import STREAMED_RESPONSE_TEXT_DELIVERED_KEY
 from rasa.core.config.available_endpoints import AvailableEndpoints
 from rasa.core.constants import (
     UTTER_SOURCE_METADATA_KEY,
@@ -625,6 +626,7 @@ class EnterpriseSearchPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Po
         # Determine if we can use streaming (no post-processing needed)
         can_stream = (
             output_channel is not None
+            and output_channel.supports_streaming
             and not self.relevancy_check_enabled
             and not self.citation_enabled
         )
@@ -671,6 +673,10 @@ class EnterpriseSearchPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Po
         )
 
         action_metadata = self._get_action_metadata(search_query, documents, llm_answer)
+        if can_stream:
+            action_metadata[ACTION_METADATA_MESSAGE_KEY][
+                STREAMED_RESPONSE_TEXT_DELIVERED_KEY
+            ] = True
 
         return self._create_prediction(
             domain=domain, tracker=tracker, action_metadata=action_metadata

{rasa_pro-3.21.0.dev4 → rasa_pro-3.21.0.dev5}/rasa/core/processor.py

@@ -22,7 +22,10 @@ from rasa.core import jobs, turn_latency
 from rasa.core.actions.action import Action
 from rasa.core.actions.action_exceptions import ActionExecutionRejection
 from rasa.core.actions.action_hangup import BOT_DISCONNECTED_REASON
-from rasa.core.actions.constants import STREAMED_CHUNK_KEY
+from rasa.core.actions.constants import (
+    STREAMED_RESPONSE_FULLY_DELIVERED_KEY,
+    STREAMED_RESPONSE_TEXT_DELIVERED_KEY,
+)
 from rasa.core.actions.forms import FormAction
 from rasa.core.channels.channel import (
     CollectingOutputChannel,
@@ -979,16 +982,19 @@ class BaseMessageProcessor(MessageProcessor):
             if not isinstance(event, BotUttered):
                 continue
 
-            if event.metadata.get(STREAMED_CHUNK_KEY):
+            if event.metadata.get(STREAMED_RESPONSE_FULLY_DELIVERED_KEY):
                 structlogger.debug(
                     "rasa.core.processor._send_bot_messages.skip_streamed_chunk",
                     text=event.text,
                 )
                 continue
 
-            delivery = await output_channel.send_response(
-                tracker.sender_id, event.message()
-            )
+            message = event.message()
+            if event.metadata.get(STREAMED_RESPONSE_TEXT_DELIVERED_KEY):
+                # The text was already delivered as chunks; retain non-text payloads.
+                message["text"] = ""
+
+            delivery = await output_channel.send_response(tracker.sender_id, message)
             result.extend(delivery)
         return result
 

{rasa_pro-3.21.0.dev4 → rasa_pro-3.21.0.dev5}/rasa/mantle/default_skills/default_responses.yml

@@ -7,3 +7,9 @@ responses:
     - text: "I'm sorry, I wasn't able to continue with that request."
   utter_hangup_goodbye:
     - text: "Thanks for calling. Goodbye."
+  utter_model_request_hook_error:
+    - text: "I'm sorry, but something went wrong. Please try again."
+  utter_tool_call_hook_error:
+    - text: "I'm sorry, but something went wrong. Please try again."
+  utter_model_call_error:
+    - text: "I'm sorry, but something went wrong. Please try again."

{rasa_pro-3.21.0.dev4 → rasa_pro-3.21.0.dev5}/rasa/mantle/model_archive/training_telemetry.py

@@ -261,10 +261,21 @@ def _user_skills(catalog: SkillCatalog) -> list[Skill]:
 def _scale_attributes(catalog: Optional[SkillCatalog]) -> dict[str, Any]:
     if catalog is None:
         return {}
+    from rasa.mantle.tools.mcp_import_spec import try_parse_mcp_tool_import
+
     skills = list(catalog.skills.values())
     tool_names: set[str] = set()
     for skill in skills:
+        # ``declared_tool_names`` intentionally omits MCP-only bare names so the
+        # shared-tool loader does not allowlist them; telemetry still counts them.
         tool_names.update(catalog.declared_tool_names(skill.id))
+        for import_reference in skill.import_tool_names:
+            try:
+                mcp_import = try_parse_mcp_tool_import(import_reference)
+            except ValueError:
+                continue
+            if mcp_import is not None:
+                tool_names.add(mcp_import.tool_name)
     return {
         "num_skills": len(skills),
         "num_default_skills": sum(1 for s in skills if s.is_default),

{rasa_pro-3.21.0.dev4 → rasa_pro-3.21.0.dev5}/rasa/mantle/orchestration/orchestrator.py

@@ -142,6 +142,20 @@ _MAX_EMPTY_LLM_ATTEMPTS = 3
 """Max main-LLM attempts when a completion is empty (no text, no tools)."""
 
 _UTTER_HANGUP_GOODBYE = "utter_hangup_goodbye"
+UTTER_MODEL_REQUEST_HOOK_ERROR = "utter_model_request_hook_error"
+"""Packaged response when ``modify_model_request`` crashes or times out."""
+UTTER_TOOL_CALL_HOOK_ERROR = "utter_tool_call_hook_error"
+"""Packaged response when ``modify_tool_call`` crashes or times out."""
+UTTER_MODEL_CALL_ERROR = "utter_model_call_error"
+"""Packaged response when the main model call fails unexpectedly."""
+TURN_ERROR_DEFAULT_TEXT = "I'm sorry, but something went wrong. Please try again."
+"""Spoken when a turn-error template is missing or unmatched.
+
+The response name itself is never sent. Rephrase on these templates is
+ignored: this path runs because the model call cannot be trusted.
+"""
+_HOOK_EXECUTION_FAILED = "Hook execution failed."
+_LLM_CALL_FAILED = "LLM call failed."
 
 # Tags identifying where a turn completed, recorded on the
 # ``mantle.turn.completed`` log line for observability.
@@ -157,6 +171,7 @@ _SOURCE_LLM_LISTEN = "llm_listen"
 _SOURCE_LLM_HANGUP = "llm_hangup"
 _SOURCE_EMPTY_LLM_RESPONSE = "empty_llm_response"
 _SOURCE_LLM_ERROR = "llm_error"
+_SOURCE_HOOK_ERROR = "hook_error"
 _SOURCE_CANCELLED = "cancelled"
 _SOURCE_SKIP_SET_MEMORY_BUTTON = "skip_set_memory_button"
 
@@ -449,7 +464,11 @@ class Orchestrator:
                         iteration=iteration,
                     )
                 except HookExecutionError as exc:
-                    return self._llm_error_result(exc, iteration)
+                    return await self._hook_error_result(
+                        exc,
+                        iteration,
+                        response_name=UTTER_MODEL_REQUEST_HOOK_ERROR,
+                    )
 
                 # Engine-owned RetryModel feedback: append after request hooks so
                 # builders cannot strip the steering note.
@@ -487,7 +506,7 @@ class Orchestrator:
                 except OperationCancelled:
                     return self._cancelled_result(iteration)
                 except _MainLlmCallFailed as failed:
-                    return self._llm_error_result(failed.cause, iteration)
+                    return await self._llm_error_result(failed.cause, iteration)
 
                 llm_text = response.response_text()
                 tool_calls = list(response.tool_calls or [])
@@ -518,7 +537,11 @@ class Orchestrator:
                             tool_calls,
                         )
                     except HookExecutionError as exc:
-                        return self._llm_error_result(exc, iteration)
+                        return await self._hook_error_result(
+                            exc,
+                            iteration,
+                            response_name=UTTER_TOOL_CALL_HOOK_ERROR,
+                        )
                     if preflight.retry is not None:
                         # Discarded before any dispatch — do not set the latch.
                         retry_feedback = preflight.retry.feedback
@@ -1502,7 +1525,11 @@ class Orchestrator:
             try:
                 await self._dispatch_tool_calls(tool_calls, tracker_handle, iteration)
             except HookExecutionError as exc:
-                return self._llm_error_result(exc, iteration)
+                return await self._hook_error_result(
+                    exc,
+                    iteration,
+                    response_name=UTTER_TOOL_CALL_HOOK_ERROR,
+                )
             except OperationCancelled:
                 return self._cancelled_result(iteration)
             return self._completed_or_cancelled(
@@ -1587,7 +1614,11 @@ class Orchestrator:
         try:
             await self._dispatch_tool_calls(tool_calls, tracker_handle, iteration)
         except HookExecutionError as exc:
-            return self._llm_error_result(exc, iteration)
+            return await self._hook_error_result(
+                exc,
+                iteration,
+                response_name=UTTER_TOOL_CALL_HOOK_ERROR,
+            )
         except OperationCancelled:
             return self._cancelled_result(iteration)
         # A tool with requires_confirmation writes an awaiting_confirmation
@@ -1925,23 +1956,82 @@ class Orchestrator:
             if hook_events:
                 tracker_handle.apply_events(hook_events)
 
-    def _llm_error_result(self, exc: Exception, iteration: int) -> TurnResult:
-        """Turn a failed LLM call into a completed, leak-free error result.
+    async def _emit_turn_error_fallback(self, response_name: str) -> None:
+        """Speak a packaged turn-error response after an abort.
+
+        Used for fail-closed hook aborts and unknown main-model failures.
+        Builders override the named templates in ``responses.yml``.
+        ``metadata.rephrase`` is ignored. A missing or unmatched template
+        speaks the packaged default, never the response name and never the
+        exception text. If the turn is already cancelled, the utterance is
+        skipped (same drop semantics as :meth:`MessageTurnContext.send`).
+        """
+        ctx = current_turn_context()
+        if ctx.is_cancelled:
+            structlogger.debug(
+                "mantle.orchestrator.turn_error_fallback_skipped_cancelled",
+                response_name=response_name,
+            )
+            return
+
+        resolved = self._skill_executor.resolve_response_name(
+            response_name,
+            ctx.tracker_handle,
+        )
+        text = resolved.text.strip() if isinstance(resolved.text, str) else ""
+        use_default = not text or text == response_name
+        await ctx.send(
+            TURN_ERROR_DEFAULT_TEXT if use_default else text,
+            response_name=response_name,
+            buttons=() if use_default else resolved.buttons,
+            variant_metadata=None if use_default else resolved.variant_metadata,
+        )
+
+    async def _hook_error_result(
+        self,
+        exc: Exception,
+        iteration: int,
+        *,
+        response_name: str,
+    ) -> TurnResult:
+        """Abort the turn after a fail-closed modify hook crash or timeout.
+
+        Distinct from :meth:`_llm_error_result` so operators do not misread a
+        guardrail failure as a provider outage. The user hears ``response_name``.
+        """
+        structlogger.error(
+            "mantle.orchestrator.hook_error",
+            error=str(exc),
+            error_type=type(exc).__name__,
+            iteration=iteration,
+            response_name=response_name,
+            exc_info=True,
+        )
+        await self._emit_turn_error_fallback(response_name)
+        return self._completed(
+            TurnResult(error=_HOOK_EXECUTION_FAILED, iteration_count=iteration),
+            source=_SOURCE_HOOK_ERROR,
+        )
+
+    async def _llm_error_result(self, exc: Exception, iteration: int) -> TurnResult:
+        """Abort the turn after an unexpected main-model call failure.
 
         The full exception (type + stack) is logged for operators, but
         ``TurnResult.error`` is a stable, provider-agnostic string so raw
-        endpoint/model fragments cannot leak downstream.  Shared by the main
-        loop and the rephrase path so both fail identically.
+        endpoint/model fragments cannot leak downstream. The user hears
+        ``utter_model_call_error``.
         """
         structlogger.error(
             "mantle.orchestrator.llm_error",
             error=str(exc),
             error_type=type(exc).__name__,
             iteration=iteration,
+            response_name=UTTER_MODEL_CALL_ERROR,
             exc_info=True,
         )
+        await self._emit_turn_error_fallback(UTTER_MODEL_CALL_ERROR)
         return self._completed(
-            TurnResult(error="LLM call failed.", iteration_count=iteration),
+            TurnResult(error=_LLM_CALL_FAILED, iteration_count=iteration),
             source=_SOURCE_LLM_ERROR,
         )
 

{rasa_pro-3.21.0.dev4 → rasa_pro-3.21.0.dev5}/rasa/mantle/skills/catalog.py

@@ -465,7 +465,11 @@ class SkillCatalog(BaseModel):
         This is the skill-wide union across contexts — a name in this set may
         still be absent from :meth:`resolve_tool_gates` for a specific target
         (declared only on another same-skill block). Used by the tool loader to
-        scope shared tools to declaring skills.
+        scope shared tools to declaring skills. Bare gate names originating only
+        from MCP imports do not declare same-named shared tools — including when
+        those bare names also appear in ``tool_constraints`` or ordered-block
+        ``tools`` (constraints/gates, not shared-tool imports). Only a
+        non-``mcp/`` ``import_tools`` entry allowlists a shared Python tool.
         """
         skill = self.skills.get(skill_id)
         if skill is None:
@@ -473,6 +477,22 @@ class SkillCatalog(BaseModel):
         names = {gate.name for gate in skill.tools}
         for block in ordered_blocks_in_body(skill):
             names.update(gate.name for gate in block.tools)
+
+        from rasa.mantle.tools.mcp_import_spec import try_parse_mcp_tool_import
+
+        shared_imports = {
+            name for name in skill.import_tool_names if not name.startswith("mcp/")
+        }
+        for import_reference in skill.import_tool_names:
+            try:
+                mcp_import = try_parse_mcp_tool_import(import_reference)
+            except ValueError:
+                # Malformed ``mcp/…`` entries are reported by import_tools
+                # validation; skip them here so a sibling valid MCP import does
+                # not turn that report into an uncaught traceback.
+                continue
+            if mcp_import is not None and mcp_import.tool_name not in shared_imports:
+                names.discard(mcp_import.tool_name)
         return names
 
     def resolve_tool_gates(self, skill_id: str, target_id: str) -> list[GatedTool]:

{rasa_pro-3.21.0.dev4 → rasa_pro-3.21.0.dev5}/rasa/version.py

@@ -1,3 +1,3 @@
 # this file will automatically be changed,
 # do not add anything but the version number here!
-__version__ = "3.21.0.dev4"
+__version__ = "3.21.0.dev5"