rasa-pro 3.19.0.dev1__tar.gz → 3.19.0.dev3__tar.gz

{rasa_pro-3.19.0.dev1 → rasa_pro-3.19.0.dev3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: rasa-pro
-Version: 3.19.0.dev1
+Version: 3.19.0.dev3
 Summary: State-of-the-art open-core Conversational AI framework for Enterprises that natively leverages generative AI for effortless assistant development.
 Keywords: nlp,machine-learning,machine-learning-library,bot,bots,botkit,rasa conversational-agents,conversational-ai,chatbot,chatbot-framework,bot-framework
 Author: Rasa Technologies GmbH

{rasa_pro-3.19.0.dev1 → rasa_pro-3.19.0.dev3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "rasa-pro"
-version = "3.19.0.dev1"
+version = "3.19.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>",]
@@ -657,6 +657,8 @@ convention = "google"
 
 
 
+
+
 [tool.poetry.group.dev.dependencies]
 ruff = ">=0.3.5,<0.4.0"
 docker = "~7.1.0"

rasa_pro-3.19.0.dev3/rasa/agents/core/cancellation.py

@@ -0,0 +1,205 @@
+"""Cancellation token for interrupting long-running agent operations."""
+
+from __future__ import annotations
+
+import asyncio
+from typing import Awaitable, Optional, TypeVar
+
+import structlog
+
+from rasa.shared.exceptions import RasaException
+
+T = TypeVar("T")
+
+structlogger = structlog.get_logger()
+
+# Bound how long ``race`` waits for a cancelled work task to unwind (e.g. TTS
+# stream-end joining an audio sender). Without a cap, "cancel wins" can still
+# block on uncooperative teardown.
+_TEARDOWN_GRACE_SECONDS = 0.5
+
+
+class OperationCancelled(RasaException):
+    """Raised when a cancellable awaitable is aborted by a cancellation token.
+
+    Distinct from :exc:`asyncio.CancelledError`: the outer turn task is still
+    running; only the in-flight LLM / tool / skill await was aborted so the
+    orchestrator can stop the turn cleanly.
+    """
+
+    def __init__(self, message: str = "Operation cancelled") -> None:
+        super().__init__(message)
+
+
+class CancellationToken:
+    """A lightweight, lock-free signaling primitive for cooperative cancellation.
+
+    Wraps an ``asyncio.Event`` so that any external source (session timer,
+    channel disconnect, explicit user action) can interrupt a long-running
+    operation — such as A2A polling — without acquiring the conversation lock.
+
+    Typical usage inside a polling loop::
+
+        while True:
+            ...
+            if cancellation_token:
+                cancelled = await cancellation_token.wait(timeout=delay)
+                if cancelled:
+                    break
+            else:
+                await asyncio.sleep(delay)
+
+    To abort an in-flight awaitable as soon as cancel is signalled::
+
+        result = await token.race(do_work())
+    """
+
+    def __init__(self) -> None:
+        self._event = asyncio.Event()
+        self._cancelled = False
+        # Bound on first await so ``cancel()`` can wake waiters via the
+        # owning loop (``Event.set()`` is not safe across threads/loops).
+        self._loop: Optional[asyncio.AbstractEventLoop] = None
+
+    def _bind_running_loop(self) -> None:
+        """Remember the loop that owns waiters for this token.
+
+        Every waiter must call this *before* it checks :attr:`is_cancelled` —
+        see the ordering invariant in :meth:`cancel`.
+        """
+        try:
+            running = asyncio.get_running_loop()
+        except RuntimeError:
+            return
+        if self._loop is None:
+            self._loop = running
+
+    def cancel(self) -> None:
+        """Signal cancellation. Lock-free, safe to call from any thread.
+
+        When waiters are parked on another event loop (e.g. A2A polling in a
+        worker thread while a Sanic handler cancels), ``asyncio.Event.set()``
+        must run on the owning loop via ``call_soon_threadsafe``. Calling
+        ``set()`` directly from a foreign thread can fail to wake waiters and
+        can leave ``wait_for`` hung past its timeout.
+
+        Ordering invariant, paired with the waiters: ``_cancelled`` is set
+        before ``_loop`` is read here, and every waiter binds the loop before
+        it checks :attr:`is_cancelled`. Together these close the window where a
+        waiter parks just as this method reads ``_loop`` as ``None`` — one side
+        always observes the other's write. Moving either statement reopens the
+        window, and the token then silently fails to wake a cross-thread
+        waiter.
+        """
+        self._cancelled = True  # must precede the ``_loop`` read below
+        loop = self._loop
+        try:
+            running = asyncio.get_running_loop()
+        except RuntimeError:
+            running = None
+
+        if loop is not None and loop.is_running() and running is not loop:
+            try:
+                loop.call_soon_threadsafe(self._event.set)
+                return
+            except RuntimeError:
+                # Loop closed between the check and the schedule attempt.
+                pass
+        self._event.set()
+
+    @property
+    def is_cancelled(self) -> bool:
+        """Non-blocking check."""
+        return self._cancelled or self._event.is_set()
+
+    async def wait_until_cancelled(self) -> None:
+        """Block indefinitely until cancellation is signalled.
+
+        Unlike :meth:`wait`, this method has no timeout — it returns only
+        when :meth:`cancel` has been called.  Use it to create an
+        ``asyncio.Task`` that can be raced against another coroutine via
+        ``asyncio.wait``::
+
+            consume_task = asyncio.create_task(do_work())
+            cancel_task = asyncio.create_task(token.wait_until_cancelled())
+            done, pending = await asyncio.wait(
+                {consume_task, cancel_task},
+                return_when=asyncio.FIRST_COMPLETED,
+            )
+        """
+        self._bind_running_loop()
+        if self.is_cancelled:
+            self._event.set()
+            return
+        await self._event.wait()
+
+    async def wait(self, timeout: float) -> bool:
+        """Sleep for up to *timeout* seconds, waking immediately on cancellation.
+
+        Use as a cancellation-aware replacement for ``asyncio.sleep`` inside
+        polling loops::
+
+            cancelled = await token.wait(timeout=delay)
+            if cancelled:
+                break
+
+        Returns:
+            ``True`` if cancelled before the timeout, ``False`` if the timeout
+            expired normally.
+        """
+        self._bind_running_loop()
+        if self.is_cancelled:
+            self._event.set()
+            return True
+        try:
+            await asyncio.wait_for(self._event.wait(), timeout=timeout)
+            return True
+        except asyncio.TimeoutError:
+            return False
+
+    async def race(self, awaitable: Awaitable[T]) -> T:
+        """Await *awaitable*, aborting when this token is cancelled.
+
+        Raises :exc:`OperationCancelled` when cancel wins (or was already set).
+        The losing task is cancelled and drained for up to
+        :data:`_TEARDOWN_GRACE_SECONDS` so slow teardown cannot stall the
+        caller indefinitely.
+        """
+        self._bind_running_loop()
+        if self.is_cancelled:
+            if asyncio.iscoroutine(awaitable):
+                awaitable.close()
+            raise OperationCancelled()
+
+        work = asyncio.ensure_future(awaitable)
+        cancel = asyncio.create_task(self.wait_until_cancelled())
+        try:
+            done, pending = await asyncio.wait(
+                {work, cancel}, return_when=asyncio.FIRST_COMPLETED
+            )
+        except asyncio.CancelledError:
+            await self._cancel_and_drain(work, cancel)
+            raise
+
+        await self._cancel_and_drain(*pending)
+        if work in done:
+            return work.result()
+        raise OperationCancelled()
+
+    async def _cancel_and_drain(self, *tasks: asyncio.Task) -> None:
+        """Cancel *tasks* and await them up to the teardown grace period."""
+        if not tasks:
+            return
+        for task in tasks:
+            task.cancel()
+        try:
+            await asyncio.wait_for(
+                asyncio.gather(*tasks, return_exceptions=True),
+                timeout=_TEARDOWN_GRACE_SECONDS,
+            )
+        except asyncio.TimeoutError:
+            structlogger.warning(
+                "cancellation.race.teardown_timeout",
+                grace_seconds=_TEARDOWN_GRACE_SECONDS,
+                pending_count=sum(1 for task in tasks if not task.done()),
+            )

{rasa_pro-3.19.0.dev1 → rasa_pro-3.19.0.dev3}/rasa/agents/protocol/mcp/mcp_base_agent.py

@@ -1270,16 +1270,11 @@ 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:
-            llm_total_time_ms = (
-                llm_response.latency * 1000
-                if llm_response.latency is not None
-                else None
-            )
             bot_uttered = self.create_bot_uttered_for_streamed_content(
                 llm_content,
                 agent_input,
                 llm_time_to_first_token_ms=llm_response.llm_time_to_first_token_ms,
-                llm_total_time_ms=llm_total_time_ms,
+                llm_total_time_ms=llm_response.latency_ms,
             )
         structlogger.debug(
             "mcp_base_agent.generate_and_send_response.response",

{rasa_pro-3.19.0.dev1 → rasa_pro-3.19.0.dev3}/rasa/builder/copilot/mcp_server/tools/conversation_repair.py

@@ -44,7 +44,7 @@ Repair signals:
 No ``- digression`` without digression metadata on ``FlowInterrupted``:
 
 - ``call:`` sub-flow — ``CALL`` frame; parent not paused (no ``FlowInterrupted``)
-- Scope handler — ``activate_flow`` → ``default_unsupported_request_handler``;
+- Scope handler — ``activate`` → ``default_unsupported_request_handler``;
   repair is ``- out_of_scope`` / ``- out_of_domain`` (via
   ``UnsupportedRequestClassified``)
 - Same-flow re-activate — dispatch no-op before lifecycle events

{rasa_pro-3.19.0.dev1 → rasa_pro-3.19.0.dev3}/rasa/calm_v2/default_skills/default_unsupported_request_handler/skill.md

@@ -8,7 +8,7 @@ description: >
   scope) selects the message.
 routing:
   # engine_managed: reached only via the cannot_help tool's dispatch, never by
-  # routing — so it is excluded from the activate_flow enum and routing catalogue.
+  # routing — so it is excluded from the activate enum and routing catalogue.
   engine_managed: true
 ---
 

{rasa_pro-3.19.0.dev1 → rasa_pro-3.19.0.dev3}/rasa/calm_v2/llm/client.py

@@ -29,7 +29,7 @@ from rasa.calm_v2.prompts.messages import LlmMessage
 from rasa.calm_v2.prompts.token_budget import PROMPT_ONLY_LLM_CONFIG_KEYS
 from rasa.shared.constants import API_KEY
 from rasa.shared.providers.llm.llm_client import LLMClient as _ProviderClient
-from rasa.shared.providers.llm.llm_response import LLMResponse
+from rasa.shared.providers.llm.llm_response import LLMResponse, measure_llm_latency
 from rasa.shared.utils.llm import acompletion_with_streaming, llm_factory
 
 if TYPE_CHECKING:
@@ -179,6 +179,7 @@ class LLMClient:
         _log_llm_response(response)
         return response
 
+    @measure_llm_latency
     async def acompletion(
         self,
         messages: List[LlmMessage],

{rasa_pro-3.19.0.dev1 → rasa_pro-3.19.0.dev3}/rasa/calm_v2/llm/tool_schemas.py

@@ -7,8 +7,8 @@ Static framework tools
 ----------------------
 Always present; schema is hard-coded.
 
-* ``activate_flow`` — start one of the allowed flows (``flow_id`` enum).
-  Globally routable flows are always listed; non-routable internal sub-flows
+* ``activate`` — start one of the allowed activation targets (``target_id`` enum).
+  Globally routable entry ids are always listed; non-routable internal entry points
   are added only while their owning skill is active.
 * ``complete_skill`` — finish the active skill/phase gracefully
 * ``cancel_skill`` — abandon the active skill and emit ``FlowCancelled``
@@ -53,8 +53,9 @@ from rasa.calm_v2.memory.field import (
     MemoryField,
 )
 from rasa.calm_v2.orchestration.post_write_hooks import is_post_write_hook
-from rasa.calm_v2.skills.catalog import SkillCatalog
+from rasa.calm_v2.skills.catalog import SkillCatalog, SkillDefinition
 from rasa.calm_v2.skills.conditions import GatedTool, evaluate_expression
+from rasa.calm_v2.state.pending_tool_confirmation import PendingToolConfirmation
 
 if TYPE_CHECKING:
     from rasa.calm_v2.orchestration.correction import CorrectableMemoryItem
@@ -97,7 +98,7 @@ _TOOL_FUNCTION = "function"
 # Static tool schema constants
 # ---------------------------------------------------------------------------
 
-TOOL_ACTIVATE_FLOW = "activate_flow"
+TOOL_ACTIVATE = "activate"
 TOOL_COMPLETE_SKILL = "complete_skill"
 TOOL_CANCEL_SKILL = "cancel_skill"
 TOOL_SET_FIELDS = "set_fields"
@@ -105,6 +106,9 @@ TOOL_SET_FIELDS = "set_fields"
 
 TOOL_CORRECT = "correct"
 
+TOOL_RESOLVE_TOOL_CONFIRMATION = "resolve_tool_confirmation"
+"""Interpret the user's reply to a pending ``requires_confirmation`` gate."""
+
 TOOL_SEARCH_KNOWLEDGE = "search_knowledge"
 """On-demand knowledge retrieval — see :func:`_build_search_knowledge_schema`."""
 
@@ -114,11 +118,12 @@ TOOL_CANNOT_HELP = "cannot_help"
 # Engine-owned tool names — builder ``@tool`` functions must not reuse these.
 FRAMEWORK_TOOL_NAMES: frozenset[str] = frozenset(
     {
-        TOOL_ACTIVATE_FLOW,
+        TOOL_ACTIVATE,
         TOOL_COMPLETE_SKILL,
         TOOL_CANCEL_SKILL,
         TOOL_SET_FIELDS,
         TOOL_CORRECT,
+        TOOL_RESOLVE_TOOL_CONFIRMATION,
         TOOL_SEARCH_KNOWLEDGE,
         TOOL_CANNOT_HELP,
     }
@@ -159,33 +164,37 @@ _STATIC_TOOLS_WITHOUT_ACTIVATE: List[Dict[str, Any]] = [
 def _build_activate_flow_schema(
     routable_flow_ids: List[str],
 ) -> Dict[str, Any]:
-    """Build the ``activate_flow`` schema from the allowed flow IDs.
+    """Build the LLM ``activate`` tool schema from allowed entry ids.
 
-    Routing always targets a flow, never a skill — autonomous skills are
-    represented by a synthetic flow whose id equals the skill id — so the LLM
-    only ever picks a ``flow_id``.
+    Routing resolves to an internal flow id; the schema exposes ``target_id`` to
+    the model with an enum of entry ids it may activate this turn.
 
     Args:
-        routable_flow_ids: Ordered flow IDs from
+        routable_flow_ids: Ordered entry ids from
             :meth:`~rasa.calm_v2.skills.catalog.SkillCatalog.get_startable_candidate_flow_ids`
             (global routable ids plus the active skill's ``referenced_blocks``).
     """
-    flow_id_schema: Dict[str, Any] = {
+    target_id_schema: Dict[str, Any] = {
         "type": "string",
-        "description": "The flow to start.",
+        "description": (
+            "The activation target id — a skill id for prose, or "
+            "``{skill_id}__{block_id}`` for an ordered block."
+        ),
     }
     if routable_flow_ids:
-        flow_id_schema["enum"] = sorted(routable_flow_ids)
+        target_id_schema["enum"] = sorted(routable_flow_ids)
 
     return {
         "type": _TOOL_FUNCTION,
         "function": {
-            "name": TOOL_ACTIVATE_FLOW,
-            "description": "Activate a flow to start or switch to a task.",
+            "name": TOOL_ACTIVATE,
+            "description": (
+                "Activate a skill or ordered-block entry to start or switch tasks."
+            ),
             "parameters": {
                 "type": "object",
-                "properties": {"flow_id": flow_id_schema},
-                "required": ["flow_id"],
+                "properties": {"target_id": target_id_schema},
+                "required": ["target_id"],
             },
         },
     }
@@ -271,7 +280,7 @@ def _build_correct_schema(
 ) -> Optional[Dict[str, Any]]:
     """Build the per-turn ``correct`` schema, or ``None`` when nothing is correctable.
 
-    Like ``activate_flow``, the schema is rebuilt each turn with a dynamic
+    Like ``activate``, the schema is rebuilt each turn with a dynamic
     ``memory_key`` enum and a description that lists each correctable memory item
     with its declared type, current value, and (where declared) its allowed
     values, so the LLM can target the right earlier decision and supply a
@@ -343,6 +352,51 @@ def _build_correct_schema(
     }
 
 
+def _build_resolve_tool_confirmation_schema(
+    tool_name: str,
+    confirmation_ask: str | None,
+) -> Dict[str, Any]:
+    """Build the per-turn ``resolve_tool_confirmation`` schema.
+
+    Offered only while a builder tool is paused on ``requires_confirmation``. The
+    LLM interprets the user's reply and sets ``confirmed`` accordingly.
+
+    When supplied, the description embeds the substituted confirmation ask so
+    the model can interpret the user's reply in context. Treat it like other
+    user-visible copy (it may include memory values); do not log at INFO+.
+    """
+    context = (
+        f"The agent asked the user: {confirmation_ask!r} "
+        if confirmation_ask is not None
+        else "The agent asked the user to confirm "
+    )
+    return {
+        "type": _TOOL_FUNCTION,
+        "function": {
+            "name": TOOL_RESOLVE_TOOL_CONFIRMATION,
+            "description": (
+                "Resolve a pending tool confirmation. "
+                f"{context}before running '{tool_name}'. Interpret "
+                "the user's latest reply: set confirmed=true if they agreed to "
+                "proceed, or confirmed=false if they declined or changed their "
+                "mind."
+            ),
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "confirmed": {
+                        "type": "boolean",
+                        "description": (
+                            "True to run the pending tool; False to cancel it."
+                        ),
+                    }
+                },
+                "required": ["confirmed"],
+            },
+        },
+    }
+
+
 def _build_field_property_schema(
     field_name: str,
     field: Optional[MemoryField],
@@ -630,6 +684,7 @@ def build_tool_schemas(
     knowledge_available: bool = False,
     knowledge_searched: bool = False,
     project_memory_fields: Optional[Mapping[str, MemoryField]] = None,
+    pending_tool_confirmation: Optional[PendingToolConfirmation] = None,
 ) -> List[Dict[str, Any]]:
     """Build the full tool schema list for one LLM completion call.
 
@@ -677,7 +732,7 @@ def build_tool_schemas(
             model cannot decline before the context is possibly complete). When
             ``False``, ``cannot_help`` is offered immediately.
         knowledge_searched: Whether ``search_knowledge`` has already been called
-            this turn. When ``True``, only ``activate_flow``,
+            this turn. When ``True``, only ``activate``,
             ``search_knowledge`` and ``cannot_help`` are offered; the active
             skill's lifecycle, collect, and builder tools are dropped so the
             grounded answer does not re-drive the skill.
@@ -688,6 +743,10 @@ def build_tool_schemas(
             ``set_fields`` schema correctly typed instead of defaulting such
             fields to ``string``. Skill-local fields take precedence on a name
             collision.
+        pending_tool_confirmation: Optional pending confirmation payload when a
+            builder tool is paused on ``requires_confirmation``. When set, a
+            ``resolve_tool_confirmation`` tool is offered so the LLM can
+            interpret the user's reply.
 
     Returns:
         A list of OpenAI-format tool schema dicts ready for the LLM client.
@@ -701,7 +760,7 @@ def build_tool_schemas(
     if startable_candidate_flow_ids:
         schemas.append(_build_activate_flow_schema(startable_candidate_flow_ids))
 
-    # search_knowledge is available alongside activate_flow in both routing mode
+    # search_knowledge is available alongside activate in both routing mode
     # and while a skill is active, so the model can retrieve at any point in the
     # turn.
     if knowledge_available:
@@ -712,17 +771,28 @@ def build_tool_schemas(
     # context is possibly complete: offered only once search_knowledge has run
     # this turn, or immediately when no knowledge base is configured. Appended
     # before the post-search early return below so it survives the trim that
-    # keeps only activate_flow + search_knowledge after a search (the model may
+    # keeps only activate + search_knowledge after a search (the model may
     # still need to decline once a search turns up nothing relevant).
     if knowledge_searched or not knowledge_available:
         schemas.append(_build_cannot_help_schema())
 
+    # resolve_tool_confirmation must survive the post-search trim the same way
+    # cannot_help does: it is the only way to unblock requires_confirmation after a
+    # clarifying search during a confirmation pause.
+    if pending_tool_confirmation is not None:
+        schemas.append(
+            _build_resolve_tool_confirmation_schema(
+                pending_tool_confirmation.tool_name,
+                pending_tool_confirmation.confirmation_ask,
+            )
+        )
+
     # Once search_knowledge has run this turn, the only tools kept are
-    # activate_flow + search_knowledge (re-query) plus cannot_help. The active
-    # skill's lifecycle / collect / builder tools are dropped so the grounded
-    # answer does not re-drive the skill; they return on a later turn once no
-    # search has run, or after an activate_flow. Mirrors the active-skill prompt
-    # trim.
+    # activate + search_knowledge (re-query) plus cannot_help and, when a
+    # confirmation is pending, resolve_tool_confirmation. The active skill's
+    # lifecycle / collect / builder tools are dropped so the grounded answer
+    # does not re-drive the skill; they return on a later turn once no search
+    # has run, or after an activate. Mirrors the active-skill prompt trim.
     if knowledge_searched:
         return schemas
 
@@ -740,40 +810,76 @@ def build_tool_schemas(
     active_skill = (
         skill_catalog.skill_for_flow(active_flow_id) if active_flow_id else None
     )
+    _append_set_fields_schema(
+        schemas,
+        active_skill=active_skill,
+        settable_fields=settable_fields,
+        settable_descriptions=settable_descriptions,
+        project_memory_fields=project_memory_fields,
+    )
+    _append_custom_tool_schemas(
+        schemas,
+        skill_catalog=skill_catalog,
+        active_skill=active_skill,
+        active_flow_id=active_flow_id,
+        skill_tool_funcs=skill_tool_funcs,
+        memory_values=memory_values,
+    )
+    return schemas
 
-    if settable_fields:
-        active_skill_fields = (
-            active_skill.memory.definition.all_fields() if active_skill else {}
-        )
-        # Project fields can appear in ``settable_fields`` too; merge their
-        # defs so type/enum metadata is correct. Skill-local fields win on a
-        # name collision (the active skill's contract is authoritative there).
-        memory_fields = {**(project_memory_fields or {}), **active_skill_fields}
-        schemas.append(
-            _build_set_fields_schema(
-                settable_fields,
-                memory_fields,
-                settable_descriptions or {},
-            )
+
+def _append_set_fields_schema(
+    schemas: List[Dict[str, Any]],
+    *,
+    active_skill: Optional[SkillDefinition],
+    settable_fields: Optional[List[str]],
+    settable_descriptions: Optional[Dict[str, Optional[str]]],
+    project_memory_fields: Optional[Mapping[str, MemoryField]],
+) -> None:
+    """Append the batch ``set_fields`` schema when settable fields are present."""
+    if not settable_fields:
+        return
+    active_skill_fields = (
+        active_skill.memory.definition.all_fields() if active_skill else {}
+    )
+    # Project fields can appear in ``settable_fields`` too; merge their
+    # defs so type/enum metadata is correct. Skill-local fields win on a
+    # name collision (the active skill's contract is authoritative there).
+    memory_fields = {**(project_memory_fields or {}), **active_skill_fields}
+    schemas.append(
+        _build_set_fields_schema(
+            settable_fields,
+            memory_fields,
+            settable_descriptions or {},
         )
+    )
 
-    if active_flow_id is not None and skill_tool_funcs:
-        skill_id = active_skill.id if active_skill else active_flow_id
-        skill_funcs = skill_tool_funcs.get(skill_id, {})
-        if skill_funcs:
-            active_tool_names = visible_custom_tool_names(
-                skill_catalog,
-                skill_id,
-                active_flow_id,
-                skill_funcs,
-                memory_values,
-            )
-            if active_tool_names:
-                schemas.extend(
-                    build_custom_tool_schemas(active_tool_names, skill_funcs)
-                )
 
-    return schemas
+def _append_custom_tool_schemas(
+    schemas: List[Dict[str, Any]],
+    *,
+    skill_catalog: SkillCatalog,
+    active_skill: Optional[SkillDefinition],
+    active_flow_id: Optional[str],
+    skill_tool_funcs: Optional[Mapping[str, Mapping[str, Callable]]],
+    memory_values: Mapping[str, Any],
+) -> None:
+    """Append gated custom tool schemas for the active skill, if any."""
+    if active_flow_id is None or not skill_tool_funcs:
+        return
+    skill_id = active_skill.id if active_skill else active_flow_id
+    skill_funcs = skill_tool_funcs.get(skill_id, {})
+    if not skill_funcs:
+        return
+    active_tool_names = visible_custom_tool_names(
+        skill_catalog,
+        skill_id,
+        active_flow_id,
+        skill_funcs,
+        memory_values,
+    )
+    if active_tool_names:
+        schemas.extend(build_custom_tool_schemas(active_tool_names, skill_funcs))
 
 
 def tool_gate_statuses(

{rasa_pro-3.19.0.dev1 → rasa_pro-3.19.0.dev3}/rasa/calm_v2/memory/manager.py

@@ -70,10 +70,29 @@ CORRECTION_RESUME_ENTRY = "correction_resume_point"
 # :data:`_DISCOVERED_MAX_FACTS` (oldest evicted first).
 DISCOVERED_FACTS_ENTRY = "__discovered__"
 
+# Engine-internal system entry: a builder tool waiting on user yes/no before
+# dispatch (``requires_confirmation`` on ``GatedTool``). Payload shape is owned by
+# ``TrackerHandle`` / the confirmation gate in the skill executor.
+PENDING_TOOL_CONFIRMATION_ENTRY = "pending_tool_confirmation"
+
+# Engine-internal system entry: per-frame set of skill ``on: activate`` utter
+# triggers already emitted (``{frame_id: [response_name, ...]}``).
+ACTIVATE_TRIGGERS_FIRED_ENTRY = "verbatim_activate_triggers_fired"
+
+# Engine-internal system entry: per-frame ``when:`` trigger match state
+# (``{frame_id: {response_name: matched_bool}}``) updated after each evaluation.
+WHEN_TRIGGER_MATCH_STATE_ENTRY = "verbatim_when_trigger_match_state"
+
 # Registry of known system-scoped entry names. The ``system.*`` namespace is
 # engine-reserved (never a user-facing memory item — see ``reverse_lookup``).
 _SYSTEM_ENTRIES: frozenset[str] = frozenset(
-    {CORRECTION_RESUME_ENTRY, DISCOVERED_FACTS_ENTRY}
+    {
+        CORRECTION_RESUME_ENTRY,
+        DISCOVERED_FACTS_ENTRY,
+        PENDING_TOOL_CONFIRMATION_ENTRY,
+        ACTIVATE_TRIGGERS_FIRED_ENTRY,
+        WHEN_TRIGGER_MATCH_STATE_ENTRY,
+    }
 )