rasa-pro 3.13.0rc4__py3-none-any.whl → 3.13.1a3__py3-none-any.whl

rasa/builder/llm_helper_prompt.jinja2

@@ -0,0 +1,245 @@
+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 bot_logs %}
+**Bot Logs:**
+```
+{{ bot_logs }}
+```
+{% endif %}
+
+{% if chat_bot_files %}
+**Bot Configuration Files:**
+{% for file_name, file_content in chat_bot_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": "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.\""
+}
+```
+
+### 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": "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.\""
+    },
+    {
+        "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"
+    },
+    {
+        "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"
+    },
+    {
+        "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.

rasa/builder/llm_service.py

@@ -0,0 +1,327 @@
+"""Service for handling LLM interactions."""
+
+import asyncio
+import importlib
+import json
+from contextlib import asynccontextmanager
+from copy import deepcopy
+from typing import Any, Dict, List, Optional
+
+import importlib_resources
+import openai
+import structlog
+from jinja2 import Template
+
+from rasa.builder import config
+from rasa.builder.exceptions import LLMGenerationError
+from rasa.builder.llm_context import tracker_as_llm_context
+from rasa.builder.models import LLMBuilderContext
+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):
+        self._client: Optional[openai.AsyncOpenAI] = None
+        self._domain_schema: Optional[Dict[str, Any]] = None
+        self._flows_schema: Optional[Dict[str, Any]] = None
+        self._helper_schema: Optional[Dict[str, Any]] = None
+
+    @asynccontextmanager
+    async def _get_client(self):
+        """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):
+        """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()
+
+        if self._helper_schema is None:
+            self._helper_schema = _load_helper_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 = await client.chat.completions.create(
+                    model=config.OPENAI_MODEL,
+                    messages=messages,
+                    temperature=config.OPENAI_TEMPERATURE,
+                    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"],
+                            },
+                        },
+                    },
+                )
+
+                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")
+
+    async def create_helper_messages(
+        self, llm_builder_context: LLMBuilderContext
+    ) -> List[Dict[str, Any]]:
+        """Create helper messages for LLM builder."""
+        # Format chat history for documentation search
+        chat_dump = self._format_chat_dump(llm_builder_context.chat_history)
+
+        # Search documentation
+        documentation_results = await self.search_documentation(chat_dump)
+        formatted_docs = self._format_documentation_results(documentation_results)
+
+        current_conversation = tracker_as_llm_context(llm_builder_context.tracker)
+
+        # Prepare LLM messages
+        system_messages = get_helper_messages(
+            current_conversation,
+            llm_builder_context.bot_logs,
+            llm_builder_context.chat_bot_files,
+            formatted_docs,
+        )
+
+        # Add user messages
+        messages = system_messages.copy()
+        for msg in llm_builder_context.chat_history:
+            messages.append(
+                {
+                    "role": "user" if msg.type == "user" else "assistant",
+                    "content": json.dumps(msg.content)
+                    if isinstance(msg.content, list)
+                    else msg.content,
+                }
+            )
+        return messages
+
+    async def generate_helper_response(
+        self, messages: List[Dict[str, Any]]
+    ) -> Dict[str, Any]:
+        """Generate helper response using OpenAI."""
+        self._prepare_schemas()
+
+        try:
+            async with self._get_client() as client:
+                response = await client.chat.completions.create(
+                    model=config.OPENAI_MODEL,
+                    messages=messages,
+                    response_format={
+                        "type": "json_schema",
+                        "json_schema": {
+                            "name": "llm_helper",
+                            "schema": self._helper_schema,
+                        },
+                    },
+                )
+
+                content = response.choices[0].message.content
+                if not content:
+                    raise LLMGenerationError("Empty response from LLM helper")
+
+                try:
+                    return json.loads(content)
+                except json.JSONDecodeError as e:
+                    raise LLMGenerationError(f"Invalid JSON from LLM helper: {e}")
+
+        except openai.OpenAIError as e:
+            raise LLMGenerationError(f"OpenAI API error in helper: {e}")
+        except asyncio.TimeoutError:
+            raise LLMGenerationError("LLM helper request timed out")
+
+    async def search_documentation(
+        self, query: str, max_results: Optional[int] = None
+    ) -> List[Dict[str, Any]]:
+        """Search documentation using OpenAI vector store."""
+        if max_results is None:
+            max_results = config.OPENAI_MAX_VECTOR_RESULTS
+
+        try:
+            async with self._get_client() as client:
+                results = await client.vector_stores.search(
+                    vector_store_id=config.OPENAI_VECTOR_STORE_ID,
+                    query=query,
+                    max_num_results=max_results,
+                    rewrite_query=True,
+                )
+
+                return results.data
+
+        except openai.OpenAIError as e:
+            structlogger.warning(
+                "llm.documentation_search_failed", error=str(e), query=query
+            )
+            return []
+
+    @staticmethod
+    def _format_chat_dump(messages) -> str:
+        """Format chat messages for documentation search."""
+        result = ""
+        for message in messages:
+            if message.type == "user":
+                content = (
+                    message.content
+                    if isinstance(message.content, str)
+                    else str(message.content)
+                )
+                result += f"User: {content}\n"
+            else:
+                if isinstance(message.content, list):
+                    for part in message.content:
+                        if part.get("type") == "text":
+                            result += f"Assistant: {part.get('text')}\n"
+                else:
+                    result += f"Assistant: {message.content}\n"
+        return result
+
+    @staticmethod
+    def _format_documentation_results(results) -> 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.attributes.get('url', '')}'>"
+            for part in result.content:
+                formatted_result += f"<content>{part.text}</content>"
+            formatted_results += formatted_result + "</result>"
+
+        return f"<sources>{formatted_results}</sources>"
+
+
+# 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))
+
+    # 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
+
+
+def _load_helper_schema() -> Dict[str, Any]:
+    """Load helper schema."""
+    return read_json_file(
+        importlib_resources.files(PACKAGE_NAME).joinpath(
+            "builder/llm-helper-schema.json"
+        )
+    )
+
+
+# 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}]
+
+
+def get_helper_messages(
+    current_conversation: str,
+    bot_logs: str,
+    chat_bot_files: Dict[str, str],
+    documentation_results: str,
+) -> List[Dict[str, Any]]:
+    """Get messages for helper response."""
+    global _helper_template
+
+    if _helper_template is None:
+        template_content = importlib.resources.read_text(
+            "rasa.builder",
+            "llm_helper_prompt.jinja2",
+        )
+        _helper_template = Template(template_content)
+
+    system_prompt = _helper_template.render(
+        current_conversation=current_conversation,
+        bot_logs=bot_logs,
+        chat_bot_files=chat_bot_files,
+        documentation_results=documentation_results,
+    )
+    return [{"role": "system", "content": system_prompt}]
+
+
+# Global service instance
+llm_service = LLMService()

rasa/builder/logging_utils.py

@@ -0,0 +1,51 @@
+"""Logging utilities for the prompt-to-bot service."""
+
+import collections
+import logging
+import threading
+from typing import Any, Deque, Dict
+
+from rasa.builder import config
+
+# Thread-safe deque for collecting recent logs
+_recent_logs: Deque[str] = collections.deque(maxlen=config.MAX_LOG_ENTRIES)
+_logs_lock = threading.RLock()
+
+
+def collecting_logs_processor(
+    logger: Any, log_level: str, event_dict: Dict[str, Any]
+) -> Dict[str, Any]:
+    """Structlog processor that collects recent log entries.
+
+    This processor is thread-safe and maintains a rolling buffer of recent logs.
+    """
+    if log_level != logging.getLevelName(logging.DEBUG).lower():
+        event_message = event_dict.get("event_info") or event_dict.get("event", "")
+        log_entry = f"[{log_level}] {event_message}"
+
+        with _logs_lock:
+            _recent_logs.append(log_entry)
+
+    return event_dict
+
+
+def get_recent_logs() -> str:
+    """Get recent log entries as a formatted string.
+
+    Returns:
+        Formatted string of recent log entries, one per line.
+    """
+    with _logs_lock:
+        return "\n".join(list(_recent_logs))
+
+
+def clear_recent_logs() -> None:
+    """Clear the recent logs buffer."""
+    with _logs_lock:
+        _recent_logs.clear()
+
+
+def get_log_count() -> int:
+    """Get the current number of log entries."""
+    with _logs_lock:
+        return len(_recent_logs)

rasa/builder/main.py

@@ -0,0 +1,61 @@
+#!/usr/bin/env python3
+"""Main entry point for the prompt-to-bot service."""
+
+import logging
+import sys
+from typing import Optional
+
+import rasa.core.utils
+from rasa.builder.logging_utils import collecting_logs_processor
+from rasa.builder.service import PromptToBotService
+from rasa.utils.common import configure_logging_and_warnings
+from rasa.utils.log_utils import configure_structlog
+from rasa.utils.sanic_error_handler import register_custom_sanic_error_handler
+
+
+def setup_logging():
+    """Setup logging configuration."""
+    log_level = logging.DEBUG
+
+    configure_logging_and_warnings(
+        log_level=log_level,
+        logging_config_file=None,
+        warn_only_once=True,
+        filter_repeated_logs=True,
+    )
+
+    configure_structlog(
+        log_level,
+        include_time=True,
+        additional_processors=[collecting_logs_processor],
+    )
+
+
+def main(project_folder: Optional[str] = None):
+    """Main entry point."""
+    try:
+        # Setup logging
+        setup_logging()
+
+        # Create and configure service
+
+        service = PromptToBotService(project_folder)
+        register_custom_sanic_error_handler(service.app)
+
+        # Log available routes
+        rasa.core.utils.list_routes(service.app)
+
+        # Run the service
+        service.run()
+
+    except KeyboardInterrupt:
+        print("\nService stopped by user")
+        sys.exit(0)
+    except Exception as e:
+        print(f"Failed to start service: {e}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    project_folder = sys.argv[1] if len(sys.argv) > 1 else None
+    main(project_folder)