rasa-pro 3.11.3a1.dev6__tar.gz → 3.11.3a1.dev7__tar.gz

{rasa_pro-3.11.3a1.dev6 → rasa_pro-3.11.3a1.dev7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: rasa-pro
-Version: 3.11.3a1.dev6
+Version: 3.11.3a1.dev7
 Summary: State-of-the-art open-core Conversational AI framework for Enterprises that natively leverages generative AI for effortless assistant development.
 Home-page: https://rasa.com
 Keywords: nlp,machine-learning,machine-learning-library,bot,bots,botkit,rasa conversational-agents,conversational-ai,chatbot,chatbot-framework,bot-framework

{rasa_pro-3.11.3a1.dev6 → rasa_pro-3.11.3a1.dev7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "rasa-pro"
-version = "3.11.3a1.dev6"
+version = "3.11.3a1.dev7"
 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.11.3a1.dev6 → rasa_pro-3.11.3a1.dev7}/rasa/core/actions/action.py

@@ -17,7 +17,7 @@ from jsonschema import Draft202012Validator
 
 import rasa.core
 import rasa.shared.utils.io
-from rasa.core.actions.constants import (
+from rasa.shared.constants import (
     TEXT,
     ELEMENTS,
     QUICK_REPLIES,
@@ -102,7 +102,6 @@ from rasa.shared.nlu.constants import (
     INTENT_NAME_KEY,
     INTENT_RANKING_KEY,
 )
-from rasa.shared.nlu.constants import PROMPTS
 from rasa.shared.utils.io import raise_warning
 from rasa.shared.utils.schemas.events import EVENTS_SCHEMA
 from rasa.utils.endpoints import ClientResponseError, EndpointConfig
@@ -277,7 +276,6 @@ def create_bot_utterance(message: Dict[Text, Any]) -> BotUttered:
             ATTACHMENT: message.pop(ATTACHMENT, None) or message.get(IMAGE, None),
             IMAGE: message.pop(IMAGE, None),
             CUSTOM: message.pop(CUSTOM, None),
-            PROMPTS: message.pop(PROMPTS, None),
         },
         metadata=message,
     )

{rasa_pro-3.11.3a1.dev6 → rasa_pro-3.11.3a1.dev7}/rasa/core/actions/constants.py

@@ -3,11 +3,3 @@ SELECTIVE_DOMAIN = "enable_selective_domain"
 
 SSL_CLIENT_CERT_FIELD = "ssl_client_cert"
 SSL_CLIENT_KEY_FIELD = "ssl_client_key"
-
-TEXT = "text"
-ELEMENTS = "elements"
-QUICK_REPLIES = "quick_replies"
-BUTTONS = "buttons"
-ATTACHMENT = "attachment"
-IMAGE = "image"
-CUSTOM = "custom"

{rasa_pro-3.11.3a1.dev6 → rasa_pro-3.11.3a1.dev7}/rasa/core/channels/__init__.py

@@ -31,6 +31,7 @@ from rasa.core.channels.vier_cvg import CVGInput
 from rasa.core.channels.voice_stream.twilio_media_streams import (
     TwilioMediaStreamsInputChannel,
 )
+from rasa.core.channels.studio_chat import StudioChatInput
 
 input_channel_classes: List[Type[InputChannel]] = [
     CmdlineInput,
@@ -53,6 +54,7 @@ input_channel_classes: List[Type[InputChannel]] = [
     JambonzVoiceReadyInput,
     TwilioMediaStreamsInputChannel,
     BrowserAudioInputChannel,
+    StudioChatInput,
 ]
 
 # Mapping from an input channel name to its class to allow name based lookup.

{rasa_pro-3.11.3a1.dev6 → rasa_pro-3.11.3a1.dev7}/rasa/core/channels/development_inspector.py

@@ -88,9 +88,6 @@ class DevelopmentInspectProxy(InputChannel):
         """Called when a tracker has been updated."""
         if self.tracker_stream:
             tracker_dump = await self.get_tracker_state(sender_id)
-            # check if the underlying channel has an on_new_tracker_dump hook
-            if hasattr(self.underlying, "on_new_tracker_dump"):
-                await self.underlying.on_new_tracker_dump(sender_id, tracker_dump)
             await self.tracker_stream.broadcast(tracker_dump)
 
     async def on_message_proxy(

{rasa_pro-3.11.3a1.dev6 → rasa_pro-3.11.3a1.dev7}/rasa/core/channels/socketio.py

@@ -1,4 +1,3 @@
-import asyncio
 import inspect
 import logging
 import uuid
@@ -7,7 +6,6 @@ from typing import Any, Awaitable, Callable, Dict, Iterable, List, Optional, Tex
 
 import rasa.core.channels.channel
 from rasa.core.channels.channel import InputChannel, OutputChannel, UserMessage
-from rasa.shared.core.trackers import EventVerbosity
 import rasa.shared.utils.io
 from sanic import Blueprint, response, Sanic
 from sanic.request import Request
@@ -56,31 +54,9 @@ class SocketIOOutput(OutputChannel):
         super().__init__()
         self.sio = sio
         self.bot_message_evt = bot_message_evt
-        self.last_event_timestamp = (
-            -1
-        )  # Initialize with -1 to send all events on first message
-
-    def _get_new_events(self) -> List[Dict[Text, Any]]:
-        """Get events that are newer than the last sent event."""
-        events = self.tracker_state.get("events", []) if self.tracker_state else []
-        new_events = [
-            event for event in events if event["timestamp"] > self.last_event_timestamp
-        ]
-        if new_events:
-            self.last_event_timestamp = new_events[-1]["timestamp"]
-        return new_events
 
     async def _send_message(self, socket_id: Text, response: Any) -> None:
         """Sends a message to the recipient using the bot event."""
-        # send tracker state (contains stack, slots and more)
-        await self.sio.emit("tracker_state", self.tracker_state, room=socket_id)
-
-        # send new events
-        new_events = self._get_new_events()
-        if new_events:
-            await self.sio.emit("rasa_events", new_events, room=socket_id)
-
-        # send bot response
         await self.sio.emit(self.bot_message_evt, response, room=socket_id)
 
     async def send_text_message(
@@ -190,8 +166,6 @@ class SocketIOInput(InputChannel):
         metadata_key: Optional[Text] = "metadata",
     ):
         """Creates a ``SocketIOInput`` object."""
-        from rasa.core.agent import Agent
-
         self.bot_message_evt = bot_message_evt
         self.session_persistence = session_persistence
         self.user_message_evt = user_message_evt
@@ -203,8 +177,6 @@ class SocketIOInput(InputChannel):
         self.jwt_key = jwt_key
         self.jwt_algorithm = jwt_method
 
-        self.agent: Optional[Agent] = None
-
     def get_output_channel(self) -> Optional["OutputChannel"]:
         """Creates socket.io output channel object."""
         if self.sio is None:
@@ -218,13 +190,9 @@ class SocketIOInput(InputChannel):
             return None
         return SocketIOOutput(self.sio, self.bot_message_evt)
 
-    async def on_new_tracker_dump(self, sender_id: str, tracker_dump: str) -> None:
-        if self.sio:
-            await self.sio.emit("tracker", tracker_dump, room=sender_id)
-
     def blueprint(
         self, on_new_message: Callable[[UserMessage], Awaitable[Any]]
-    ) -> Blueprint:
+    ) -> SocketBlueprint:
         """Defines a Sanic blueprint."""
         # Workaround so that socketio works with requests from other origins.
         # https://github.com/miguelgrinberg/python-socketio/issues/205#issuecomment-493769183
@@ -233,11 +201,6 @@ class SocketIOInput(InputChannel):
             sio, self.socketio_path, "socketio_webhook", __name__
         )
 
-        @socketio_webhook.listener("after_server_start")  # type: ignore[misc]
-        async def after_server_start(app: Sanic, _: asyncio.AbstractEventLoop) -> None:
-            """Prints a message after the server has started with inspect URL."""
-            self.agent = app.ctx.agent
-
         # make sio object static to use in get_output_channel
         self.sio = sio
 
@@ -283,30 +246,6 @@ class SocketIOInput(InputChannel):
             await sio.emit("session_confirm", data["session_id"], room=sid)
             logger.debug(f"User {sid} connected to socketIO endpoint.")
 
-        @sio.on("tracker", namespace=self.namespace)
-        async def handle_tracker(sid: Text, data: Dict) -> None:
-            from rasa.shared.core.trackers import DialogueStateTracker
-
-            if self.agent is None:
-                raise ValueError("Agent is not initialized")
-
-            async with self.agent.lock_store.lock(data["sender_id"]):
-                tracker = DialogueStateTracker.from_dict(
-                    data["sender_id"], data["events"], self.agent.domain.slots
-                )
-
-                # will override an existing tracker with the same id!
-                await self.agent.tracker_store.save(tracker)
-
-            # TODO: rather figure out how to trigger the on_tracker_updated
-            #   of the development inspector channel
-            state = tracker.current_state(EventVerbosity.AFTER_RESTART)
-            await sio.emit(
-                "tracker",
-                json.dumps(state),
-                room=sid,
-            )
-
         @sio.on(self.user_message_evt, namespace=self.namespace)
         async def handle_message(sid: Text, data: Dict) -> None:
             output_channel = SocketIOOutput(sio, self.bot_message_evt)

rasa_pro-3.11.3a1.dev7/rasa/core/channels/studio_chat.py

@@ -0,0 +1,192 @@
+import asyncio
+from functools import partial
+import json
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Awaitable,
+    Callable,
+    Dict,
+    List,
+    Optional,
+    Text,
+)
+import structlog
+
+from rasa.core.channels.socketio import SocketBlueprint, SocketIOInput
+from rasa.shared.core.trackers import EventVerbosity
+from sanic import Sanic
+from rasa.plugin import plugin_manager
+from rasa.hooks import hookimpl
+
+if TYPE_CHECKING:
+    from rasa.core.channels.channel import UserMessage
+    from rasa.shared.core.trackers import DialogueStateTracker
+
+
+structlogger = structlog.get_logger()
+
+
+def tracker_as_dump(tracker: "DialogueStateTracker") -> str:
+    """Create a dump of the tracker state."""
+    from rasa.shared.core.trackers import get_trackers_for_conversation_sessions
+
+    multiple_tracker_sessions = get_trackers_for_conversation_sessions(tracker)
+
+    if 0 <= len(multiple_tracker_sessions) <= 1:
+        last_tracker = tracker
+    else:
+        last_tracker = multiple_tracker_sessions[-1]
+
+    state = last_tracker.current_state(EventVerbosity.AFTER_RESTART)
+    return json.dumps(state)
+
+
+class StudioTrackerUpdatePlugin:
+    """Plugin for publishing tracker updates a socketio channel."""
+
+    def __init__(self, socket_channel: "StudioChatInput") -> None:
+        self.socket_channel = socket_channel
+        self.tasks: List[asyncio.Task] = []
+
+    def _cancel_tasks(self) -> None:
+        """Cancel all remaining tasks."""
+        for task in self.tasks:
+            task.cancel()
+        self.tasks = []
+
+    def _cleanup_tasks(self) -> None:
+        """Remove tasks that have already completed."""
+        self.tasks = [task for task in self.tasks if not task.done()]
+
+    @hookimpl  # type: ignore[misc]
+    def after_new_user_message(self, tracker: "DialogueStateTracker") -> None:
+        """Triggers a tracker update notification after a new user message."""
+        self.handle_tracker_update(tracker)
+
+    @hookimpl  # type: ignore[misc]
+    def after_action_executed(self, tracker: "DialogueStateTracker") -> None:
+        """Triggers a tracker update notification after an action is executed."""
+        self.handle_tracker_update(tracker)
+
+    def handle_tracker_update(self, tracker: "DialogueStateTracker") -> None:
+        """Handles a tracker update when triggered by a hook."""
+        structlogger.info("studio_chat.after_tracker_update", tracker=tracker)
+        # directly create a dump to avoid the tracker getting modified by another
+        # function before it gets published (since the publishing is scheduled
+        # as an async task)
+        tracker_dump = tracker_as_dump(tracker)
+        task = asyncio.create_task(
+            self.socket_channel.publish_tracker_update(tracker.sender_id, tracker_dump)
+        )
+        self.tasks.append(task)
+        self._cleanup_tasks()
+
+    @hookimpl  # type: ignore[misc]
+    def after_server_stop(self) -> None:
+        """Cancels all remaining tasks when the server stops."""
+        self._cancel_tasks()
+
+
+class StudioChatInput(SocketIOInput):
+    """Input channel for the communication between Rasa Studio and Rasa Pro."""
+
+    @classmethod
+    def name(cls) -> Text:
+        return "studio_chat"
+
+    def __init__(
+        self,
+        *args: Any,
+        **kwargs: Any,
+    ) -> None:
+        """Creates a ``SocketIOInput`` object."""
+        from rasa.core.agent import Agent
+
+        super().__init__(*args, **kwargs)
+        self.agent: Optional[Agent] = None
+
+        self._register_tracker_update_hook()
+
+    def _register_tracker_update_hook(self) -> None:
+        plugin_manager().register(StudioTrackerUpdatePlugin(self))
+
+    async def on_tracker_updated(self, tracker: "DialogueStateTracker") -> None:
+        """Triggers a tracker update notification after a change to the tracker."""
+        await self.publish_tracker_update(tracker.sender_id, tracker_as_dump(tracker))
+
+    async def publish_tracker_update(self, sender_id: str, tracker_dump: Dict) -> None:
+        """Publishes a tracker update notification to the websocket."""
+        if not self.sio:
+            structlogger.error("studio_chat.on_tracker_updated.sio_not_initialized")
+            return
+        await self.sio.emit("tracker", tracker_dump, room=sender_id)
+
+    async def on_message_proxy(
+        self,
+        on_new_message: Callable[["UserMessage"], Awaitable[Any]],
+        message: "UserMessage",
+    ) -> None:
+        """Proxies the on_new_message call to the underlying channel.
+
+        Triggers a tracker update notification after processing the message.
+        """
+        await on_new_message(message)
+
+        if not self.agent:
+            structlogger.error("studio_chat.on_message_proxy.agent_not_initialized")
+            return
+
+        tracker = await self.agent.tracker_store.retrieve(message.sender_id)
+        if tracker is None:
+            structlogger.error("studio_chat.on_message_proxy.tracker_not_found")
+            return
+
+        await self.on_tracker_updated(tracker)
+
+    async def handle_tracker_update(self, sid: str, data: Dict) -> None:
+        from rasa.shared.core.trackers import DialogueStateTracker
+
+        structlogger.debug(
+            "studio_chat.sio.handle_tracker_update",
+            sid=sid,
+            sender_id=data["sender_id"],
+        )
+        if self.agent is None:
+            structlogger.error("studio_chat.sio.agent_not_initialized")
+            return None
+
+        if not (domain := self.agent.domain):
+            structlogger.error("studio_chat.sio.domain_not_initialized")
+            return None
+
+        async with self.agent.lock_store.lock(data["sender_id"]):
+            tracker = DialogueStateTracker.from_dict(
+                data["sender_id"], data["events"], domain.slots
+            )
+
+            # will override an existing tracker with the same id!
+            await self.agent.tracker_store.save(tracker)
+
+        await self.on_tracker_updated(tracker)
+
+    def blueprint(
+        self, on_new_message: Callable[["UserMessage"], Awaitable[Any]]
+    ) -> SocketBlueprint:
+        socket_blueprint = super().blueprint(
+            partial(self.on_message_proxy, on_new_message)
+        )
+
+        if not self.sio:
+            structlogger.error("studio_chat.blueprint.sio_not_initialized")
+            return socket_blueprint
+
+        @socket_blueprint.listener("after_server_start")  # type: ignore[misc]
+        async def after_server_start(app: Sanic, _: asyncio.AbstractEventLoop) -> None:
+            self.agent = app.ctx.agent
+
+        @self.sio.on("update_tracker", namespace=self.namespace)
+        async def on_update_tracker(sid: Text, data: Dict) -> None:
+            await self.handle_tracker_update(sid, data)
+
+        return socket_blueprint

