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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: rasa-pro
-Version: 3.13.0a1.dev4
+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.dev4 → 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.dev4"
+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>",]
@@ -376,6 +376,8 @@ 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_context.py

@@ -0,0 +1,81 @@
+import json
+from typing import Optional
+
+from rasa.shared.core.constants import DEFAULT_SLOT_NAMES
+from rasa.shared.core.events import (
+    ActionExecuted,
+    BotUttered,
+    FlowCompleted,
+    FlowStarted,
+    SlotSet,
+    UserUttered,
+)
+from rasa.shared.core.trackers import DialogueStateTracker
+
+
+def tracker_as_llm_context(tracker: Optional[DialogueStateTracker]) -> str:
+    """Convert a tracker to a string that can be used as context for the LLM."""
+    if not tracker or not tracker.events:
+        return "No conversation history available."
+
+    context_parts = []
+    current_turn = []
+
+    for event in tracker.events:
+        if isinstance(event, UserUttered):
+            if current_turn:
+                context_parts.append(" | ".join(current_turn))
+                current_turn = []
+            current_turn.append(f"User: {event.text}")
+            if event.intent:
+                current_turn.append(f"Intent: {event.intent.get('name')}")
+            if event.entities:
+                current_turn.append(
+                    f"Entities: {[e.get('entity') for e in event.entities]}"
+                )
+            if event.commands:
+                current_turn.append(
+                    f"Commands: {[cmd.get('name') for cmd in event.commands]}"
+                )
+
+        elif isinstance(event, BotUttered):
+            if event.text:
+                current_turn.append(f"Bot: {event.text}")
+
+        elif isinstance(event, ActionExecuted):
+            current_turn.append(f"Action: {event.action_name}")
+            if event.confidence:
+                current_turn.append(f"Confidence: {event.confidence:.2f}")
+
+        elif isinstance(event, SlotSet) and event.key not in DEFAULT_SLOT_NAMES:
+            current_turn.append(f"Slot Set: {event.key}={event.value}")
+
+        elif isinstance(event, FlowStarted):
+            current_turn.append(f"# Flow Started: {event.flow_id}")
+
+        elif isinstance(event, FlowCompleted):
+            current_turn.append(f"# Flow Completed: {event.flow_id}")
+
+    if current_turn:
+        context_parts.append(" | ".join(current_turn))
+
+    # Add final state information
+    context_parts.append("\nCurrent State:")
+    context_parts.append(f"Latest Message: {tracker.latest_message.text or '-'}")
+
+    # Add active flows from stack
+    if tracker.active_flow:
+        context_parts.append(f"Active Flow: {tracker.active_flow}")
+    if tracker.stack:
+        context_parts.append(f"Flow Stack: {json.dumps(tracker.stack.as_dict())}")
+
+    # Add slot values that are not None
+    non_empty_slots = {
+        k: str(v.value)
+        for k, v in tracker.slots.items()
+        if v is not None and k not in DEFAULT_SLOT_NAMES
+    }
+    if non_empty_slots:
+        context_parts.append(f"Slots: {json.dumps(non_empty_slots)}")
+
+    return "\n".join(context_parts)

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.dev4 → rasa_pro-3.13.0a1.dev6}/rasa/builder/prompt_to_bot.py

@@ -1,4 +1,5 @@
 import asyncio
+import collections
 import importlib
 import json
 import logging
@@ -18,6 +19,7 @@ from sanic import Sanic, response
 from structlog.testing import capture_logs
 
 import rasa.core.utils
+from rasa.builder.llm_context import tracker_as_llm_context
 from rasa.cli.utils import validate_files
 from rasa.constants import PACKAGE_NAME
 from rasa.core import agent, channels
@@ -47,15 +49,15 @@ 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",
 )
 
-VECTOR_STORE_ID = "vs_685123376e288191a005b6b144d3026f"
-
+DEFAULT_LLM_HELPER_SYSTEM_PROMPT = importlib.resources.read_text(
+    "rasa.builder",
+    "llm_helper_prompt.jinja2",
+)
 
-class PromptRequest(BaseModel):
-    prompt: str
-    client_id: Optional[str] = None
+VECTOR_STORE_ID = "vs_685123376e288191a005b6b144d3026f"
 
 
 default_credentials_yaml = """
@@ -65,6 +67,23 @@ studio_chat:
   session_persistence: true
 """
 
+# create a dict where we collect most recent logs. only collect the last 30 log lines
+# use a builtin type for this
+recent_logs = collections.deque(maxlen=30)
+
+
+def collecting_logs_processor(logger, log_level, event_dict):
+    if log_level != logging.getLevelName(logging.DEBUG).lower():
+        event_message = event_dict.get("event_info") or event_dict.get("event", "")
+        recent_logs.append(f"[{log_level}] {event_message}")
+
+    return event_dict
+
+
+class PromptRequest(BaseModel):
+    prompt: str
+    client_id: Optional[str] = None
+
 
 def default_credentials() -> Dict[str, Any]:
     return read_yaml(default_credentials_yaml)
