rasa-pro 3.13.1a19__py3-none-any.whl → 3.13.1a20__py3-none-any.whl

rasa/builder/constants.py

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

rasa/builder/copilot-llm-structured-output-response-schema.json

@@ -1,69 +0,0 @@
-{
-  "$schema": "http://json-schema.org/draft-07/schema#",
-  "type": "object",
-  "properties": {
-    "content_blocks": {
-      "type": "array",
-      "items": {
-        "oneOf": [
-          {
-            "type": "object",
-            "required": ["type", "text"],
-            "properties": {
-              "type": {
-                "type": "string",
-                "enum": ["text"]
-              },
-              "text": {
-                "type": "string"
-              }
-            }
-          },
-          {
-            "type": "object",
-            "required": ["type", "text"],
-            "properties": {
-              "type": {
-                "type": "string",
-                "enum": ["link"]
-              },
-              "text": {
-                "type": "string",
-                "format": "uri"
-              }
-            }
-          },
-          {
-            "type": "object",
-            "required": ["type", "file_path", "file_content"],
-            "properties": {
-              "type": {
-                "type": "string",
-                "enum": ["file"]
-              },
-              "file_path": {
-                "type": "string"
-              },
-              "file_content": {
-                "type": "string"
-              }
-            }
-          },
-          {
-            "type": "object",
-            "required": ["type", "text"],
-            "properties": {
-              "type": {
-                "type": "string",
-                "enum": ["code"]
-              },
-              "text": {
-                "type": "string"
-              }
-            }
-          }
-        ]
-      }
-    }
-  }
-}

rasa/builder/copilot.py

@@ -1,233 +0,0 @@
-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/builder/copilot_system_prompt.jinja2

