rasa-pro 3.20.0.dev3__tar.gz → 3.20.0.dev4__tar.gz

{rasa_pro-3.20.0.dev3 → rasa_pro-3.20.0.dev4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: rasa-pro
-Version: 3.20.0.dev3
+Version: 3.20.0.dev4
 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.20.0.dev3 → rasa_pro-3.20.0.dev4}/pyproject.toml

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

{rasa_pro-3.20.0.dev3 → rasa_pro-3.20.0.dev4}/rasa/agents/protocol/mcp/mcp_base_agent.py

@@ -125,7 +125,12 @@ from rasa.shared.utils.llm import (
     serialize_bot_response_for_prompt,
 )
 from rasa.shared.utils.mcp.server_connection import MCPServerConnection
-from rasa.shared.utils.mcp.utils import build_mcp_meta, call_tool_with_meta
+from rasa.shared.utils.mcp.utils import (
+    MAX_TOOL_NAME_LENGTH,
+    PROVIDER_UNSAFE_TOOL_NAME_CHARS,
+    build_mcp_meta,
+    call_tool_with_meta,
+)
 from rasa.tracing.langfuse_telemetry import update_current_span_metadata
 
 # Marker text for "previous run (completed)" in message content when agent restarted.
@@ -157,12 +162,6 @@ _MESSAGE_CACHE_BASE_MESSAGES = "base_messages"
 # `task_completed" />`); the debris always falls outside this character class.
 _LEADING_TOOL_NAME_PATTERN = re.compile(r"[A-Za-z0-9_.\-]+")
 
-# Characters a tool name may contain before providers start rejecting it.
-_PROVIDER_SAFE_TOOL_NAME_PATTERN = re.compile(r"[^A-Za-z0-9_\-]")
-
-# OpenAI's tool name limit. Also bounds how much of a mangled name is logged.
-_MAX_TOOL_NAME_LENGTH = 64
-
 # Stand-in used when a mangled name sanitises away to nothing, so the message
 # echoed back to the provider still carries a legal tool name.
 _PLACEHOLDER_TOOL_NAME = "unknown_tool"
