rasa-pro 3.13.1a18__tar.gz → 3.13.1a19__tar.gz

{rasa_pro-3.13.1a18 → rasa_pro-3.13.1a19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: rasa-pro
-Version: 3.13.1a18
+Version: 3.13.1a19
 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.13.1a18 → rasa_pro-3.13.1a19}/pyproject.toml

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

rasa_pro-3.13.1a19/rasa/builder/constants.py

@@ -0,0 +1,4 @@
+ROLE_SYSTEM = "system"
+ROLE_USER = "user"
+ROLE_ASSISTANT = "assistant"
+ROLE_RASA_COPILOT = "copilot"

rasa_pro-3.13.1a18/rasa/builder/llm-helper-schema.json → rasa_pro-3.13.1a19/rasa/builder/copilot-llm-structured-output-response-schema.json

@@ -35,16 +35,16 @@
           },
           {
             "type": "object",
-            "required": ["type", "file", "content"],
+            "required": ["type", "file_path", "file_content"],
             "properties": {
               "type": {
                 "type": "string",
                 "enum": ["file"]
               },
-              "file": {
+              "file_path": {
                 "type": "string"
               },
-              "content": {
+              "file_content": {
                 "type": "string"
               }
             }

rasa_pro-3.13.1a19/rasa/builder/copilot.py

@@ -0,0 +1,233 @@
+import asyncio
+import importlib
+import json
+from contextlib import asynccontextmanager
+from typing import Any, Dict, List
+
+import importlib_resources
+import openai
+import structlog
+from jinja2 import Template
+from pydantic import ValidationError
+from typing_extensions import AsyncGenerator
+
+from rasa.builder import config
+from rasa.builder.constants import ROLE_SYSTEM, ROLE_USER
+from rasa.builder.exceptions import DocumentRetrievalError, LLMGenerationError
+from rasa.builder.inkeep_document_retrieval import InKeepDocumentRetrieval
+from rasa.builder.llm_context import tracker_as_llm_context
+from rasa.builder.models import CopilotChatMessage, CopilotContext, Document
+from rasa.shared.constants import PACKAGE_NAME
+from rasa.shared.utils.io import read_json_file
+
+COPILOT_LLM_STRUCTURED_OUTPUT_SCHEMA_PATH = str(
+    importlib_resources.files(PACKAGE_NAME).joinpath(
+        "builder/copilot-llm-structured-output-response-schema.json"
+    )
+)
+
+structlogger = structlog.get_logger()
+
+
+class Copilot:
+    def __init__(self):
+        self._client = None
+        self._copilot_response_schema = read_json_file(
+            COPILOT_LLM_STRUCTURED_OUTPUT_SCHEMA_PATH
+        )
+        self._inkeep_document_retrieval = InKeepDocumentRetrieval()
+        self._system_message_prompt_template = Template(
+            importlib.resources.read_text(
+                "rasa.builder",
+                "copilot_system_prompt.jinja2",
+            )
+        )
+
+    @asynccontextmanager
+    async def _get_client(self) -> AsyncGenerator[openai.AsyncOpenAI, None]:
+        """Get or lazy create OpenAI client with proper resource management."""
+        if self._client is None:
+            self._client = openai.AsyncOpenAI(timeout=config.OPENAI_TIMEOUT)
+
+        try:
+            yield self._client
+        except Exception as e:
+            structlogger.error("copilot.llm_client_error", error=str(e))
+            raise
+
+    async def generate_response(self, context: CopilotContext) -> CopilotChatMessage:
+        """Generate copilot response using OpenAI."""
+        try:
+            async with self._get_client() as client:
+                response_format = {
+                    "type": "json_schema",
+                    "json_schema": {
+                        "name": "copilot_response",
+                        "schema": self._copilot_response_schema,
+                    },
+                }  # type: ignore[arg-type]
+                messages = await self._create_llm_request_messages(context)
+
+                response = await client.chat.completions.create(
+                    model=config.OPENAI_MODEL,
+                    messages=messages,
+                    response_format=response_format,
+                )
+
+                content = response.choices[0].message.content
+                if not content:
+                    structlogger.error(
+                        "copilot.generate_response.empty_llm_response",
+                        event_info="Copilot: Empty response from LLM",
+                        messages=messages,
+                        response=response,
+                    )
+                    raise LLMGenerationError("Copilot: Empty response from LLM")
+
+                try:
+                    # Parse the JSON response and create a CopilotChatMessage
+                    llm_response = json.loads(content)
+                    structlogger.debug(
+                        "copilot.generate_response.llm_response",
+                        event_info="Copilot: LLM response",
+                        llm_response=llm_response,
+                    )
+                    return CopilotChatMessage.from_llm_response(llm_response)
+                except (json.JSONDecodeError, ValidationError) as e:
+                    structlogger.error(
+                        "copilot.generate_response.llm_response_invalid_json_format",
+                        content=content,
+                        event_info=f"Copilot: Invalid JSON from LLM: {e}",
+                        error=str(e),
+                    )
+                    raise LLMGenerationError(f"Copilot: Invalid JSON from LLM: {e}")
+
+        except openai.OpenAIError as e:
+            structlogger.error(
+                "copilot.generate_response.openai_api_error",
+                event_info="Copilot: OpenAI API error",
+                messages=messages,
+                error=str(e),
+            )
+            raise LLMGenerationError(f"Copilot: OpenAI API error: {e}")
+        except asyncio.TimeoutError:
+            structlogger.error(
+                "copilot.generate_response.llm_request_timeout",
+                event_info="Copilot: LLM request timed out.",
+                messages=messages,
+            )
+            raise LLMGenerationError("Copilot: LLM request timed out.")
+
+    async def _create_llm_request_messages(
+        self, context: CopilotContext
+    ) -> List[Dict[str, Any]]:
+        """Constructs the full list of messages to send to the LLM.
+
+        This includes:
+        - System instructions that utilizes logs, relevant documentation bits, and
+          the current tracker state of the Rasa assistant to generate a response.
+        - Chat history between the user and the copilot.
+
+        Args:
+            context: Context object containing chat history, current tracker
+                state, logs, and file references.
+
+        Returns:
+            A full list of messages to pass to the LLM (system + chronological message
+            history).
+        """
+        system_message = await self._create_system_message(context)
+        chat_history_messages = self._create_chat_history_messages(context)
+        return [system_message, *chat_history_messages]
+
+    async def _create_system_message(
+        self,
+        context: CopilotContext,
+    ) -> Dict[str, Any]:
+        """Create the system message with the instructions and context for the copilot.
+
+        Args:
+            context: The context of the copilot.
+
+        Returns:
+            The system message for the copilot.
+        """
+        # Retrieve relevant documents from Rasa documentation and format them
+        documentation_results = await self._search_rasa_documentation(context)
+        formatted_docs = self._format_documents(documentation_results)
+
+        # Format the current conversation between the user and the Rasa assistant
+        current_conversation_with_assistant = tracker_as_llm_context(context.tracker)
+
+        # Render the system message prompt template
+        rendered_prompt = self._system_message_prompt_template.render(
+            current_conversation=current_conversation_with_assistant,
+            assistant_logs=context.assistant_logs,
+            assistant_files=context.assistant_files,
+            documentation_results=formatted_docs,
+        )
+        return {"role": ROLE_SYSTEM, "content": rendered_prompt}
+
+    def _create_chat_history_messages(
+        self,
+        context: CopilotContext,
+    ) -> List[Dict[str, Any]]:
+        """Create the chat history messages for the copilot."""
+        return [message.to_openai_format() for message in context.copilot_chat_history]
+
+    async def _search_rasa_documentation(
+        self,
+        context: CopilotContext,
+    ) -> List[Document]:
+        """Search Rasa documentation for relevant information.
+
+        Args:
+            context: The context of the copilot.
+
+        Returns:
+            A list of Document objects. Empty list is returned if the search fails.
+        """
+        try:
+            query = self._create_documentation_search_query(context)
+            return await self._inkeep_document_retrieval.retrieve_documents(query)
+        except DocumentRetrievalError as e:
+            structlogger.error(
+                "copilot.search_rasa_documentation.error",
+                event_info=(
+                    f"Copilot: Searching Rasa documentation for query '{query}' "
+                    f"failed with the following error: {e}. Returning empty list."
+                ),
+                query=query,
+                error=str(e),
+            )
+            return []
+
+    @staticmethod
+    def _create_documentation_search_query(context: CopilotContext) -> str:
+        """Format chat messages between user and copilot for documentation search."""
+        result = ""
+        user_prefix = "User"
+        assistant_prefix = "Assistant"
+        for message in context.copilot_chat_history:
+            text = message.get_text_content().strip()
+            if not text:
+                continue
+            if message.role == ROLE_USER:
+                result += f"{user_prefix}: {text}\n"
+            else:
+                result += f"{assistant_prefix}: {text}\n"
+        return result
+
+    @staticmethod
+    def _format_documents(results: List[Document]) -> str:
+        """Format documentation search results."""
+        if not results:
+            return "<sources>No relevant documentation found.</sources>"
+
+        formatted_results = ""
+        for result in results:
+            formatted_result = f"<result url='{result.url}'>"
+            formatted_result += f"<content>{result.content}</content>"
+            formatted_results += formatted_result + "</result>"
+
+        return f"<sources>{formatted_results}</sources>"

rasa_pro-3.13.1a18/rasa/builder/llm_helper_prompt.jinja2 → rasa_pro-3.13.1a19/rasa/builder/copilot_system_prompt.jinja2

@@ -22,16 +22,16 @@ You have access to:
 ```
 {% endif %}
 
-{% if bot_logs %}
+{% if assistant_logs %}
 **Bot Logs:**
 ```
-{{ bot_logs }}
+{{ assistant_logs }}
 ```
 {% endif %}
 
-{% if chat_bot_files %}
+{% if assistant_files %}
 **Bot Configuration Files:**
-{% for file_name, file_content in chat_bot_files.items() %}
+{% for file_name, file_content in assistant_files.items() %}
 **{{ file_name }}:**
 ```
 {{ file_content }}
@@ -182,8 +182,8 @@ Use for generic code examples and snippets:
 ```json
 {
     "type": "file",
-    "file": "domain.yml",
-    "content": "responses:\n  utter_welcome_branded:\n    - text: \"Welcome to [Your Company Name]! I'm here to help.\"\n    - text: \"Hi! I'm [Bot Name], your personal assistant.\""
+    "file_path": "domain.yml",
+    "file_content": "responses:\n  utter_welcome_branded:\n    - text: \"Welcome to [Your Company Name]! I'm here to help.\"\n    - text: \"Hi! I'm [Bot Name], your personal assistant.\""
 }
 ```
 
@@ -212,18 +212,18 @@ Use to reference Rasa documentation:
     },
     {
         "type": "file",
-        "file": "domain.yml",
-        "content": "intents:\n  - request_kyc\n  - provide_document\n\nentities:\n  - document_type\n\nresponses:\n  utter_request_documents:\n    - text: \"To verify your identity, please provide a government-issued ID.\""
+        "file_path": "domain.yml",
+        "file_content": "intents:\n  - request_kyc\n  - provide_document\n\nentities:\n  - document_type\n\nresponses:\n  utter_request_documents:\n    - text: \"To verify your identity, please provide a government-issued ID.\""
     },
     {
         "type": "file",
-        "file": "flows.yml",
-        "content": "flows:\n  kyc_verification:\n    description: Handle KYC document verification\n    start_conditions:\n      - intent: request_kyc\n    steps:\n      - action: utter_request_documents\n      - intent: provide_document\n      - action: action_process_kyc_document"
+        "file_path": "flows.yml",
+        "file_content": "flows:\n  kyc_verification:\n    description: Handle KYC document verification\n    start_conditions:\n      - intent: request_kyc\n    steps:\n      - action: utter_request_documents\n      - intent: provide_document\n      - action: action_process_kyc_document"
     },
     {
         "type": "file",
-        "file": "data/nlu.yml",
-        "content": "- intent: request_kyc\n  examples: |\n    - I need to verify my identity\n    - How do I complete KYC\n    - What documents do you need"
+        "file_path": "data/nlu.yml",
+        "file_content": "- intent: request_kyc\n  examples: |\n    - I need to verify my identity\n    - How do I complete KYC\n    - What documents do you need"
     },
     {
         "type": "text",

{rasa_pro-3.13.1a18 → rasa_pro-3.13.1a19}/rasa/builder/inkeep_document_retrieval.py

@@ -52,15 +52,28 @@ class InKeepDocumentRetrieval:
             List of Document objects containing retrieved content
 
         Raises:
-            LLMGenerationError: If the API call fails or returns invalid response
+            DocumentRetrievalError: When document retrieval fails due to:
+                - Empty response from InKeep AI API
+                - OpenAI API errors (authentication, rate limiting, etc.)
+                - Request timeout
+                - Unexpected errors during API communication
         """
-        response = await self._call_inkeep_rag_api(
-            query=query,
-            temperature=temperature,
-            timeout=timeout,
-        )
-        documents = self._parse_documents_from_response(response)
-        return documents
+        try:
+            response = await self._call_inkeep_rag_api(
+                query=query,
+                temperature=temperature,
+                timeout=timeout,
+            )
+            documents = self._parse_documents_from_response(response)
+            return documents
+        except DocumentRetrievalError as e:
+            structlogger.error(
+                "inkeep_document_retrieval.retrieve_documents.error",
+                event_info="InKeep Document Retrieval: Error",
+                query=query,
+                error=str(e),
+            )
+            raise e
 
     async def _call_inkeep_rag_api(
         self, query: str, temperature: float, timeout: float
@@ -108,7 +121,7 @@ class InKeepDocumentRetrieval:
 
         except openai.OpenAIError as e:
             structlogger.error(
-                "inkeep_document_retrieval.api_error",
+                "inkeep_document_retrieval.call_inkeep_rag_api.api_error",
                 event_info="InKeep Document Retrieval: API error",
                 request_params=request_params,
                 error=e,
@@ -116,7 +129,7 @@ class InKeepDocumentRetrieval:
             raise DocumentRetrievalError(f"InKeep Document Retrieval: API error: {e}")
         except asyncio.TimeoutError as e:
             structlogger.error(
-                "inkeep_document_retrieval.timeout_error",
+                "inkeep_document_retrieval.call_inkeep_rag_api.timeout_error",
                 event_info="InKeep Document Retrieval: Timeout error",
                 request_params=request_params,
                 error=e,
@@ -124,7 +137,7 @@ class InKeepDocumentRetrieval:
             raise DocumentRetrievalError(f"InKeep AI request timed out: {e}")
         except Exception as e:
             structlogger.error(
-                "inkeep_document_retrieval.error",
+                "inkeep_document_retrieval.call_inkeep_rag_api.error",
                 event_info="InKeep Document Retrieval: Error",
                 request_params=request_params,
                 error=e,
@@ -161,7 +174,8 @@ class InKeepDocumentRetrieval:
             response: ChatCompletion response from InKeep AI's RAG model.
 
         Returns:
-            List of Document objects
+            List of Document objects. Empty list is returned if the response is empty
+            or if the response is invalid.
         """
         try:
             content = response.choices[0].message.content
@@ -192,7 +206,8 @@ class InKeepDocumentRetrieval:
 
         except json.JSONDecodeError as e:
             structlogger.warning(
-                "inkeep_document_retrieval.parse_response_failed",
+                "inkeep_document_retrieval.parse_documents_from_response"
+                ".parse_response_failed",
                 event_info=(
                     "InKeep Document Retrieval: Parse response failed. "
                     "Returning empty list.",
@@ -202,7 +217,7 @@ class InKeepDocumentRetrieval:
             return []
         except Exception as e:
             structlogger.error(
-                "inkeep_document_retrieval.parse_response_error",
+                "inkeep_document_retrieval.parse_documents_from_response.error",
                 event_info=(
                     "InKeep Document Retrieval: Parse response error. "
                     "Returning empty list.",

rasa_pro-3.13.1a19/rasa/builder/llm_service.py

@@ -0,0 +1,181 @@
+"""Service for handling LLM interactions."""
+
+import asyncio
+import importlib
+import json
+from contextlib import asynccontextmanager
+from copy import deepcopy
+from typing import Any, AsyncGenerator, Dict, List, Optional
+
+import importlib_resources
+import openai
+import structlog
+from jinja2 import Template
+
+from rasa.builder import config
+from rasa.builder.copilot import Copilot
+from rasa.builder.exceptions import LLMGenerationError
+from rasa.constants import PACKAGE_NAME
+from rasa.shared.constants import DOMAIN_SCHEMA_FILE, RESPONSES_SCHEMA_FILE
+from rasa.shared.core.flows.yaml_flows_io import FLOWS_SCHEMA_FILE
+from rasa.shared.utils.io import read_json_file
+from rasa.shared.utils.yaml import read_schema_file
+
+structlogger = structlog.get_logger()
+
+
+class LLMService:
+    """Handles OpenAI LLM interactions with caching for efficiency."""
+
+    def __init__(self) -> None:
+        self._client: Optional[openai.AsyncOpenAI] = None
+        self._domain_schema: Optional[Dict[str, Any]] = None
+        self._flows_schema: Optional[Dict[str, Any]] = None
+        self._copilot = None
+
+    @property
+    def copilot(self):
+        """Get or lazy create copilot instance."""
+        if self._copilot is None:
+            self._copilot = Copilot()
+
+        try:
+            return self._copilot
+        except Exception as e:
+            structlogger.error(
+                "llm_service.copilot.error",
+                event_info="LLM Service: Error getting copilot instance.",
+                error=str(e),
+            )
+            raise
+
+    @asynccontextmanager
+    async def _get_client(self) -> AsyncGenerator[openai.AsyncOpenAI, None]:
+        """Get or create OpenAI client with proper resource management."""
+        if self._client is None:
+            self._client = openai.AsyncOpenAI(timeout=config.OPENAI_TIMEOUT)
+
+        try:
+            yield self._client
+        except Exception as e:
+            structlogger.error("llm.client_error", error=str(e))
+            raise
+
+    def _prepare_schemas(self) -> None:
+        """Prepare and cache schemas for LLM generation."""
+        if self._domain_schema is None:
+            self._domain_schema = _prepare_domain_schema()
+
+        if self._flows_schema is None:
+            self._flows_schema = _prepare_flows_schema()
+
+    async def generate_rasa_project(
+        self, messages: List[Dict[str, Any]]
+    ) -> Dict[str, Any]:
+        """Generate Rasa project data using OpenAI."""
+        self._prepare_schemas()
+
+        try:
+            async with self._get_client() as client:
+                response_format = {
+                    "type": "json_schema",
+                    "json_schema": {
+                        "name": "rasa_project",
+                        "schema": {
+                            "type": "object",
+                            "properties": {
+                                "domain": self._domain_schema,
+                                "flows": self._flows_schema,
+                            },
+                            "required": ["domain", "flows"],
+                        },
+                    },
+                }
+                response = await client.chat.completions.create(
+                    model=config.OPENAI_MODEL,
+                    messages=messages,
+                    temperature=config.OPENAI_TEMPERATURE,
+                    response_format=response_format,
+                )
+
+                content = response.choices[0].message.content
+                if not content:
+                    raise LLMGenerationError("Empty response from LLM")
+
+                try:
+                    return json.loads(content)
+                except json.JSONDecodeError as e:
+                    raise LLMGenerationError(f"Invalid JSON from LLM: {e}")
+
+        except openai.OpenAIError as e:
+            raise LLMGenerationError(f"OpenAI API error: {e}")
+        except asyncio.TimeoutError:
+            raise LLMGenerationError("LLM request timed out")
+
+
+# Schema preparation functions (stateless)
+def _prepare_domain_schema() -> Dict[str, Any]:
+    """Prepare domain schema by removing unnecessary parts."""
+    domain_schema = deepcopy(read_schema_file(DOMAIN_SCHEMA_FILE, PACKAGE_NAME, False))
+
+    if not isinstance(domain_schema, dict):
+        raise ValueError("Domain schema is not a dictionary")
+
+    # Remove parts not needed for CALM bots
+    unnecessary_keys = ["intents", "entities", "forms", "config", "session_config"]
+
+    for key in unnecessary_keys:
+        domain_schema["mapping"].pop(key, None)
+
+    # Remove problematic slot mappings
+    slot_mapping = domain_schema["mapping"]["slots"]["mapping"]["regex;([A-Za-z]+)"][
+        "mapping"
+    ]
+    slot_mapping.pop("mappings", None)
+    slot_mapping.pop("validation", None)
+
+    # Add responses schema
+    domain_schema["mapping"]["responses"] = read_schema_file(
+        RESPONSES_SCHEMA_FILE, PACKAGE_NAME, False
+    )["schema;responses"]
+
+    return domain_schema
+
+
+def _prepare_flows_schema() -> Dict[str, Any]:
+    """Prepare flows schema by removing nlu_trigger."""
+    schema_file = str(
+        importlib_resources.files(PACKAGE_NAME).joinpath(FLOWS_SCHEMA_FILE)
+    )
+    flows_schema = deepcopy(read_json_file(schema_file))
+    flows_schema["$defs"]["flow"]["properties"].pop("nlu_trigger", None)
+    return flows_schema
+
+
+# Template functions (stateless with caching)
+_skill_template: Optional[Template] = None
+_helper_template: Optional[Template] = None
+
+
+def get_skill_generation_messages(
+    skill_description: str, project_data: Dict[str, str]
+) -> List[Dict[str, Any]]:
+    """Get messages for skill generation."""
+    global _skill_template
+
+    if _skill_template is None:
+        template_content = importlib.resources.read_text(
+            "rasa.builder",
+            "skill_to_bot_prompt.jinja2",
+        )
+        _skill_template = Template(template_content)
+
+    system_prompt = _skill_template.render(
+        skill_description=skill_description,
+        project_data=project_data,
+    )
+    return [{"role": "system", "content": system_prompt}]
+
+
+# Global service instance
+llm_service = LLMService()