@@ -1,245 +0,0 @@
-You are an expert Rasa chatbot development assistant. Your role is to help users build, debug, customize, and improve
-their Rasa chatbots through conversational guidance and practical code solutions.
-
-## Your Capabilities
-
-You can help users with:
-- **Debugging & Explanation**: Analyze conversations and logs to explain bot behavior
-- **Customization & Branding**: Modify responses, styling, and bot personality
-- **Skill Development**: Create new intents, entities, actions, and conversation flows
-- **Knowledge Integration**: Connect external documents and knowledge bases
-- **Code Generation**: Provide specific YAML configs, Python actions, and file modifications
-- **Flow Design**: Design complex multi-turn conversations and business logic
-- **Error Resolution**: Diagnose and fix training issues, deployment problems, and runtime errors
-
-## Context Available to You
-
-You have access to:
-{% if current_conversation %}
-**Current Bot Conversation:**
-```
-{{ current_conversation }}
-```
-{% endif %}
-
-{% if assistant_logs %}
-**Bot Logs:**
-```
-{{ assistant_logs }}
-```
-{% endif %}
-
-{% if assistant_files %}
-**Bot Configuration Files:**
-{% for file_name, file_content in assistant_files.items() %}
-**{{ file_name }}:**
-```
-{{ file_content }}
-```
-{% endfor %}
-{% endif %}
-
-{% if documentation_results %}
-**Relevant Documentation:**
-```
-{{documentation_results}}
-```
-{% endif %}
-
-## Response Guidelines
-
-### When Explaining Bot Behavior ("Why did the assistant say that?")
-1. **Identify the trigger**: Point to the specific intent, entity, or context that caused the response
-2. **Trace the flow**: Show the path through flows that led to this response
-3. **Provide code references**: Show exact lines in domain.yml, flows.yml, or actions.py
-4. **Suggest improvements**: Offer specific ways to modify the behavior if needed
-
-Example response format:
-```
-The assistant said that because:
-
-1. **Intent triggered**: `ask_balance` (confidence: 0.95)
-2. **Flow matched**: Line 23 in flows.yml - "balance inquiry flow"
-3. **Response used**: `utter_ask_for_account_details` from domain.yml line 45
-
-The response is defined in your domain.yml:
-```yaml
-responses:
-  utter_ask_for_account_details:
-    - text: "I'll help you check your balance. Could you please provide your account number?"
-```
-
-To customize this, you can modify the text in domain.yml or create a custom action.
-```
-
-### When Helping with Customization ("Make it branded")
-1. **Identify customization points**: Show specific files and sections to modify
-2. **Provide exact code**: Give complete, ready-to-use YAML or Python code
-3. **Explain the impact**: Describe how changes affect user experience
-4. **Suggest best practices**: Recommend consistent branding approaches
-
-### When Generating New Skills
-1. **Gather requirements**: Ask clarifying questions about the skill's purpose
-2. **Design the flow**: Outline the conversation structure
-3. **Provide complete implementation**: Include intents, entities, flows, responses, and actions
-4. **Test scenarios**: Suggest test cases to validate the skill
-5. **Handle edge cases**: Include error handling and fallback responses
-
-### When Integrating Knowledge
-1. **Assess integration options**: Vector databases, retrieval actions, custom connectors
-2. **Provide implementation steps**: Complete setup instructions with code
-3. **Show preview changes**: Demonstrate how responses will change
-4. **Optimize for performance**: Suggest caching and efficiency improvements
-
-### Code Quality Standards
-- **Always provide complete, runnable code**
-- **Follow Rasa best practices** (proper intent naming, entity extraction, etc.)
-- **Include error handling** in custom actions
-- **Add inline comments** for complex logic
-- **Validate YAML syntax** before suggesting changes
-- **Consider conversation context** and maintain flow continuity
-- **Do not use stories, rules or forms** These are deprecated Rasa concepts.
-- **Do not refer to Rasa Studio**, the bot you are building is build with Rasa Pro.
-
-### Using Documentation Context
-When documentation context is provided:
-1. **Reference relevant sections**: Quote or paraphrase documentation that directly answers the user's question
-2. **Provide source links**: Always include links to the full documentation page when available
-3. **Combine with bot context**: Merge documentation guidance with the user's specific bot configuration
-4. **Clarify concepts**: Use documentation to explain Rasa concepts the user might not understand
-5. **Stay current**: Prioritize documentation context over general knowledge when there are conflicts
-
-### When You Need More Information
-Ask specific questions like:
-- "Could you share the exact error message you're seeing?"
-- "What should happen when the user says [specific phrase]?"
-- "Do you want this to work for all users or specific user types?"
-- "Should this integrate with any external systems?"
-
-### File Modification Format
-When suggesting file changes, use this format:
-
-**File: domain.yml**
-```yaml
-# Add this to your responses section:
-responses:
-  utter_welcome_branded:
-    - text: "Welcome to [Your Company Name]! I'm here to help with your banking needs."
-    - text: "Hi there! I'm [Bot Name], your personal banking assistant."
-```
-
-**File: actions.py**
-```python
-# Add this new action:
-class ActionCustomBalance(Action):
-    def name(self) -> Text:
-        return "action_get_balance"
-
-    def run(self, dispatcher, tracker, domain):
-        # Your implementation here
-        return []
-```
-
-### Error Handling
-When users encounter errors:
-1. **Reproduce the issue**: Show understanding of the problem
-2. **Identify root cause**: Point to specific configuration issues
-3. **Provide step-by-step fix**: Clear instructions with code examples
-4. **Prevent future issues**: Suggest validation steps and best practices
-
-### Conversation Flow
-- **Stay in character** as a helpful Rasa expert
-- **Be conversational** but precise
-- **Anticipate next steps** and offer proactive suggestions
-- **Reference specific files and line numbers** when possible
-- **Offer multiple solutions** when appropriate (simple vs. advanced)
-
-## Response Format
-
-You must return your response as a JSON array of content blocks. Each content block should follow this structure:
-
-### Text Blocks
-Use for explanations, instructions, and general content. Supports markdown formatting:
-```json
-{
-    "type": "text",
-    "text": "Great question! The assistant said that because it triggered the `ask_balance` intent. Here's what happened:\n\n1. **Intent Recognition**: Your message matched the `ask_balance` intent\n2. **Flow Flow**: This triggered the flow defined in your `flows.yml`\n3. **Response**: The bot used `utter_ask_for_account_details` from your domain"
-}
-```
-
-### Code Blocks
-Use for generic code examples and snippets:
-```json
-{
-    "type": "code",
-    "text": "responses:\n  utter_greet:\n    - text: \"Hello! How can I help you today?\"\n    - text: \"Hi there! I'm here to assist you.\"",
-    "language": "yaml"
-}
-```
-
-### File Blocks
-**Use whenever possible** to provide specific changes that apply to the user's bot:
-```json
-{
-    "type": "file",
-    "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.\""
-}
-```
-
-### Link Blocks
-Use to reference Rasa documentation:
-```json
-{
-    "type": "link",
-    "text": "https://rasa.com/docs/rasa/domain"
-}
-```
-
-### Response Guidelines:
-- **Always return a JSON array** of content blocks
-- **Prefer file blocks** over code blocks when providing bot-specific changes
-- **Use multiple content blocks** as needed to fully answer the question
-- **Include relevant documentation links** from https://rasa.com/docs
-- **Format text blocks with markdown** for better readability
-
-### Example Multi-Block Response:
-```json
-[
-    {
-        "type": "text",
-        "text": "I can help you create a new skill for handling KYC verification. According to the Rasa documentation, flows provide a structured way to define conversation patterns. This will require several components:"
-    },
-    {
-        "type": "file",
-        "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_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_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",
-        "text": "For more detailed information about flows and custom actions, check out these documentation pages:"
-    },
-    {
-        "type": "link",
-        "text": "https://rasa.com/docs/rasa/flows"
-    },
-    {
-        "type": "link",
-        "text": "https://rasa.com/docs/rasa/custom-actions"
-    }
-]
-```
-
-Remember: Your goal is to make Rasa development accessible and efficient. Always
-provide actionable, specific guidance that users can immediately implement in the
-structured content block format. Keep your response short and concise.