rasa-pro 3.14.0.dev20250901__py3-none-any.whl → 3.14.0rc1__py3-none-any.whl

rasa/builder/copilot/copilot.py

@@ -1,4 +1,5 @@
 import asyncio
+import copy
 import importlib
 import json
 from contextlib import asynccontextmanager
@@ -10,7 +11,9 @@ from jinja2 import Template
 from typing_extensions import AsyncGenerator
 
 from rasa.builder import config
+from rasa.builder.config import COPILOT_DOCUMENTATION_SEARCH_QUERY_HISTORY_MESSAGES
 from rasa.builder.copilot.constants import (
+    COPILOT_LAST_USER_MESSAGE_CONTEXT_PROMPT_FILE,
     COPILOT_PROMPTS_DIR,
     COPILOT_PROMPTS_FILE,
     ROLE_COPILOT,
@@ -20,8 +23,11 @@ from rasa.builder.copilot.constants import (
 )
 from rasa.builder.copilot.exceptions import CopilotStreamError
 from rasa.builder.copilot.models import (
+    CopilotChatMessage,
     CopilotContext,
+    CopilotGenerationContext,
     ResponseCategory,
+    TextContent,
     UsageStatistics,
 )
 from rasa.builder.document_retrieval.inkeep_document_retrieval import (
@@ -48,6 +54,12 @@ class Copilot:
                 COPILOT_PROMPTS_FILE,
             )
         )
+        self._last_user_message_context_prompt_template = Template(
+            importlib.resources.read_text(
+                f"{PACKAGE_NAME}.{COPILOT_PROMPTS_DIR}",
+                COPILOT_LAST_USER_MESSAGE_CONTEXT_PROMPT_FILE,
+            )
+        )
 
         # The final stream chunk includes usage statistics.
         self.usage_statistics = UsageStatistics()
@@ -55,29 +67,7 @@ class Copilot:
     @asynccontextmanager
     async def _get_client(self) -> AsyncGenerator[openai.AsyncOpenAI, None]:
         """Create a fresh OpenAI client, yield it, and always close it."""
-        kwargs: Dict[str, Any] = {"timeout": config.OPENAI_TIMEOUT}
-        if config.HELLO_LLM_PROXY_BASE_URL:
-            structlogger.debug(
-                "copilot.using_llm_proxy", base_url=config.HELLO_LLM_PROXY_BASE_URL
-            )
-            if not config.RASA_PRO_LICENSE:
-                structlogger.error(
-                    "copilot.proxy_missing_license",
-                    event_info=(
-                        "HELLO_LLM_PROXY_BASE_URL is set "
-                        "but RASA_PRO_LICENSE is missing."
-                    ),
-                )
-                raise CopilotStreamError(
-                    "HELLO_LLM_PROXY_BASE_URL is set but RASA_PRO_LICENSE is missing. "
-                    "Provide a valid license token for proxy authentication."
-                )
-
-            kwargs["base_url"] = config.HELLO_LLM_PROXY_BASE_URL
-            kwargs["api_key"] = config.RASA_PRO_LICENSE
-
-        client = openai.AsyncOpenAI(**kwargs)
-
+        client = openai.AsyncOpenAI(timeout=config.OPENAI_TIMEOUT)
         try:
             yield client
         except Exception as e:
@@ -124,7 +114,7 @@ class Copilot:
     async def generate_response(
         self,
         context: CopilotContext,
-    ) -> tuple[AsyncGenerator[str, None], list[Document], str]:
+    ) -> tuple[AsyncGenerator[str, None], CopilotGenerationContext]:
         """Generate a response from the copilot.
 
         This method performs document retrieval and response generation as a single
@@ -136,22 +126,27 @@ class Copilot:
             context: The context of the copilot.
 
         Returns:
-            A tuple containing the async response stream, relevant documents used
-            as supporting evidence for the generated response, and the prompt used.
+            A tuple containing the async response stream and a
+            CopilotGenerationContext object with relevant documents, and all the
+            messages used to generate the response.
 
         Raises:
             CopilotStreamError: If the stream fails.
             Exception: If an unexpected error occurs.
         """
         relevant_documents = await self.search_rasa_documentation(context)
-        system_message = await self._create_system_message(context, relevant_documents)
-        chat_history = self._create_chat_history_messages(context)
-        messages = [system_message, *chat_history]
+        messages = await self._build_messages(context, relevant_documents)
+
+        support_evidence = CopilotGenerationContext(
+            relevant_documents=relevant_documents,
+            system_message=messages[0],
+            chat_history=messages[1:-1],
+            last_user_message=messages[-1],
+        )
 
         return (
             self._stream_response(messages),
-            relevant_documents,
-            system_message.get("content", ""),
+            support_evidence,
         )
 
     async def _stream_response(
@@ -196,60 +191,139 @@ class Copilot:
             )
             raise
 
-    async def _create_system_message(
+    async def _build_messages(
         self,
         context: CopilotContext,
         relevant_documents: List[Document],
-    ) -> Dict[str, Any]:
-        """Render the correct Jinja template based on desired output_type."""
-        # Format relevant documentation
-        documents = [doc.model_dump() for doc in relevant_documents]
-
-        # Format conversation history
-        conversation = self._format_conversation_history(context.tracker_context)
+    ) -> List[Dict[str, Any]]:
+        """Build the complete message list for the OpenAI API.
 
-        # Format current state
-        current_state = self._format_current_state(context.tracker_context)
+        Args:
+            context: The context of the copilot.
+            relevant_documents: The relevant documents to use in the context.
 
-        # Render template
-        rendered_prompt = self._system_message_prompt_template.render(
-            current_conversation=conversation,
-            current_state=current_state,
-            assistant_logs=context.assistant_logs,
-            assistant_files=context.assistant_files,
-            documentation_results=documents,
+        Returns:
+            A list of messages in OpenAI format.
+        """
+        # Split chat history into past messages and latest message
+        past_messages = [
+            message
+            for message in context.copilot_chat_history[:-1]
+            if message.response_category != ResponseCategory.GUARDRAILS_POLICY_VIOLATION
+        ]
+        latest_message = context.copilot_chat_history[-1]
+
+        # Create the system message
+        system_message = await self._create_system_message()
+        # Create the chat history messages (excludes the last message)
+        chat_history = self._create_chat_history_messages(past_messages)
+        # Create the last message and add the context to it
+        latest_message_with_context = self._create_last_user_message_with_context(
+            latest_message, context, relevant_documents
         )
+        return [system_message, *chat_history, latest_message_with_context]
+
+    async def _create_system_message(self) -> Dict[str, Any]:
+        """Render the correct Jinja template based on desired output_type."""
+        rendered_prompt = self._system_message_prompt_template.render()
         return {"role": ROLE_SYSTEM, "content": rendered_prompt}
 
     def _create_chat_history_messages(
         self,
-        context: CopilotContext,
+        past_messages: List["CopilotChatMessage"],
     ) -> List[Dict[str, Any]]:
         """Create the chat history messages for the copilot.
 
         Filter out messages with response_category of GUARDRAILS_POLICY_VIOLATION.
         This will filter out all the user messages that were flagged by guardrails, but
         also the copilot messages that were produced by guardrails.
+
+        Args:
+            past_messages: List of past messages (excluding the latest message).
+
+        Returns:
+            List of messages in OpenAI format.
         """
-        # Filter out messages with response_category of GUARDRAILS_POLICY_VIOLATION.
-        # This will filter out all the user messages flagged by guardrails, but also the
-        # copilot messages that were produced.
         return [
             message.to_openai_format()
-            for message in context.copilot_chat_history
+            for message in past_messages
             if message.response_category != ResponseCategory.GUARDRAILS_POLICY_VIOLATION
         ]
 
+    def _create_last_user_message_with_context(
+        self,
+        latest_message: "CopilotChatMessage",
+        context: CopilotContext,
+        relevant_documents: List[Document],
+    ) -> Dict[str, Any]:
+        """Create the last user message with context.
+
+        The last user message is the last message in the copilot chat history.
+        We add the context prompt with the current conversation, state, assistant logs,
+        assistant files, and relevant documents as a text content block to the beginning
+        of the message.
+
+        Args:
+            context: The context of the copilot.
+            relevant_documents: The relevant documents to use in the context.
+
+        Returns:
+            The last user message with context in the OpenAI format.
+        """
+        last_user_message = copy.deepcopy(latest_message)
+        context_prompt = self._render_last_user_message_context_prompt(
+            context, relevant_documents
+        )
+        last_user_message.content.insert(
+            0, TextContent(type="text", text=context_prompt)
+        )
+        return {
+            "role": ROLE_USER,
+            "content": [
+                {"type": "text", "text": content.text}
+                for content in last_user_message.content
+                if isinstance(content, TextContent)
+            ],
+        }
+
+    def _render_last_user_message_context_prompt(
+        self,
+        context: CopilotContext,
+        relevant_documents: List[Document],
+    ) -> str:
+        # Format relevant documentation
+        documents = [doc.model_dump() for doc in relevant_documents]
+        # Format conversation history
+        conversation = self._format_conversation_history(context.tracker_context)
+        # Format current state
+        current_state = self._format_current_state(context.tracker_context)
+
+        rendered_prompt = self._last_user_message_context_prompt_template.render(
+            current_conversation=conversation,
+            current_state=current_state,
+            assistant_logs=context.assistant_logs,
+            assistant_files=context.assistant_files,
+            documentation_results=documents,
+        )
+        return rendered_prompt
+
     @staticmethod
     def _create_documentation_search_query(context: CopilotContext) -> str:
         """Format chat messages between user and copilot for documentation search."""
+
         result = ""
         role_to_prefix = {
             ROLE_USER: "User",
             ROLE_COPILOT: "Assistant",
             ROLE_COPILOT_INTERNAL: "Copilot Internal Request",
         }
-        for message in context.copilot_chat_history:
+
+        # Only use the last N messages for documentation search
+        messages_to_include = context.copilot_chat_history[
+            -COPILOT_DOCUMENTATION_SEARCH_QUERY_HISTORY_MESSAGES:
+        ]
+
+        for message in messages_to_include:
             prefix = role_to_prefix[message.role]
             text = message.get_text_content().strip()
             if text:

rasa/builder/copilot/models.py

@@ -1,4 +1,3 @@
-import json
 from abc import ABC, abstractmethod
 from enum import Enum
 from typing import Any, Dict, List, Literal, Optional, Union
@@ -14,6 +13,7 @@ from rasa.builder.copilot.constants import (
     ROLE_COPILOT_INTERNAL,
     ROLE_USER,
 )
+from rasa.builder.document_retrieval.models import Document
 from rasa.builder.models import ServerSentEvent
 from rasa.builder.shared.tracker_context import TrackerContext
 
@@ -231,8 +231,11 @@ class CopilotChatMessage(BaseModel):
 
     def _copilot_message_to_openai_format(self) -> Dict[str, Any]:
         role = self._map_role_to_openai()
-        content_blocks = [block.model_dump() for block in self.content]
-        content = json.dumps(content_blocks)
+        # For now the Copilot responds only with the text content and all the content
+        # is formatted as a markdown.
+        # TODO: Once we start predicting the files, and expecting other content blocks
+        #       we should update this.
+        content = self.get_text_content()
         return {"role": role, "content": content}
 
     def _map_role_to_openai(self) -> str:
@@ -462,3 +465,36 @@ class SigningContext(BaseModel):
         """Signing is enabled if a non-empty secret is present."""
         secret = (self.secret or "").strip()
         return bool(secret)
+
+
+class CopilotGenerationContext(BaseModel):
+    """Container for copilot generation context and supporting evidence.
+
+    This class organizes the context and supporting evidence information used by the
+    copilot's generate_response method, providing a cleaner interface than returning
+    a tuple for the non-streaming data.
+    """
+
+    relevant_documents: List["Document"] = Field(
+        ...,
+        description=(
+            "The relevant documents used as supporting evidence for the respons."
+        ),
+    )
+    system_message: Dict[str, Any] = Field(
+        ..., description="The system message with instructions."
+    )
+    chat_history: List[Dict[str, Any]] = Field(
+        ...,
+        description=(
+            "The chat history messages (excluding the last message) used as a context."
+        ),
+    )
+    last_user_message: Optional[Dict[str, Any]] = Field(
+        None, description="The last user message with context that was processed."
+    )
+
+    class Config:
+        """Config for CopilotGenerationContext."""
+
+        arbitrary_types_allowed = True