@@ -1864,7 +1863,7 @@ class MCPBaseAgent(AgentProtocol):
                 structlogger.debug(
                     f"{component_name}.send_message.repaired_malformed_tool_name.raw",
                     event_info="The malformed tool name as returned by the provider.",
-                    raw_tool_name=raw_tool_name[:_MAX_TOOL_NAME_LENGTH],
+                    raw_tool_name=raw_tool_name[:MAX_TOOL_NAME_LENGTH],
                     tool_name=repaired_tool_name,
                     agent_name=self._name,
                     agent_id=agent_id,
@@ -1892,7 +1891,7 @@ class MCPBaseAgent(AgentProtocol):
                 structlogger.debug(
                     f"{component_name}.send_message.sanitized_tool_name.raw",
                     event_info="The unusable tool name as returned by the provider.",
-                    raw_tool_name=raw_tool_name[:_MAX_TOOL_NAME_LENGTH],
+                    raw_tool_name=raw_tool_name[:MAX_TOOL_NAME_LENGTH],
                     tool_name=provider_safe_tool_name,
                     agent_name=self._name,
                     agent_id=agent_id,
@@ -1917,8 +1916,8 @@ class MCPBaseAgent(AgentProtocol):
         Returns:
             A name matching `[A-Za-z0-9_-]{1,64}` that is not an available tool.
         """
-        sanitized = _PROVIDER_SAFE_TOOL_NAME_PATTERN.sub("", tool_name)[
-            :_MAX_TOOL_NAME_LENGTH
+        sanitized = PROVIDER_UNSAFE_TOOL_NAME_CHARS.sub("", tool_name)[
+            :MAX_TOOL_NAME_LENGTH
         ]
         if sanitized and sanitized not in available_tool_names:
             return sanitized

{rasa_pro-3.20.0.dev3 → rasa_pro-3.20.0.dev4}/rasa/builder/training_service.py

@@ -39,6 +39,7 @@ def update_agent(agent: Optional[Agent], app: Sanic) -> None:
     # agent swap (training, reload, shutdown via ``update_agent(None, app)``).
     previous_agent = getattr(app.ctx, "agent", None)
     if isinstance(previous_agent, Agent) and previous_agent is not agent:
+        app.add_task(previous_agent.close())
         previous_agent.stop_privacy_manager()
 
     app.ctx.agent = agent

rasa_pro-3.20.0.dev4/rasa/cli/project_templates/mantle/integrations.yml

@@ -0,0 +1,24 @@
+# External integrations for your Mantle agent.
+
+llm:
+  provider: openai
+  model: gpt-5.2
+  api_key_env: OPENAI_API_KEY
+
+channels:
+  rest:
+    enabled: true
+  inspector:
+    enabled: true
+
+# Optional — remote MCP tools (uncomment and set MCP_BANKING_TOKEN).
+# Import a tool in skill.md with: import_tools: [mcp/banking:get_balance]
+#
+# mcp_servers:
+#   - name: banking
+#     url: http://localhost:8000/mcp/
+#     token: ${MCP_BANKING_TOKEN}
+#     # tool_timeout: 30
+#     # meta_map:
+#     #   static:
+#     #     source: "rasa_agent"

{rasa_pro-3.20.0.dev3 → rasa_pro-3.20.0.dev4}/rasa/cli/tools/skills_data/mantle/mantle-building-skills/SKILL.md

@@ -113,6 +113,25 @@ import_tools:
   - get_customer_info        # shared: from tools/ at agent root
 ```
 
+- Remote MCP tools also require an `import_tools` entry. Declare the server in
+  the top-level `mcp_servers` list in `integrations.yml`, then import individual
+  tools with `mcp/<server-name>:<tool-name>`:
+
+```yaml
+# integrations.yml
+mcp_servers:
+  - name: banking
+    url: https://banking.example.com/mcp/
+    token: ${MCP_BANKING_TOKEN}
+
+# skills/check_balance/skill.md frontmatter
+import_tools:
+  - mcp/banking:get_balance
+```
+
+- Refer to the imported tool in the skill body as `@tool.get_balance`. MCP
+  imports are an allowlist; declaring a server does not expose every remote
+  tool.
 - A skill-local tool wins over a shared tool of the same name. Resolved once at
   model load.
 - To validate or clean a value right after it is written, define
@@ -190,7 +209,7 @@ responses emitted after the tool result (success vs error payload).
 ```yaml
 tool_constraints:
   - lock_card:
-      requires: "session.project.selected_card_id"
+      requires: "session.card_replace.selected_card_id"
   - process_card_replacement:
       requires: >
         session.card_replace.order_confirmed
@@ -205,7 +224,7 @@ tool_constraints:
 
 Placeholders in `responses.yml` bodies (including confirmation ask/denial):
 
-- `{session.<namespace>.<entry>}` — e.g. `{session.project.selected_card_label}`
+- `{session.<namespace>.<entry>}` — e.g. `{session.card_disambiguation.selected_card_label}`
 - `{entry}` — bare memory field; resolved skill-local first, then project scope
 
 Supplied `utter_for_confirmation` / `utter_on_user_denial` names must exist in
@@ -224,7 +243,7 @@ every memory reference uses three segments: `session.<skill_id>.<entry>` for a
 skill's own memory, `session.project.<entry>` for project-wide memory. A bare key
 is rejected at validation with `Unknown name '<key>' in condition expression`, so
 `requires: selected_card_id` does not work. Within that form you can write a
-truthiness check (`session.project.selected_card_id`), a boolean combination
+truthiness check (`session.card_replace.selected_card_id`), a boolean combination
 (`session.card_replace.order_confirmed and session.card_replace.shipping_type`,
 `not session.card_replace.fraud_report_filed`), or a comparison
 (`session.card_replace.replacement_reason == 'stolen'`). Use a folded `>` scalar
@@ -287,7 +306,7 @@ Set PII fields become bare `[set]` (the whole token, not `field: [set]`).
 Example:
 
 ```markdown
-Use the already chosen card @memory.project.selected_card_id for this request.
+Use the already chosen card @memory.card_replace.selected_card_id for this request.
 ```
 
 Keep `session.*` for structured YAML and conditions (`requires:`, `if:`,
@@ -380,7 +399,7 @@ steps:
     execute_tool: get_customer_info
   - id: select_card
     instructions: Show the customer their cards and ask which one needs replacing.
-    complete_when: "session.project.selected_card_id"
+    complete_when: "session.card_replace.selected_card_id"
 :::
 ```
 

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

@@ -2,16 +2,16 @@
 name: mantle-configuring-agent
 description: >
   Configures the Mantle project config files: agent.yml (identity, persona, rules,
-  prompt tuning, session settings), integrations.yml (LLM provider, channels
-  including voice ASR/TTS, model groups, Langfuse tracing), memory.yml (schema, cross-skill
+  prompt tuning, session settings, tool_timeout), integrations.yml (LLM provider, channels
+  including voice ASR/TTS, model groups, MCP servers, Langfuse tracing), memory.yml (schema, cross-skill
   visibility), and responses.yml (verbatim templates). Use when setting up or
-  changing any of these files.
+  changing any of these files, including declaring MCP servers and importing their tools.
 license: Apache-2.0
 engine: mantle
 rasa_version: ">=3.18"
 metadata:
   author: rasa
-  version: "0.1.6"
+  version: "0.1.7"
   docs-url: https://rasa-2f7eb63d.mintlify.site
 ---
 
@@ -72,9 +72,9 @@ The file has **two levels**, and mixing them up is the most common mistake:
   fails to load with `config.agent.missing_section`; a missing persona fails with
   `config.agent.missing_persona`.
 - **Top-level siblings** of `agent:`: `rules`, `prompts`, `references`,
-  `conversation`, `session_config`. Nesting these inside `agent:` means they are
-  never read, and unknown keys are ignored rather than rejected, so the mistake is
-  silent.
+  `conversation`, `tool_timeout`, `session_config`. Nesting these inside `agent:`
+  means they are never read, and unknown keys are ignored rather than rejected,
+  so the mistake is silent.
 
 Notes:
 
@@ -86,11 +86,15 @@ Notes:
 - `prompts` overrides individual sections of the system prompt: `text_rules`,
   `voice_rules`, `ack_rule`, `ack_reminder`, `ack_enabled`, `ack_examples`,
   `routing_no_active_skill`. Leave one unset to keep its built-in default.
+- `tool_timeout` is an optional wall-clock limit in seconds for local `@tool`
+  calls (default `10`). Imported MCP tools use the same value when the server
+  omits its own `tool_timeout` in `integrations.yml`.
 - `id` is generated and written back into the file when absent.
 
 ## integrations.yml — providers and infrastructure
 
-Holds the LLM provider, the input channels customers reach the agent through and optional Langfuse tracing.
+Holds the LLM provider, 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` in the `llm:` block, which
 names an environment variable and works for every provider. `${ENV_VAR}` expansion
 happens in the `channels:` block, which is read with environment variables
@@ -127,6 +131,41 @@ work by naming the provider and its model. `tracing` is optional and lives here
 `inspector` are the minimum for local work: `rest` is what the evaluation runner
 talks to, and `inspector` is required for `rasa inspect`.
 
+### MCP servers
+
+Declare each remote MCP server under the top-level `mcp_servers` list. The
+server `name` becomes part of every imported tool reference:
+
+```yaml integrations.yml
+mcp_servers:
+  - name: banking
+    url: https://banking.example.com/mcp/
+    token: ${MCP_BANKING_TOKEN}
+    # tool_timeout: 30
+```
+
+Use at most one auth strategy per server: `token`, `api_key`, `oauth`, or
+`module`. Secrets must use `${ENV_VAR}` references. `tool_timeout` overrides the
+top-level `agent.yml` default for this server.
+
+An MCP server declaration does not expose all of its tools. Each skill
+allowlists only the tools it needs in `skill.md`:
+
+```yaml skills/check_balance/skill.md
+---
+name: Check balance
+description: Look up a customer's account balance.
+import_tools:
+  - mcp/banking:get_balance
+---
+
+Ask for the account number, then call @tool.get_balance.
+```
+
+The import format is `mcp/<server-name>:<tool-name>`. The server name must match
+an `mcp_servers` entry; startup fails if the server or imported tool is
+unavailable.
+
 ### Voice channels
 
 Speech recognition and synthesis are configured **inside the voice channel entry**,
@@ -214,13 +253,25 @@ Types: `text`, `bool`, `int`, `float`, `list`, `json`, `categorical` (with
 `enum_values`), and `any`. Give each a `description`: it is what the LLM sees when
 deciding whether to record a value.
 
-Add `llm_settable: true` to let the LLM write an entry itself. Leave it off for
-engine-derived values such as eligibility results or computed flags, so the model
-can neither invent nor revise them. A value owned by a `collect:` step is settable
-either way, since the engine asked the user for it directly.
-
-A project-level `memory.yml` uses the same `type`/`description` shape but as a flat
-map of top-level keys, with no `schema:`/`public:`/`private:` wrapper.
+Add `llm_settable: true` on a **skill** entry to let the LLM write it. Leave it
+off for engine-derived values (eligibility, computed flags). A skill `collect:`
+value is settable either way. Both flags are skill-only: a project field with
+`llm_settable` or `collect:` fails `rasa train`.
+
+Root `memory.yml` is a flat map (no `schema:` / public / private). The LLM cannot
+write it. The first write is a tool, a post-write hook, or `seed: true` (project
+only, off by default). After that the value stays set for the session.
+
+```yaml memory.yml
+authenticated:
+  type: bool
+  description: Whether the customer has verified their identity.
+caller_phone:
+  type: text
+  seed: true
+  pii: true
+  description: Phone number from the voice channel at connect time.
+```
 
 Design rule: `public` is the skill's API. Another skill gating on
 `session.project.authenticated` depends only on that key, not on the auth skill
@@ -311,10 +362,10 @@ agent sounds natural.
 ## Don't
 
 - Don't put secrets literally in any of these files. Use `api_key_env` in `llm:`
-  and `${ENV_VAR}` in `channels:`.
-- Don't nest `rules`, `prompts`, `references`, `conversation`, or `session_config`
-  inside the `agent:` block. They are top-level siblings, and nesting them is
-  ignored silently.
+  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.
 - Don't put skill behavior in `persona` or global config; behavior belongs in the
   owning skill's `skill.md`.
 - Don't create `domain.yml`, `config.yml`, `credentials.yml`, or an
@@ -337,6 +388,7 @@ Most relevant here:
 
 - [Project structure](https://rasa-2f7eb63d.mintlify.site/reference/project-structure): every file and folder an agent recognises, and which are required
 - [agent.yml reference](https://rasa-2f7eb63d.mintlify.site/reference/agent-yml): every key, and which are top-level rather than nested
-- [integrations.yml reference](https://rasa-2f7eb63d.mintlify.site/reference/integrations-yml): LLM providers, channels, voice ASR/TTS, model groups
+- [integrations.yml reference](https://rasa-2f7eb63d.mintlify.site/reference/integrations-yml): LLM providers, channels, voice ASR/TTS, model groups, MCP servers
+- [Import MCP tools](https://rasa-2f7eb63d.mintlify.site/concepts/tools#mcp-tools): declare a server, then allowlist tools with `import_tools`
 - [memory.yml reference](https://rasa-2f7eb63d.mintlify.site/reference/memory-yml): skill schema vs project memory, types, access control
 - [responses.yml reference](https://rasa-2f7eb63d.mintlify.site/reference/responses-yml): templates, conditional variants, interpolation, and the four ways a response fires

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

@@ -131,8 +131,8 @@ assertions:
 
   # ordered checks — each child must occur, in this order
   - sequencing:
-      - slot_was_set: project.selected_card_id  # set once...
-      - slot_was_set: project.selected_card_id  # ...then re-set (a correction)
+      - slot_was_set: card_replace.selected_card_id  # set once...
+      - slot_was_set: card_replace.selected_card_id  # ...then re-set (a correction)
 ```
 
 The docs list more assertion types you can reach for as needed — `action_executed`,

{rasa_pro-3.20.0.dev3 → rasa_pro-3.20.0.dev4}/rasa/core/agent.py

@@ -28,7 +28,7 @@ from rasa.core.available_agents import AvailableAgents
 from rasa.core.channels.channel import OutputChannel, UserMessage
 from rasa.core.config.available_endpoints import AvailableEndpoints
 from rasa.core.constants import DEFAULT_REQUEST_TIMEOUT
-from rasa.core.exceptions import AgentNotReady
+from rasa.core.exceptions import AgentNotReady, RuntimeIntegrationsPrepareError
 from rasa.core.http_interpreter import RasaNLUHttpInterpreter
 from rasa.core.information_retrieval.faiss import LegacyFaissModelError
 from rasa.core.lock_store import InMemoryLockStore, LockStore
@@ -99,6 +99,12 @@ async def _load_and_set_updated_model(
 ) -> None:
     """Load the persisted model into memory and set the model on the agent.
 
+    The replacement processor is built and prepared off to the side, and only
+    installed once its runtime integrations are live. Turns that start during
+    the refresh therefore keep running on the previous processor instead of
+    reaching a processor whose MCP connections are still being established, and
+    a prepare that fails or is cancelled never touches the serving processor.
+
     Args:
         agent: Instance of `Agent` to update with the new model.
         model_directory: Rasa model directory.
@@ -108,7 +114,23 @@ async def _load_and_set_updated_model(
         "_load_and_set_updated_model.loading",
         message=f"Found new model with fingerprint {fingerprint}. Loading...",
     )
-    agent.load_model(model_directory, fingerprint)
+    replacement = agent._create_processor(model_directory)
+    try:
+        await _prepare_runtime_integrations(replacement)
+    except BaseException:
+        # Include CancelledError: a cancelled prepare must not leak the
+        # connections the replacement opened before it was interrupted.
+        await replacement.close_runtime_integrations()
+        raise
+
+    previous_processor = agent.processor
+    # Synchronous swap: no await between here and the last assignment, so no
+    # turn can observe a half-installed model.
+    agent._set_loaded_model(replacement)
+    agent._set_fingerprint(fingerprint)
+
+    # Drain: close waits for in-flight MCP calls on the retired processor.
+    await _close_replaced_processor(previous_processor, replacement)
 
     logger.debug(
         "_load_and_set_updated_model.loaded",
@@ -116,6 +138,34 @@ async def _load_and_set_updated_model(
     )
 
 
+async def _prepare_runtime_integrations(processor: MessageProcessor) -> None:
+    """Prepare a processor's integrations, tagging failures as a prepare error.
+
+    Raises:
+        RuntimeIntegrationsPrepareError: If processor integration setup fails.
+    """
+    try:
+        await processor.prepare_runtime_integrations()
+    except Exception as e:
+        raise RuntimeIntegrationsPrepareError(
+            f"Failed to prepare runtime integrations: {e}",
+            suppress_stack_trace=True,
+        ) from e
+
+
+async def _close_replaced_processor(
+    retired: Optional[MessageProcessor],
+    kept: Optional[MessageProcessor],
+) -> None:
+    """Close integrations on a processor that is no longer serving traffic.
+
+    MCP close waits for in-flight tool calls on that processor so a refresh
+    does not drop a connection under a live turn.
+    """
+    if retired is not None and retired is not kept:
+        await retired.close_runtime_integrations()
+
+
 async def _update_model_from_server(model_server: EndpointConfig, agent: Agent) -> None:
     """Load a zipped Rasa Core model from a URL and update the passed agent."""
     if not is_url(model_server.url):
@@ -368,11 +418,13 @@ async def load_agent(
                 "Agent loaded with no model!"
             )
 
+        await agent.prepare_runtime_integrations()
+
         if agent.processor and sub_agents:
             # CLI commands that accept --sub-agents all route through this entry
             # point. With the model loaded, this is the best spot to initialise
             # the sub-agents. The processor knows how: CALM v1 reads the model's
-            # flows, while CALM v2 (empty graph, no flows_provider) is a no-op.
+            # flows, while Mantle (empty graph, no flows_provider) is a no-op.
             await agent.processor.prepare_subagents(sub_agents)
 
         # Initialize timer manager after model is loaded
@@ -406,6 +458,22 @@ async def load_agent(
             event_info=str(e),
         )
         raise e from None
+    except RuntimeIntegrationsPrepareError as e:
+        # Fail closed: do not return a ready agent without MCP / integrations.
+        # Report the failing integration like the expected failures above rather
+        # than dumping the connect / list_tools chain; `--debug` keeps the full
+        # traceback for diagnosing which server and call site failed.
+        logger.error(
+            "load_agent.runtime_integrations_prepare_failed",
+            event_info=str(e),
+            error_type=type(e.__cause__).__name__ if e.__cause__ else None,
+        )
+        logger.debug(
+            "load_agent.runtime_integrations_prepare_failed.debug",
+            event_info=str(e),
+            exc_info=True,
+        )
+        raise e from None
     except Exception as e:
         logger.error(
             "load_agent.could_not_load_model",
@@ -509,8 +577,23 @@ class Agent:
     def load_model(
         self, model_path: Union[Text, Path], fingerprint: Optional[Text] = None
     ) -> None:
-        """Loads the agent's model and processor given a new model path."""
-        self.processor = create_message_processor(
+        """Load the agent's model and processor given a new model path.
+
+        This synchronous method only installs the processor. Async entry points
+        must subsequently await :meth:`prepare_runtime_integrations` before the
+        agent serves traffic. :func:`load_agent` and model-server refreshes
+        enforce that lifecycle contract.
+
+        Only use this on an agent that is not serving traffic yet. To refresh a
+        live agent, prepare a processor from :meth:`_create_processor` first and
+        install it once it is ready, as :func:`_load_and_set_updated_model` does.
+        """
+        self._set_loaded_model(self._create_processor(model_path))
+        self._set_fingerprint(fingerprint)
+
+    def _create_processor(self, model_path: Union[Text, Path]) -> MessageProcessor:
+        """Build a processor for *model_path* without installing it on the agent."""
+        return create_message_processor(
             model_path=model_path,
             tracker_store=self.tracker_store,
             lock_store=self.lock_store,
@@ -522,20 +605,6 @@ class Agent:
             privacy_manager=self.privacy_manager,
         )
 
-        self.domain = self.processor.domain
-
-        self._set_fingerprint(fingerprint)
-
-        # update domain on all instances
-        self.tracker_store.domain = self.domain
-        # CALM v2 owns its slot names via the memory layer rather than a generated
-        # domain, so its tracker must accept any (namespaced) slot on demand.
-        self.tracker_store.use_permissive_slots = (
-            getattr(self.processor, "engine_version", None) == MANTLE_ENGINE_VERSION
-        )
-        if isinstance(self.nlg, TemplatedNaturalLanguageGenerator):
-            self.nlg.responses = self.domain.responses if self.domain else {}
-
     @property
     def model_id(self) -> Optional[Text]:
         """Returns the model_id from processor's model_metadata."""
@@ -582,6 +651,9 @@ class Agent:
         This stops the timer manager and performs any necessary cleanup.
         Should be called when the agent is no longer needed.
         """
+        if self.processor is not None:
+            await self.processor.close_runtime_integrations()
+
         if self.timer_manager is not None:
             await self.timer_manager.stop()
             logger.debug(
@@ -589,6 +661,16 @@ class Agent:
                 message="Timer manager stopped",
             )
 
+    async def prepare_runtime_integrations(self) -> None:
+        """Prepare integrations after ``load_model`` and before serving traffic.
+
+        Raises:
+            RuntimeIntegrationsPrepareError: If processor integration setup fails.
+        """
+        if self.processor is None:
+            return
+        await _prepare_runtime_integrations(self.processor)
+
     def stop_privacy_manager(self) -> None:
         """Stop the privacy manager's background scheduler thread, if any.
 
@@ -881,6 +963,19 @@ class Agent:
 
         return await self.handle_message(msg)
 
+    def _set_loaded_model(self, processor: MessageProcessor) -> None:
+        """Point the agent, tracker, and NLG at a processor."""
+        self.processor = processor
+        self.domain = processor.domain
+        self.tracker_store.domain = self.domain
+        # Mantle owns its slot names via the memory layer rather than a generated
+        # domain, so its tracker must accept any (namespaced) slot on demand.
+        self.tracker_store.use_permissive_slots = (
+            getattr(processor, "engine_version", None) == MANTLE_ENGINE_VERSION
+        )
+        if isinstance(self.nlg, TemplatedNaturalLanguageGenerator):
+            self.nlg.responses = self.domain.responses if self.domain else {}
+
     def _set_fingerprint(self, fingerprint: Optional[Text] = None) -> None:
         if fingerprint:
             self.fingerprint = fingerprint

{rasa_pro-3.20.0.dev3 → rasa_pro-3.20.0.dev4}/rasa/core/channels/conversation_queue/queue.py

@@ -192,13 +192,6 @@ class InMemoryConversationQueue(Generic[T]):
         """
         queue_event = self._wrap(event)
         await self._queue.put(queue_event)
-        structlogger.debug(
-            "conversation_queue.event_enqueued",
-            conversation_id=self._conversation_id,
-            event_type=type(event).__name__,
-            priority=self._priority_of(event),
-            queue_size=self._queue.qsize(),
-        )
 
     async def get(self) -> T:
         """Get the next event from the queue.
@@ -209,13 +202,6 @@ class InMemoryConversationQueue(Generic[T]):
             The next event in the queue.
         """
         event = self._unwrap(await self._queue.get())
-        structlogger.debug(
-            "conversation_queue.event_dequeued",
-            conversation_id=self._conversation_id,
-            event_type=type(event).__name__,
-            priority=self._priority_of(event),
-            queue_size=self._queue.qsize(),
-        )
         return event
 
     async def drain(self) -> list[T]:
@@ -265,12 +251,6 @@ class InMemoryConversationQueue(Generic[T]):
         first = await self.get()
         rest = await self.drain()
         batch = [first, *rest]
-        structlogger.debug(
-            "conversation_queue.get_batch",
-            conversation_id=self._conversation_id,
-            event_count=len(batch),
-            event_types=[type(e).__name__ for e in batch],
-        )
         return batch
 
     def _wrap(self, event: T) -> _QueueItem[T]: