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

rasa/builder/models.py

@@ -0,0 +1,174 @@
+"""Pydantic models for request/response validation."""
+
+from typing import Any, Dict, List, Literal, Optional, Union
+
+from pydantic import BaseModel, Field, validator
+
+from rasa.cli.scaffold import ProjectTemplateName
+from rasa.shared.core.trackers import DialogueStateTracker
+
+
+class PromptRequest(BaseModel):
+    """Request model for prompt-to-bot endpoint."""
+
+    prompt: str = Field(
+        ..., min_length=1, max_length=10000, description="The skill description prompt"
+    )
+    client_id: Optional[str] = Field(
+        None, max_length=255, description="Optional client identifier"
+    )
+
+    @validator("prompt")
+    def validate_prompt(cls, v):
+        if not v.strip():
+            raise ValueError("Prompt cannot be empty or whitespace only")
+        return v.strip()
+
+
+class TemplateRequest(BaseModel):
+    """Request model for template-to-bot endpoint."""
+
+    template_name: ProjectTemplateName = Field(
+        ...,
+        description=(
+            f"The template name to use ({ProjectTemplateName.supported_values()})"
+        ),
+    )
+    client_id: Optional[str] = Field(
+        None, max_length=255, description="Optional client identifier"
+    )
+
+    @validator("template_name")
+    def validate_template_name(cls, v):
+        if v not in ProjectTemplateName:
+            raise ValueError(
+                f"Template name must be one of {ProjectTemplateName.supported_values()}"
+            )
+        return v
+
+
+class ChatMessage(BaseModel):
+    """Model for chat messages."""
+
+    type: str = Field(..., pattern="^(user|assistant)$")
+    content: Union[str, List[Dict[str, Any]]] = Field(...)
+
+
+class LLMBuilderRequest(BaseModel):
+    """Request model for LLM builder endpoint."""
+
+    messages: List[ChatMessage] = Field(..., min_items=1, max_items=50)
+
+
+class LLMBuilderContext(BaseModel):
+    """Context model for LLM builder endpoint."""
+
+    tracker: Optional[DialogueStateTracker] = Field(None)
+    bot_logs: str = Field("")
+    chat_bot_files: Dict[str, str] = Field({})
+    chat_history: List[ChatMessage] = Field([])
+
+    class Config:
+        """Config for LLMBuilderContext."""
+
+        arbitrary_types_allowed = True
+
+
+class BotDataUpdateRequest(BaseModel):
+    """Request model for bot data updates."""
+
+    domain_yml: Optional[str] = Field(None, alias="domain.yml")
+    flows_yml: Optional[str] = Field(None, alias="flows.yml")
+    config_yml: Optional[str] = Field(None, alias="config.yml")
+
+    class Config:
+        """Config for BotDataUpdateRequest."""
+
+        allow_population_by_field_name = True
+
+
+class ContentBlock(BaseModel):
+    """Base model for content blocks."""
+
+    type: str = Field(...)
+
+
+class TextBlock(ContentBlock):
+    """Text content block."""
+
+    type: Literal["text"] = "text"
+    text: str = Field(...)
+
+
+class CodeBlock(ContentBlock):
+    """Code content block."""
+
+    type: Literal["code"] = "code"
+    text: str = Field(...)
+    language: Optional[str] = Field(None)
+
+
+class FileBlock(ContentBlock):
+    """File content block."""
+
+    type: Literal["file"] = "file"
+    file: str = Field(...)
+    content: str = Field(...)
+
+
+class LinkBlock(ContentBlock):
+    """Link content block."""
+
+    type: Literal["link"] = "link"
+    text: str = Field(..., pattern=r"^https?://")
+
+
+class LLMHelperResponse(BaseModel):
+    """Response model for LLM helper."""
+
+    content_blocks: List[Union[TextBlock, CodeBlock, FileBlock, LinkBlock]] = Field(...)
+
+
+class ApiResponse(BaseModel):
+    """Standard API response model."""
+
+    status: str = Field(...)
+    message: Optional[str] = Field(None)
+    data: Optional[Dict[str, Any]] = Field(None)
+
+
+class ApiErrorResponse(BaseModel):
+    """API error response model."""
+
+    status: Literal["error"] = "error"
+    error: str = Field(...)
+    details: Optional[Dict[str, Any]] = Field(None)
+
+
+class ServerSentEvent(BaseModel):
+    """Server-sent event model."""
+
+    event: str = Field(...)
+    data: Dict[str, Any] = Field(...)
+
+    def format(self) -> str:
+        """Format as SSE string."""
+        import json
+
+        return f"event: {self.event}\ndata: {json.dumps(self.data)}\n\n"
+
+
+class ValidationResult(BaseModel):
+    """Result of validation operation."""
+
+    is_valid: bool = Field(...)
+    errors: Optional[List[str]] = Field(None)
+    warnings: Optional[List[str]] = Field(None)
+
+
+class TrainingResult(BaseModel):
+    """Result of training operation."""
+
+    success: bool = Field(...)
+    model_path: Optional[str] = Field(None)
+    error: Optional[str] = Field(None)

rasa/builder/project_generator.py

@@ -0,0 +1,264 @@
+"""Service for generating Rasa projects from prompts."""
+
+import json
+import os
+import shutil
+from pathlib import Path
+from textwrap import dedent
+from typing import Any, Dict, List, Optional
+
+import structlog
+
+from rasa.builder import config
+from rasa.builder.exceptions import ProjectGenerationError, ValidationError
+from rasa.builder.llm_service import get_skill_generation_messages, llm_service
+from rasa.builder.validation_service import validate_project
+from rasa.cli.scaffold import ProjectTemplateName, create_initial_project
+from rasa.shared.core.flows import yaml_flows_io
+from rasa.shared.importers.importer import TrainingDataImporter
+from rasa.shared.utils.yaml import dump_obj_as_yaml_to_string
+from rasa.utils.io import subpath
+
+structlogger = structlog.get_logger()
+
+
+class ProjectGenerator:
+    """Service for generating Rasa projects from skill descriptions."""
+
+    def __init__(self, project_folder: str):
+        """Initialize the project generator with a folder for file persistence.
+
+        Args:
+            project_folder: Path to the folder where project files will be stored
+        """
+        self.project_folder = Path(project_folder)
+        self.project_folder.mkdir(parents=True, exist_ok=True)
+
+    def init_from_template(self, template: ProjectTemplateName):
+        """Create the initial project files."""
+        self.cleanup()
+        create_initial_project(self.project_folder.as_posix(), template)
+
+    async def generate_project_with_retries(
+        self,
+        skill_description: str,
+        template: ProjectTemplateName,
+        max_retries: Optional[int] = None,
+    ) -> Dict[str, str]:
+        """Generate a Rasa project with retry logic for validation failures.
+
+        Args:
+            skill_description: Natural language description of the skill
+            rasa_config: Rasa configuration dictionary
+            template: Project template to use for the initial project
+            max_retries: Maximum number of retry attempts
+
+        Returns:
+            Dictionary of generated file contents (filename -> content)
+
+        Raises:
+            ProjectGenerationError: If generation fails after all retries
+        """
+        if max_retries is None:
+            max_retries = config.MAX_RETRIES
+
+        self.init_from_template(template)
+
+        project_data = self._get_bot_data_for_llm()
+
+        initial_messages = get_skill_generation_messages(
+            skill_description, project_data
+        )
+
+        async def _generate_with_retry(
+            messages: List[Dict[str, Any]], attempts_left: int
+        ):
+            try:
+                # Generate project data using LLM
+                project_data = await llm_service.generate_rasa_project(messages)
+
+                # Update stored bot data
+                self._update_bot_files_from_llm_response(project_data)
+
+                bot_files = self.get_bot_files()
+                structlogger.info(
+                    "project_generator.generated_project",
+                    attempts_left=attempts_left,
+                    files=list(bot_files.keys()),
+                )
+
+                # Validate the generated project
+                await self._validate_generated_project()
+
+                structlogger.info(
+                    "project_generator.validation_success", attempts_left=attempts_left
+                )
+
+                return bot_files
+
+            except ValidationError as e:
+                structlogger.error(
+                    "project_generator.validation_error",
+                    error=str(e),
+                    attempts_left=attempts_left,
+                )
+
+                if attempts_left <= 0:
+                    raise ProjectGenerationError(
+                        f"Failed to generate valid Rasa project: {e}", max_retries
+                    )
+
+                # Create error feedback for next attempt
+                error_feedback_messages = messages + [
+                    {
+                        "role": "assistant",
+                        "content": json.dumps(project_data),
+                    },
+                    {
+                        "role": "user",
+                        "content": dedent(f"""
+                            Previous attempt failed validation with error: {e}
+
+                            Please fix the issues and generate a valid Rasa project.
+                            Pay special attention to:
+                            - Proper YAML syntax
+                            - Required fields in domain and flows
+                            - Consistent naming between flows and domain
+                            - Valid slot types and mappings
+                        """).strip(),
+                    },
+                ]
+
+                return await _generate_with_retry(
+                    error_feedback_messages, attempts_left - 1
+                )
+
+            except Exception as e:
+                structlogger.error(
+                    "project_generator.generation_error",
+                    error=str(e),
+                    attempts_left=attempts_left,
+                )
+
+                if attempts_left <= 0:
+                    raise ProjectGenerationError(
+                        f"Failed to generate Rasa project: {e}", max_retries
+                    )
+
+                # For non-validation errors, retry with original messages
+                return await _generate_with_retry(initial_messages, attempts_left - 1)
+
+        return await _generate_with_retry(initial_messages, max_retries)
+
+    async def _validate_generated_project(self):
+        """Validate the generated project using the validation service."""
+        importer = self._create_importer()
+        validation_error = await validate_project(importer)
+
+        if validation_error:
+            raise ValidationError(validation_error)
+
+    def _create_importer(self) -> TrainingDataImporter:
+        """Create a training data importer from the current bot files."""
+        try:
+            return TrainingDataImporter.load_from_config(
+                config_path=self.project_folder / "config.yml",
+                domain_path=self.project_folder / "domain.yml",
+                training_data_paths=[
+                    self.project_folder / "data",
+                ],
+                args={},
+            )
+
+        except Exception as e:
+            raise ValidationError(f"Failed to create importer: {e}")
+
+    def get_bot_files(self) -> Dict[str, str]:
+        """Get the current bot files by reading from disk."""
+        bot_files = {}
+
+        for file in self.project_folder.glob("**/*"):
+            # Skip directories
+            if not file.is_file():
+                continue
+
+            relative_path = file.relative_to(self.project_folder)
+
+            # Skip hidden files and directories (any path component starting with '.')
+            if any(part.startswith(".") for part in relative_path.parts):
+                continue
+
+            # exclude the project_folder / models folder
+            if relative_path.parts[0] == "models":
+                continue
+
+            # Read file content and store with relative path as key
+            bot_files[relative_path.as_posix()] = file.read_text(encoding="utf-8")
+
+        return bot_files
+
+    def _get_bot_data_for_llm(self) -> Dict[str, Any]:
+        """Get the current bot data for the LLM."""
+        file_importer = self._create_importer()
+
+        # only include data created by the user (or the builder llm)
+        # avoid including to many defaults that are not customized
+        domain = file_importer.get_user_domain()
+        flows = file_importer.get_user_flows()
+
+        return {
+            "domain": domain.as_dict(should_clean_json=True),
+            "flows": yaml_flows_io.get_flows_as_json(flows, should_clean_json=True),
+        }
+
+    def _path_for_flow(self, flow_id: str) -> str:
+        """Get the path for a flow."""
+        if flow_id.startswith("pattern_"):
+            return f"data/patterns/{flow_id}.yml"
+        else:
+            return f"data/flows/{flow_id}.yml"
+
+    def _update_bot_files_from_llm_response(self, project_data: Dict[str, Any]):
+        """Update the bot files with generated data by writing to disk."""
+        files = {"domain.yml": dump_obj_as_yaml_to_string(project_data["domain"])}
+        # split up flows into one file per flow in the /flows folder
+        for flow_id, flow_data in project_data["flows"].get("flows", {}).items():
+            flow_file_path = self._path_for_flow(flow_id)
+            single_flow_file_data = {"flows": {flow_id: flow_data}}
+            files[flow_file_path] = dump_obj_as_yaml_to_string(single_flow_file_data)
+
+        # removes any other flows that the LLM didn't generate
+        self._cleanup_flows()
+        self.update_bot_files(files)
+
+    def _cleanup_flows(self):
+        """Cleanup the flows folder."""
+        flows_folder = self.project_folder / "data" / "flows"
+        if flows_folder.exists():
+            shutil.rmtree(flows_folder)
+        flows_folder.mkdir(parents=True, exist_ok=True)
+
+    def update_bot_files(self, files: Dict[str, str]):
+        """Update bot files with new content by writing to disk."""
+        for filename, content in files.items():
+            file_path = Path(subpath(self.project_folder, filename))
+            file_path.parent.mkdir(parents=True, exist_ok=True)
+            file_path.write_text(content, encoding="utf-8")
+
+    def cleanup(self):
+        """Cleanup the project folder."""
+        # remove all the files and folders in the project folder resulting
+        # in an empty folder
+        for filename in os.listdir(self.project_folder):
+            file_path = os.path.join(self.project_folder, filename)
+            try:
+                if os.path.isfile(file_path) or os.path.islink(file_path):
+                    os.unlink(file_path)
+                elif os.path.isdir(file_path):
+                    shutil.rmtree(file_path)
+            except Exception as e:
+                structlogger.error(
+                    "project_generator.cleanup_error",
+                    error=str(e),
+                    file_path=file_path,
+                )