{rasa_pro-3.11.3a1.dev6 → rasa_pro-3.11.3a1.dev7}/rasa/core/nlg/contextual_response_rephraser.py

@@ -23,6 +23,8 @@ from rasa.shared.nlu.constants import (
     PROMPTS,
     KEY_USER_PROMPT,
     KEY_LLM_RESPONSE_METADATA,
+    KEY_PROMPT_NAME,
+    KEY_COMPONENT_NAME,
 )
 from rasa.shared.providers.llm.llm_response import LLMResponse
 from rasa.shared.utils.health_check.llm_health_check_mixin import LLMHealthCheckMixin
@@ -153,24 +155,15 @@ class ContextualResponseRephraser(
             return response
 
         prompt_data: Dict[Text, Any] = {
+            KEY_COMPONENT_NAME: cls.__name__,
+            KEY_PROMPT_NAME: prompt_name,
             KEY_USER_PROMPT: user_prompt,
+            KEY_LLM_RESPONSE_METADATA: llm_response.to_dict() if llm_response else None,
         }
 
-        if llm_response is not None:
-            prompt_data[KEY_LLM_RESPONSE_METADATA] = llm_response.to_dict()
-        else:
-            prompt_data[KEY_LLM_RESPONSE_METADATA] = None
-
-        prompt_tuple = (prompt_name, prompt_data)
-
-        component_name = cls.__name__
-        component_prompts = response.get(PROMPTS, {})
-        if component_name in component_prompts:
-            component_prompts[component_name].append(prompt_tuple)
-        else:
-            component_prompts[component_name] = [prompt_tuple]
-
-        response[PROMPTS] = component_prompts
+        prompts = response.get(PROMPTS, [])
+        prompts.append(prompt_data)
+        response[PROMPTS] = prompts
         return response
 
     def _last_message_if_human(self, tracker: DialogueStateTracker) -> Optional[str]:
@@ -315,7 +308,7 @@ class ContextualResponseRephraser(
             llm_response=llm_response,
         )
 
-        if llm_response is None or not llm_response.choices:
+        if not (llm_response and llm_response.choices and llm_response.choices[0]):
             # If the LLM fails to generate a response, return the original response.
             return response
 

{rasa_pro-3.11.3a1.dev6 → rasa_pro-3.11.3a1.dev7}/rasa/core/policies/enterprise_search_policy.py

@@ -68,6 +68,8 @@ from rasa.shared.nlu.constants import (
     PROMPTS,
     KEY_USER_PROMPT,
     KEY_LLM_RESPONSE_METADATA,
+    KEY_PROMPT_NAME,
+    KEY_COMPONENT_NAME,
 )
 from rasa.shared.nlu.training_data.training_data import TrainingData
 from rasa.shared.providers.embedding._langchain_embedding_client_adapter import (
@@ -304,24 +306,17 @@ class EnterpriseSearchPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Po
             return
 
         parse_data = tracker.latest_message.parse_data
-        if parse_data is not None and PROMPTS not in parse_data:
-            parse_data[PROMPTS] = {}  # type: ignore[literal-required]
-
-        component_name = cls.__name__
-        component_prompts = parse_data[PROMPTS].get(component_name, [])  # type: ignore[literal-required]
+        if PROMPTS not in parse_data:
+            parse_data[PROMPTS] = []  # type: ignore[literal-required]
 
         prompt_data: Dict[Text, Any] = {
+            KEY_COMPONENT_NAME: cls.__name__,
+            KEY_PROMPT_NAME: prompt_name,
             KEY_USER_PROMPT: user_prompt,
+            KEY_LLM_RESPONSE_METADATA: llm_response.to_dict() if llm_response else None,
         }
 
-        if llm_response is not None:
-            prompt_data[KEY_LLM_RESPONSE_METADATA] = llm_response.to_dict()
-        else:
-            prompt_data[KEY_LLM_RESPONSE_METADATA] = None
-
-        prompt_tuple = (prompt_name, prompt_data)
-        component_prompts.append(prompt_tuple)
-        parse_data[PROMPTS][component_name] = component_prompts  # type: ignore[literal-required]
+        parse_data[PROMPTS].append(prompt_data)  # type: ignore[literal-required]
 
     def train(  # type: ignore[override]
         self,
@@ -549,8 +544,8 @@ class EnterpriseSearchPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Po
 
         if self.use_llm:
             prompt = self._render_prompt(tracker, documents.results)
-            response = await self._generate_llm_answer(llm, prompt)
-            llm_response = LLMResponse.ensure_llm_response(response)
+            llm_response = await self._generate_llm_answer(llm, prompt)
+            llm_response = LLMResponse.ensure_llm_response(llm_response)
 
             self._add_prompt_and_llm_response_to_latest_message(
                 tracker=tracker,

{rasa_pro-3.11.3a1.dev6 → rasa_pro-3.11.3a1.dev7}/rasa/core/processor.py

@@ -818,8 +818,9 @@ class MessageProcessor:
         return parse_data
 
     def _sanitize_message(self, message: UserMessage) -> UserMessage:
-        """Sanitize user message by removing prepended slashes before the
-        actual content.
+        """Sanitize user messages.
+
+        Removes prepended slashes before the actual content.
         """
         # Regex pattern to match leading slashes and any whitespace before
         # actual content
@@ -921,9 +922,7 @@ class MessageProcessor:
         return [command.as_dict() for command in commands]
 
     def _contains_undefined_intent(self, message: Message) -> bool:
-        """Checks if the message contains an intent that is undefined
-        in the domain.
-        """
+        """Checks if the message contains an undefined intent."""
         intent_name = message.get(INTENT, {}).get("name")
         return intent_name is not None and intent_name not in self.domain.intents
 
@@ -987,6 +986,8 @@ class MessageProcessor:
         if parse_data["entities"]:
             self._log_slots(tracker)
 
+        plugin_manager().hook.after_new_user_message(tracker=tracker)
+
         logger.debug(
             f"Logged UserUtterance - tracker now has {len(tracker.events)} events."
         )
@@ -1305,7 +1306,7 @@ class MessageProcessor:
             self._log_slots(tracker)
 
         await self.execute_side_effects(events, tracker, output_channel)
-
+        plugin_manager().hook.after_action_executed(tracker=tracker)
         return self.should_predict_another_action(action.name())
 
     def _log_action_on_tracker(
@@ -1441,8 +1442,10 @@ class MessageProcessor:
         return len(filtered_commands) > 0
 
     def _is_calm_assistant(self) -> bool:
-        """Inspects the nodes of the graph schema to determine whether
-        any node is associated with the `FlowPolicy`, which is indicative of a
+        """Inspects the nodes of the graph schema to decide if we are in CALM.
+
+        To determine whether we are in CALM mode, we check if any node is
+        associated with the `FlowPolicy`, which is indicative of a
         CALM assistant setup.
 
         Returns:

{rasa_pro-3.11.3a1.dev6 → rasa_pro-3.11.3a1.dev7}/rasa/dialogue_understanding/generator/command_generator.py

@@ -27,6 +27,8 @@ from rasa.shared.nlu.constants import (
     KEY_USER_PROMPT,
     KEY_SYSTEM_PROMPT,
     KEY_LLM_RESPONSE_METADATA,
+    KEY_PROMPT_NAME,
+    KEY_COMPONENT_NAME,
 )
 from rasa.shared.nlu.training_data.message import Message
 from rasa.shared.providers.llm.llm_response import LLMResponse
@@ -408,67 +410,49 @@ class CommandGenerator:
         Prompt is only added in case the flag 'record_commands_and_prompts' is set.
         Example of prompts in the message parse data:
             Message(data={
-              PROMPTS: {
-                "MultiStepLLMCommandGenerator": [
-                    (
-                        "fill_slots_prompt",
-                        {
-                            "user_prompt": <prompt content>",
-                            "system_prompt": <prompt content>",
-                            "llm_response_metadata": <metadata dict from LLMResponse>
-                        }
-                    ),
-                    (
-                        "handle_flows_prompt",
-                        {
-                            "user_prompt": <prompt content>",
-                            "system_prompt": <prompt content>",
-                            "llm_response_metadata": <metadata dict from LLMResponse>
-                        }
-                    ),
-                ],
-                "SingleStepLLMCommandGenerator": [
-                    (
-                        "prompt_template",
-                        {
-                            "user_prompt": <prompt content>",
-                            "system_prompt": <prompt content>",
-                            "llm_response_metadata": <metadata dict from LLMResponse>
-                        }
-                    ),
+              PROMPTS: [
+                  {
+                    "component_name": "MultiStepLLMCommandGenerator",
+                    "prompt_name": "fill_slots_prompt",
+                    "user_prompt": "...",
+                    "system_prompt": "...",
+                    "llm_response_metadata": { ... }
+                  },
+                  {
+                    "component_name": "MultiStepLLMCommandGenerator",
+                    "prompt_name": "handle_flows_prompt",
+                    "user_prompt": "...",
+                    "system_prompt": "...",
+                    "llm_response_metadata": { ... }
+                  },
+                  {
+                    "component_name": "SingleStepLLMCommandGenerator",
+                    "prompt_name": "prompt_template",
+                    "user_prompt": "...",
+                    "system_prompt": "...",
+                    "llm_response_metadata": { ... }
+                  }
                 ]
-              }
             })
         """
         from rasa.dialogue_understanding.utils import record_commands_and_prompts
 
-        # only set prompt if the flag "record_commands_and_prompts" is set to True
+        # Only set prompt if the flag "record_commands_and_prompts" is set to True.
         if not record_commands_and_prompts:
             return
 
+        # Construct the dictionary with prompt details.
         prompt_data: Dict[Text, Any] = {
+            KEY_COMPONENT_NAME: component_name,
+            KEY_PROMPT_NAME: prompt_name,
             KEY_USER_PROMPT: user_prompt,
+            KEY_LLM_RESPONSE_METADATA: llm_response.to_dict() if llm_response else None,
             **({KEY_SYSTEM_PROMPT: system_prompt} if system_prompt else {}),
         }
 
-        if llm_response is not None:
-            prompt_data[KEY_LLM_RESPONSE_METADATA] = llm_response.to_dict()
-        else:
-            prompt_data[KEY_LLM_RESPONSE_METADATA] = None
-
-        prompt_tuple = (prompt_name, prompt_data)
+        # Get or create a top-level "prompts" list.
+        prompts = message.get(PROMPTS) or []
+        prompts.append(prompt_data)
 
-        if message.get(PROMPTS) is not None:
-            prompts = message.get(PROMPTS)
-            if component_name in prompts:
-                prompts[component_name].append(prompt_tuple)
-            else:
-                prompts[component_name] = [prompt_tuple]
-        else:
-            prompts = {component_name: [prompt_tuple]}
-
-        message.set(
-            PROMPTS,
-            prompts,
-            add_to_output=True,
-        )
+        # Update the message with the new prompts list.
+        message.set(PROMPTS, prompts, add_to_output=True)