@@ -255,7 +274,9 @@ class PromptToBotService:
             )
         except Exception as e:
             structlogger.error(
-                "prompt_to_bot.update_bot_data.validation_error", error=str(e)
+                "prompt_to_bot.update_bot_data.validation_error",
+                error=str(e),
+                event_info="Failed to validate the Rasa project. Error: " + str(e),
             )
             await response.send(
                 sse_event(
@@ -273,7 +294,9 @@ class PromptToBotService:
             await response.send(sse_event("train_success", {"status": "train_success"}))
         except Exception as e:
             structlogger.error(
-                "prompt_to_bot.update_bot_data.train_error", error=str(e)
+                "prompt_to_bot.update_bot_data.train_error",
+                error=str(e),
+                event_info="Failed to train the agent. Error: " + str(e),
             )
             await response.send(
                 sse_event("train_error", {"status": "train_error", "error": str(e)})
@@ -298,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,
@@ -365,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 [
@@ -450,107 +469,73 @@ class PromptToBotService:
             ] = await self.app.ctx.agent.tracker_store.retrieve(
                 self.input_channel.latest_tracker_session_id
             )
-            if tracker is None:
-                test_conversation = []
-            else:
-                test_conversation = tracker.current_state()
+            return tracker_as_llm_context(tracker)
         else:
-            test_conversation = []
+            return tracker_as_llm_context(None)
 
-        chat_bot_files = self.bot_files
+    def format_chat_dump(self, user_chat_history: List[Dict[str, Any]]) -> str:
+        """Format the chat dump for the LLM."""
+        result = ""
+        for message in user_chat_history:
+            if message.get("type") == "user":
+                result += f"User: {message.get('content')}\n"
+            else:
+                for part in message.get("content", []):
+                    if part.get("type") == "text":
+                        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 {
-            "test_conversation": test_conversation,
-            "chat_bot_files": chat_bot_files,
-        }
+        return [
+            {"role": "system", "content": system_prompt},
+        ]
 
     async def llm_builder(self, request):
-        chat_bot_context = await self.generate_chat_bot_context()
+        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", [])
-        last_user_message = (
-            user_chat_history[-1].get("content") if user_chat_history else ""
+        chat_dump = self.format_chat_dump(user_chat_history)
+
+        client = openai.AsyncOpenAI()
+
+        results = await client.vector_stores.search(
+            vector_store_id=VECTOR_STORE_ID,
+            query=chat_dump,
+            max_num_results=10,
+            rewrite_query=True,
+        )
+
+        documentation_results = self.format_results(results.data)
+
+        messages = self.llm_helper_prompt_messages(
+            current_conversation,
+            bot_logs,
+            chat_bot_files,
+            documentation_results,
         )
 
-        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.
-
-        Chat bot context:
-        {json.dumps(chat_bot_context)}
-        """)
-
-        past_messages = []
         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")),
                 }
             )
 
-        client = openai.AsyncOpenAI()
-
-        results = await client.vector_stores.search(
-            vector_store_id=VECTOR_STORE_ID,
-            query=last_user_message,
-        )
-
-        formatted_results = self.format_results(results.data)
-
-        messages = [
-            {"role": "system", "content": prompt},
-            *past_messages,
-            {
-                "role": "user",
-                "content": (
-                    f"Documentation Context: {formatted_results}\n\n"
-                    "Respond with a json array of content blocks. Keep the "
-                    "response short and concise."
-                ),
-            },
-        ]
-
         llm_helper_schema = read_json_file(
             importlib_resources.files(PACKAGE_NAME).joinpath(
                 "builder/llm-helper-schema.json"
@@ -622,7 +607,10 @@ class PromptToBotService:
         )
 
         if not agent_instance.is_ready():
-            raise Exception("Failed to load model.")
+            raise Exception(
+                "Generation of the chatbot failed with an error (model failed "
+                "to load). Please try again."
+            )
 
         structlogger.info(
             "prompt_to_bot.train_and_load_agent.agent_ready",
@@ -642,7 +630,13 @@ def main():
         warn_only_once=True,
         filter_repeated_logs=True,
     )
-    configure_structlog(log_level, include_time=True)
+    configure_structlog(
+        log_level,
+        include_time=True,
+        additional_processors=[
+            collecting_logs_processor,
+        ],
+    )
 
     service = PromptToBotService()
     register_custom_sanic_error_handler(service.app)

rasa_pro-3.13.0a1.dev4/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}}