rasa-pro 3.13.0a1.dev5__tar.gz → 3.13.0a1.dev6__tar.gz

{rasa_pro-3.13.0a1.dev5 → rasa_pro-3.13.0a1.dev6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: rasa-pro
-Version: 3.13.0a1.dev5
+Version: 3.13.0a1.dev6
 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.0a1.dev5 → rasa_pro-3.13.0a1.dev6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "rasa-pro"
-version = "3.13.0a1.dev5"
+version = "3.13.0a1.dev6"
 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.0a1.dev6/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_pro-3.13.0a1.dev5 → rasa_pro-3.13.0a1.dev6}/rasa/builder/prompt_to_bot.py

@@ -49,7 +49,12 @@ structlogger = structlog.get_logger()
 
 DEFAULT_SKILL_GENERATION_SYSTEM_PROMPT = importlib.resources.read_text(
     "rasa.builder",
-    "skill_to_bot_prompt.jinja",
+    "skill_to_bot_prompt.jinja2",
+)
+
+DEFAULT_LLM_HELPER_SYSTEM_PROMPT = importlib.resources.read_text(
+    "rasa.builder",
+    "llm_helper_prompt.jinja2",
 )
 
 VECTOR_STORE_ID = "vs_685123376e288191a005b6b144d3026f"
@@ -316,19 +321,15 @@ class PromptToBotService:
         }
 
     async def generate_rasa_project_with_retries(
-        self, base_prompt: str, config: Dict[str, Any], max_retry_count: int = 5
+        self, skill_description: str, config: Dict[str, Any], max_retry_count: int = 5
     ) -> Dict[str, Any]:
         """Generate Rasa project data with retry logic."""
-        initial_messages = self.prompt_messages(base_prompt)
+        initial_messages = self.prompt_messages(skill_description)
 
         async def _generate(messages: List[Dict[str, Any]], tries_left: int):
             rasa_project_data = await self.generate_rasa_project(messages)
             self.update_stored_bot_data(rasa_project_data, config)
 
-            # write the data to a file
-            with open(f"rasa_project_{tries_left}.json", "w") as f:
-                json.dump(rasa_project_data, f)
-
             structlogger.info(
                 "prompt_to_bot.generate_rasa_project_with_retries.generated_project",
                 tries_left=tries_left,
@@ -383,9 +384,9 @@ class PromptToBotService:
 
         return await _generate(initial_messages, max_retry_count)
 
-    def prompt_messages(self, prompt: str) -> List[Dict[str, Any]]:
+    def prompt_messages(self, skill_description: str) -> List[Dict[str, Any]]:
         system_prompt = Template(DEFAULT_SKILL_GENERATION_SYSTEM_PROMPT).render(
-            prompt=prompt
+            skill_description=skill_description
         )
 
         return [
@@ -484,10 +485,28 @@ class PromptToBotService:
                         result += f"Assistant: {part.get('text')}\n"
         return result
 
+    def llm_helper_prompt_messages(
+        self,
+        current_conversation: str,
+        bot_logs: str,
+        chat_bot_files: Dict[str, str],
+        documentation_results: str,
+    ) -> List[Dict[str, Any]]:
+        system_prompt = Template(DEFAULT_LLM_HELPER_SYSTEM_PROMPT).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},
+        ]
+
     async def llm_builder(self, request):
-        chat_bot_context = await self.generate_chat_bot_context()
-        recent_logs_context = "\n".join(recent_logs)
-        chat_bot_files_context = json.dumps(self.bot_files)
+        current_conversation = await self.generate_chat_bot_context()
+        bot_logs = "\n".join(recent_logs)
+        chat_bot_files = self.bot_files
         user_chat_history = request.json.get("messages", [])
         chat_dump = self.format_chat_dump(user_chat_history)
 
@@ -500,88 +519,23 @@ class PromptToBotService:
             rewrite_query=True,
         )
 
-        formatted_results = self.format_results(results.data)
-
-        prompt = dedent(f"""
-        You are a helpful assistant that helps users building chatbots using Rasa.
-        Do not mention Rasa Studio - only ever refer to Rasa Pro.
-        You are given the user question as well as context about the user's project.
-        You need to generate a response using content blocks.
-
-        The content blocks should be in the following format:
-        {{
-            "type": "text",
-            "text": "Great question, you can take a look at the following resource:"
-        }}
-        The type can be one of the following: text, link, file, code.
-        When using a block of type `text`, the `text` attribute can contain markdown.
-        Use markdown to format the text when needed.
-        The text is the text of the content block.
-
-        Code blocks:
-        {{
-            "type": "code",
-            "text": "- action: utter_greet\n  next: END\n",
-            "language": "yaml"
-        }}
-        Use code blocks to provide generic code examples. Whenever possible,
-        use file blocks to provide the user with changes that apply to their bot.
-
-        Link blocks:
-        {{
-            "type": "link",
-            "text": "http://rasa.com/docs/rasa/core/flows"
-        }}
-
-        File blocks:
-        {{
-            "type": "file",
-            "file": "flows.yml",
-            "content": "- action: utter_greet\n  next: END\n",
-        }}
-        Whenever possible, use file blocks to provide the user with changes
-        that apply to their bot.
-
-        You can use multiple content blocks to answer the user's question. Return
-        as many content blocks as needed.
-
-        Create links to https://rasa.com/docs for the user to take a look at.
-
-        ----
-        Logs from chatbot framework:
-        {recent_logs_context}
-
-        ----
-        Most recent conversation of the user with the chatbot:
-        {json.dumps(chat_bot_context)}
-
-        ----
-        Chat bot files for this project (name and content):
-        {json.dumps(chat_bot_files_context)}
-
-        ----
-        Documentation Context:
-        {formatted_results}
-
-        ----
-        Respond with a json array of content blocks. Keep the response
-        short and concise.
-        """)
-
-        past_messages = []
+        documentation_results = self.format_results(results.data)
+
+        messages = self.llm_helper_prompt_messages(
+            current_conversation,
+            bot_logs,
+            chat_bot_files,
+            documentation_results,
+        )
+
         for message in user_chat_history:
-            past_messages.append(
+            messages.append(
                 {
                     "role": "user" if message.get("type") == "user" else "assistant",
                     "content": json.dumps(message.get("content")),
                 }
             )
 
-        messages = [
-            {"role": "system", "content": prompt},
-            *past_messages,
-        ]
-
         llm_helper_schema = read_json_file(
             importlib_resources.files(PACKAGE_NAME).joinpath(
                 "builder/llm-helper-schema.json"

rasa_pro-3.13.0a1.dev5/rasa/builder/skill_to_bot_prompt.jinja → rasa_pro-3.13.0a1.dev6/rasa/builder/skill_to_bot_prompt.jinja2

@@ -127,11 +127,11 @@ CALM BOT JSON:
 - Use `steps` to outline the conversation flow
 - Implement `collect` steps for gathering information
 - `collect` steps should reference an existing slot
-- For a collect step referencing a slot `A`, there should be a corresponding `utter_ask_A` 
+- For a collect step referencing a slot `A`, there should be a corresponding `utter_ask_A`
   utterance that is used in the collect step to ask for the information to be stored in `A`
 - Use `action` steps for custom actions
 - Implement conditional logic with `if`, `then`, and `else` where appropriate
-- Use `next` to define the flow between steps. If the flow should end after a step, add next: END. 
+- Use `next` to define the flow between steps. If the flow should end after a step, add next: END.
 - The content after `then` or `else` can be: the id of another step defined in the flow, a list of steps, or an END
 - End the flow with an appropriate action or message
 
@@ -155,4 +155,5 @@ CALM BOT JSON:
 
 Now, please generate Rasa CALM flow and domain JSON configuration for the following skill description:
 
-${skillDescription}
+USER_SKILL_DESCRIPTION:
+{{skill_description}}

{rasa_pro-3.13.0a1.dev5 → rasa_pro-3.13.0a1.dev6}/rasa/core/channels/studio_chat.py

@@ -229,7 +229,14 @@ class StudioChatInput(SocketIOInput, VoiceInputChannel):
 
         Triggers a tracker update notification after processing the message.
         """
-        await on_new_message(message)
+        try:
+            await on_new_message(message)
+        except Exception as e:
+            structlogger.exception(
+                "studio_chat.on_new_message.error",
+                error=str(e),
+                sender_id=message.sender_id,
+            )
 
         if not self.agent:
             structlogger.error("studio_chat.on_message_proxy.agent_not_initialized")
@@ -439,8 +446,15 @@ class StudioChatInput(SocketIOInput, VoiceInputChannel):
                     ws.put_message(data)
                 return
 
-            # Handle text messages
-            await self.handle_user_message(sid, data, on_new_message)
+            try:
+                # Handle text messages
+                await self.handle_user_message(sid, data, on_new_message)
+            except Exception as e:
+                structlogger.exception(
+                    "studio_chat.sio.handle_message.error",
+                    error=str(e),
+                    sid=sid,
+                )
 
         @self.sio.on("update_tracker", namespace=self.namespace)
         async def on_update_tracker(sid: Text, data: Dict) -> None:

{rasa_pro-3.13.0a1.dev5 → rasa_pro-3.13.0a1.dev6}/rasa/version.py

@@ -1,3 +1,3 @@
 # this file will automatically be changed,
 # do not add anything but the version number here!
-__version__ = "3.13.0a1.dev5"
+__version__ = "3.13.0a1.dev6"