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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rasa-pro
-Version: 3.21.0.dev3
+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.dev3 → 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.dev3"
+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.dev3 → 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.dev3 → rasa_pro-3.21.0.dev5}/rasa/builder/copilot/mcp_server/server.py

@@ -104,7 +104,7 @@ def _check_slot_errors(
     assertion_slot_values: dict,
     known_slots: dict,
 ) -> list:
-    """Return validation errors for initial_slots and assertion slot values."""
+    """Return validation errors for domain-slot initial_slots and assertions."""
     from rasa.builder.copilot.mcp_server.tools.scenario import (
         check_slot_type_compatibility,
     )
@@ -139,6 +139,36 @@ def _check_slot_errors(
     return errors
 
 
+def _check_initial_slots_errors(
+    initial_slots: dict,
+    assertion_slot_names: list,
+    assertion_slot_values: dict,
+    known_slots: dict,
+    project_folder: str,
+) -> list:
+    """Validate ``initial_slots`` for Mantle seed fields and domain slots."""
+    from pathlib import Path
+
+    from rasa.builder.copilot.mcp_server.tools.scenario_initial_setup import (
+        check_seed_initial_slot_errors,
+        load_project_memory_schema,
+        partition_initial_slots,
+    )
+
+    project_memory = load_project_memory_schema(Path(project_folder))
+    errors = check_seed_initial_slot_errors(initial_slots, project_memory)
+    _, post_session_start_slots = partition_initial_slots(initial_slots, project_memory)
+    errors.extend(
+        _check_slot_errors(
+            post_session_start_slots,
+            assertion_slot_names,
+            assertion_slot_values,
+            known_slots,
+        )
+    )
+    return errors
+
+
 @asynccontextmanager
 async def dummy_progress_reporter(
     ctx: Context, interval_seconds: int = 10
@@ -402,11 +432,12 @@ async def validate_scenario(
             known_slots = {slot.name: slot for slot in slots_response.slots}
             assertion_slot_values = get_assertion_slot_values(scenario.goals.assertions)
             errors.extend(
-                _check_slot_errors(
+                _check_initial_slots_errors(
                     scenario.setup.initial_slots,
                     assertion_slot_names,
                     assertion_slot_values,
                     known_slots,
+                    project_folder,
                 )
             )
         else:

rasa_pro-3.21.0.dev5/rasa/builder/copilot/mcp_server/tools/coval/preseed.py

@@ -0,0 +1,78 @@
+"""Pre-seed Rasa trackers before a Coval voice simulation connects."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Optional
+
+import aiohttp
+
+from rasa.builder.copilot.mcp_server.tools.coval.manifest import VoiceRunManifestEntry
+from rasa.builder.copilot.mcp_server.tools.evaluate_agent import (
+    _set_initial_slots,
+    _trigger_session_start,
+)
+from rasa.builder.copilot.mcp_server.tools.scenario_initial_setup import (
+    load_project_memory_schema,
+    partition_initial_slots,
+)
+
+
+async def preseed_voice_run_entry(
+    session: aiohttp.ClientSession,
+    entry: VoiceRunManifestEntry,
+    rasa_url: str,
+    *,
+    project_path: Optional[Path] = None,
+) -> None:
+    """Inject ``initial_slots`` for one manifest entry before Coval dials in.
+
+    Project fields marked ``seed: true`` in ``memory.yml`` are sent on
+    ``/session_start`` metadata when ``project_path`` is provided. Remaining
+    slots are written via the tracker events API. The voice channel may still
+    run its own session start on connect; text-style pre-seeding mirrors the
+    eval runner ordering when seed metadata is present.
+    """
+    initial_slots = dict(entry.initial_slots)
+    session_start_metadata: dict = {}
+    post_session_start_slots = initial_slots
+    if project_path is not None:
+        project_memory = load_project_memory_schema(project_path)
+        session_start_metadata, post_session_start_slots = partition_initial_slots(
+            initial_slots, project_memory
+        )
+    if session_start_metadata:
+        await _trigger_session_start(
+            session,
+            entry.rasa_sender_id,
+            rasa_url,
+            session_start_metadata=session_start_metadata,
+        )
+    await _set_initial_slots(
+        session,
+        entry.rasa_sender_id,
+        post_session_start_slots,
+        rasa_url,
+    )
+
+
+async def preseed_voice_run_manifest(
+    entries: list[VoiceRunManifestEntry],
+    rasa_url: str,
+    *,
+    project_path: Optional[Path] = None,
+    session: Optional[aiohttp.ClientSession] = None,
+) -> None:
+    """Pre-seed every entry in a voice run manifest."""
+    if session is not None:
+        for entry in entries:
+            await preseed_voice_run_entry(
+                session, entry, rasa_url, project_path=project_path
+            )
+        return
+
+    async with aiohttp.ClientSession() as owned_session:
+        for entry in entries:
+            await preseed_voice_run_entry(
+                owned_session, entry, rasa_url, project_path=project_path
+            )

{rasa_pro-3.21.0.dev3 → rasa_pro-3.21.0.dev5}/rasa/builder/copilot/mcp_server/tools/evaluate_agent.py

@@ -57,6 +57,10 @@ from rasa.builder.copilot.mcp_server.tools.observed_tools import (
     get_tools_from_events,
 )
 from rasa.builder.copilot.mcp_server.tools.scenario import Scenario
+from rasa.builder.copilot.mcp_server.tools.scenario_initial_setup import (
+    load_project_memory_schema,
+    partition_initial_slots,
+)
 from rasa.builder.copilot.mcp_server.tools.text_simulation import (
     _send_message,
     run_text_simulation,
@@ -66,6 +70,7 @@ from rasa.builder.copilot.mcp_server.tools.tool_scoring import (
     score_tools,
 )
 from rasa.core.channels.constants import USER_CONVERSATION_SESSION_START
+from rasa.mantle.memory.schema import ProjectMemorySchema
 from rasa.shared.core.events import BotUttered, UserUttered
 from rasa.shared.providers.llm.llm_client import LLMClient
 
@@ -82,6 +87,8 @@ async def _trigger_session_start(
     session: aiohttp.ClientSession,
     conversation_id: str,
     rasa_url: str,
+    *,
+    session_start_metadata: Optional[Dict[str, Any]] = None,
 ) -> List[str]:
     """Bootstrap ``/session_start`` before the first real user turn.
 
@@ -94,6 +101,8 @@ async def _trigger_session_start(
         session: Open ``aiohttp.ClientSession`` shared with the simulation loop.
         conversation_id: Rasa conversation (sender) id.
         rasa_url: Base URL of the running Rasa server (no trailing slash).
+        session_start_metadata: Optional channel-style metadata merged into the
+            ``/session_start`` webhook payload (after ``is_simulation``).
 
     Returns:
         Bot reply texts from the session-start turn (empty when no greeting
@@ -102,12 +111,15 @@ async def _trigger_session_start(
     Raises:
         RuntimeError: when all send retries are exhausted (from ``_send_message``).
     """
+    metadata: Dict[str, Any] = dict(session_start_metadata or {})
+    metadata["is_simulation"] = True
     return (
         await _send_message(
             session,
             conversation_id,
             USER_CONVERSATION_SESSION_START,
             rasa_url,
+            metadata=metadata,
         )
     ).texts
 
@@ -323,6 +335,7 @@ async def _simulate_scenario(
     simulation_llm_client: LLMClient,
     simulated_user_prompt: Optional[str],
     show_tracker_events: bool,
+    project_memory: ProjectMemorySchema,
     simulation_llm_semaphore: Optional[asyncio.Semaphore] = None,
 ) -> tuple[
     List[SimulationTurn],
@@ -338,16 +351,22 @@ async def _simulate_scenario(
     utterances stay separate. Stream timings are left unchanged.
     """
     engine_tokens: Optional[Dict[str, Any]] = None
+    session_start_metadata, post_session_start_slots = partition_initial_slots(
+        scenario.setup.initial_slots, project_memory
+    )
     async with aiohttp.ClientSession() as session:
         # Always bootstrap session start before content turns (and before slot
         # injection) so a configured welcome is uttered first, matching Inspector.
         welcome_messages = await _trigger_session_start(
-            session, conversation_id, rasa_url
+            session,
+            conversation_id,
+            rasa_url,
+            session_start_metadata=session_start_metadata or None,
         )
-        # initial_slots are injected after session start, so they intentionally
-        # override any slots that session start set.
+        # Non-seed initial_slots are injected after session start, so they
+        # intentionally override any slots that session start set.
         await _set_initial_slots(
-            session, conversation_id, scenario.setup.initial_slots, rasa_url
+            session, conversation_id, post_session_start_slots, rasa_url
         )
         sim_kwargs: Dict[str, Any] = {
             "initial_bot_messages": welcome_messages,
@@ -905,6 +924,7 @@ async def _run_once(
     metrics_judge_prompt: Optional[str] = None,
     show_tracker_events: bool = False,
     evaluate_tool_calls: bool = False,
+    project_memory: Optional[ProjectMemorySchema] = None,
     simulation_llm_semaphore: Optional[asyncio.Semaphore] = None,
     eval_llm_semaphore: Optional[asyncio.Semaphore] = None,
 ) -> RunReport:
@@ -931,6 +951,7 @@ async def _run_once(
     passed = False
     _start = time.perf_counter()
     evaluate_tool_calls = _effective_evaluate_tool_calls(evaluate_tool_calls)
+    resolved_project_memory = project_memory or load_project_memory_schema(project_path)
 
     with bound_contextvars(conversation_id=conversation_id):
         try:
@@ -948,6 +969,7 @@ async def _run_once(
                 simulation_llm_client=simulation_llm_client,
                 simulated_user_prompt=simulated_user_prompt,
                 show_tracker_events=show_tracker_events,
+                project_memory=resolved_project_memory,
                 simulation_llm_semaphore=simulation_llm_semaphore,
             )
             observed_tools, tool_scoring_result = _score_expected_tool_calls(
@@ -1222,6 +1244,7 @@ async def run_scenarios(
         # deep inside asyncio.
         return [], 0.0
 
+    project_memory = load_project_memory_schema(project_path)
     started_at = time.perf_counter()
     semaphore = asyncio.Semaphore(parallelism)
     # One semaphore per role for the whole batch, not per run: a per-run
@@ -1255,6 +1278,7 @@ async def run_scenarios(
                     metrics_judge_prompt=metrics_judge_prompt,
                     show_tracker_events=show_tracker_events,
                     evaluate_tool_calls=evaluate_tool_calls,
+                    project_memory=project_memory,
                     simulation_llm_semaphore=simulation_llm_semaphore,
                     eval_llm_semaphore=eval_llm_semaphore,
                 ),

rasa_pro-3.21.0.dev5/rasa/builder/copilot/mcp_server/tools/scenario_initial_setup.py

@@ -0,0 +1,104 @@
+"""Partition scenario ``initial_slots`` for Mantle session-start seeding."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Dict, Mapping, Optional, Tuple
+
+from rasa.builder.copilot.mcp_server.tools.scenario import check_slot_type_compatibility
+from rasa.mantle.memory.field import MemoryField
+from rasa.mantle.memory.schema import ProjectMemorySchema
+
+_PROJECT_SLOT_PREFIX = "project."
+
+_MEMORY_TYPE_TO_SLOT_TYPE: Dict[str, str] = {
+    "text": "text",
+    "bool": "bool",
+    "float": "float",
+    "list": "list",
+    "categorical": "categorical",
+    "strict_categorical": "categorical",
+}
+
+
+def load_project_memory_schema(project_path: Path) -> ProjectMemorySchema:
+    """Load project ``memory.yml`` from a Rasa project root."""
+    return ProjectMemorySchema.from_yaml(project_path / "memory.yml")
+
+
+def project_field_name_for_initial_slot_key(
+    key: str, project_fields: Mapping[str, MemoryField]
+) -> Optional[str]:
+    """Return the bare project field name when ``key`` refers to one, else ``None``."""
+    if key in project_fields:
+        return key
+    if key.startswith(_PROJECT_SLOT_PREFIX):
+        bare = key[len(_PROJECT_SLOT_PREFIX) :]
+        if bare in project_fields:
+            return bare
+    return None
+
+
+def partition_initial_slots(
+    initial_slots: Mapping[str, Any],
+    project_memory: ProjectMemorySchema,
+) -> Tuple[Dict[str, Any], Dict[str, Any]]:
+    """Split ``initial_slots`` into session-start metadata and post-start slot writes.
+
+    Project fields marked ``seed: true`` are routed to session-start metadata
+    using bare field names (matching channel gateways). All other entries stay
+    on the tracker slot-injection path.
+
+    Returns:
+        A pair ``(session_start_metadata, post_session_start_slots)``.
+    """
+    session_start_metadata: Dict[str, Any] = {}
+    post_session_start_slots: Dict[str, Any] = {}
+    for key, value in initial_slots.items():
+        field_name = project_field_name_for_initial_slot_key(key, project_memory.fields)
+        if field_name is not None and project_memory.fields[field_name].seed:
+            session_start_metadata[field_name] = value
+        else:
+            post_session_start_slots[key] = value
+    return session_start_metadata, post_session_start_slots
+
+
+def check_memory_field_value_compatibility(
+    field_name: str, value: Any, field: MemoryField
+) -> Optional[str]:
+    """Return an error when ``value`` does not match ``field``, else ``None``."""
+    if value is None:
+        return None
+    if field.type == "int":
+        if not isinstance(value, int) or isinstance(value, bool):
+            return (
+                f"Project memory field '{field_name}' has type 'int' but "
+                f"initial value {value!r} is incompatible."
+            )
+        return None
+    slot_type = _MEMORY_TYPE_TO_SLOT_TYPE.get(field.type)
+    if slot_type is not None:
+        type_error = check_slot_type_compatibility(field_name, value, slot_type)
+        if type_error is not None:
+            return type_error.replace("Slot", "Project memory field", 1)
+    if field.enum_values and value not in field.enum_values:
+        return (
+            f"Project memory field '{field_name}' value {value!r} is not one of "
+            f"{field.enum_values!r}."
+        )
+    return None
+
+
+def check_seed_initial_slot_errors(
+    initial_slots: Mapping[str, Any],
+    project_memory: ProjectMemorySchema,
+) -> list[str]:
+    """Validate ``initial_slots`` entries that map to ``seed: true`` project fields."""
+    session_start_metadata, _ = partition_initial_slots(initial_slots, project_memory)
+    errors: list[str] = []
+    for field_name, value in session_start_metadata.items():
+        field = project_memory.fields[field_name]
+        type_error = check_memory_field_value_compatibility(field_name, value, field)
+        if type_error is not None:
+            errors.append(type_error)
+    return errors

{rasa_pro-3.21.0.dev3 → rasa_pro-3.21.0.dev5}/rasa/builder/copilot/mcp_server/tools/text_simulation.py

@@ -203,6 +203,7 @@ async def _send_message(
     text: str,
     rasa_url: str,
     *,
+    metadata: Optional[Dict[str, Any]] = None,
     max_attempts: int = SIM_EVAL_LLM_MAX_ATTEMPTS,
     timeout: float = _SEND_MESSAGE_TIMEOUT,
 ) -> BotReplyMetrics:
@@ -223,6 +224,7 @@ async def _send_message(
         conversation_id: Rasa conversation (sender) id.
         text: User message text.
         rasa_url: Base URL of the running Rasa server.
+        metadata: Optional webhook metadata; defaults to ``is_simulation`` only.
         max_attempts: Total tries before giving up.
         timeout: Per-request timeout in seconds.
 
@@ -234,10 +236,13 @@ async def _send_message(
             body, or when all retry attempts are exhausted.
     """
     url = f"{rasa_url.rstrip('/')}/webhooks/rest/webhook"
+    payload_metadata: Dict[str, Any] = (
+        dict(metadata) if metadata is not None else {"is_simulation": True}
+    )
     payload = {
         "sender": conversation_id,
         "message": text,
-        "metadata": {"is_simulation": True},
+        "metadata": payload_metadata,
     }
     last_error: Optional[str] = None
     client_timeout = aiohttp.ClientTimeout(total=timeout)

{rasa_pro-3.21.0.dev3 → rasa_pro-3.21.0.dev5}/rasa/cli/tools/skills_data/mantle/mantle-simulating-evaluating/SKILL.md

@@ -90,8 +90,10 @@ scenario:
   play the part and a clear end condition, but let it choose the words.
 - **`setup.initial_slots`** *(optional)* — a `{slot_name: value}` map that seeds starting
   state (e.g. an already-logged-in customer) so a scenario doesn't have to replay setup
-  turns. Supported by the scenario schema (values are type-checked against each slot's
-  declared type); the packaged example scenarios simply don't use it.
+  turns. For Mantle, project fields marked `seed: true` in `memory.yml` are sent on
+  `/session_start` metadata (like a channel gateway); other keys are set afterward via
+  tracker slots. Values are type-checked against domain slots and, for seed fields,
+  against `memory.yml`.
 - **`goals`** — the pass condition, split into `criteria` and `assertions`.
 
 ### criteria vs assertions — the design decision

{rasa_pro-3.21.0.dev3 → 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.dev3 → 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.dev3 → 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.dev3 → 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.dev3 → 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.dev3 → 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.dev3 → 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.dev3 → 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