rasa/builder/scrape_rasa_docs.py

@@ -0,0 +1,97 @@
+import json
+import os
+from pathlib import Path
+from urllib.parse import urljoin, urlparse
+
+import requests
+from bs4 import BeautifulSoup
+
+BASE_URL = "https://rasa.com"
+DOCS_ROOT = "https://rasa.com/docs"
+OUTPUT_DIR = "rasa_docs_md"
+MAX_PAGES = 100  # Optional limit for safety
+
+visited = set()
+to_visit = [DOCS_ROOT]
+
+os.makedirs(OUTPUT_DIR, exist_ok=True)
+
+
+def is_valid_doc_url(url):
+    return url.startswith(DOCS_ROOT) and not any(
+        [url.endswith(".pdf"), "#" in url, "mailto:" in url]
+    )
+
+
+def slugify_url(url):
+    path = urlparse(url).path.strip("/").replace("/", "_")
+    return path if path else "index"
+
+
+def clean_text(html):
+    soup = BeautifulSoup(html, "html.parser")
+
+    # Remove navs, footers, and code tabs (customize if needed)
+    for tag in soup(["nav", "footer", "script", "style", "form", "button"]):
+        tag.decompose()
+
+    main = soup.find("main") or soup.body
+    if not main:
+        return ""
+
+    # Replace <code> with backticks
+    for code in main.find_all("code"):
+        code.string = f"`{code.get_text(strip=True)}`"
+
+    text = main.get_text(separator="\n", strip=True)
+    return text
+
+
+def save_as_markdown(text) -> str:
+    slug = slugify_url(url)
+    file_name = f"{slug}.md"
+    md_path = Path(OUTPUT_DIR) / file_name
+    with open(md_path, "w", encoding="utf-8") as f:
+        f.write(text)
+
+    print(f"✅ Saved: {md_path}")
+    return file_name
+
+
+pages_scraped = 0
+markdown_to_url = {}
+
+while to_visit and pages_scraped < MAX_PAGES:
+    url = to_visit.pop(0)
+    if url in visited:
+        continue
+
+    try:
+        print(f"Scraping: {url}")
+        response = requests.get(url)
+        response.raise_for_status()
+
+        html = response.text
+        text = clean_text(html)
+        if len(text) < 200:  # skip very short pages
+            print("⏭️ Skipped (too short)")
+            continue
+
+        file_name = save_as_markdown(text)
+        markdown_to_url[file_name] = url
+        pages_scraped += 1
+
+        soup = BeautifulSoup(html, "html.parser")
+        for link_tag in soup.find_all("a", href=True):
+            link = urljoin(url, link_tag["href"])
+            if is_valid_doc_url(link) and link not in visited:
+                to_visit.append(link)
+
+        visited.add(url)
+
+    except Exception as e:
+        print(f"⚠️ Failed to scrape {url}: {e}")
+
+
+with open("markdown_to_url.json", "w") as f:
+    json.dump(markdown_to_url, f, indent=2)