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

rasa/builder/models.py

@@ -1,13 +1,13 @@
 """Pydantic models for request/response validation."""
 
 import json
-from typing import Any, Dict, List, Literal, Optional, Union
+from enum import Enum
+from typing import Any, Dict, List, Literal, Optional
 
 import structlog
-from pydantic import BaseModel, Field, model_validator, validator
+from pydantic import BaseModel, Field, validator
 
 from rasa.cli.scaffold import ProjectTemplateName
-from rasa.shared.core.trackers import DialogueStateTracker
 
 structlogger = structlog.get_logger()
 
@@ -45,150 +45,6 @@ class TemplateRequest(BaseModel):
         return v
 
 
-class BaseContent(BaseModel):
-    type: str
-
-
-class TextContent(BaseContent):
-    type: Literal["text"]
-    text: str
-
-
-class LinkContent(BaseContent):
-    type: Literal["link"]
-    text: str  # This holds the URL
-
-
-class CodeContent(BaseContent):
-    type: Literal["code"]
-    text: str
-
-
-class FileContent(BaseContent):
-    type: Literal["file"]
-    file_path: str
-    file_content: str
-
-
-class EventContent(BaseModel):
-    type: Literal["event"]
-    event: str = Field(..., description="The event's type_name")
-
-    event_data: Dict[str, Any] = Field(
-        default_factory=dict,
-        description="Contains event-specific data fields."
-    )
-
-    @model_validator(mode="before")
-    @classmethod
-    def _collect_event_data(cls, data: Dict[str, Any]) -> Dict[str, Any]:
-        generic = {"type", "event"}
-        data["event_data"] = {
-            key: data.pop(key) for key in list(data.keys()) if key not in generic
-        }
-        return data
-
-    class Config:
-        extra = "forbid"
-
-
-class CopilotChatMessage(BaseModel):
-    """Model for a single chat messages between the user and the copilot."""
-
-    role: str = Field(..., pattern="^(user|copilot)$")
-    content: List[
-        Union[TextContent, LinkContent, CodeContent, FileContent, EventContent]
-    ] = Field(
-        ...,
-        description=(
-            "The content of the message. "
-            "The content is expected to be a list of content blocks. "
-            "The content blocks are expected to be one of the following types: "
-            "text, link, code, or file."
-        ),
-    )
-
-    @classmethod
-    def from_llm_response(cls, llm_response: Dict[str, Any]) -> "CopilotChatMessage":
-        """Create a CopilotChatMessage from an LLM response (role: copilot)."""
-        parsed_content = []
-        block_type_to_content_class = {
-            "text": TextContent,
-            "link": LinkContent,
-            "code": CodeContent,
-            "file": FileContent,
-            "event": EventContent,
-        }
-        for block in llm_response.get("content_blocks", []):
-            block_type = block.get("type")
-            if block_type in block_type_to_content_class.keys():
-                parsed_content.append(block_type_to_content_class[block_type](**block))
-            else:
-                structlogger.error(
-                    "copilot_chat_message.from_llm_response.unknown_content_block_type",
-                    event_info=f"Unknown content block type: `{block_type}`",
-                    block_type=block_type,
-                    block=block,
-                    llm_response=llm_response,
-                )
-                continue
-
-        return cls(role="copilot", content=parsed_content)
-
-    def get_text_content(self) -> str:
-        """Concatenate all 'text' content blocks into a single string."""
-        return "\n".join(
-            content_block.text
-            for content_block in self.content
-            if isinstance(content_block, TextContent)
-        )
-
-    def to_openai_format(self) -> Dict[str, Any]:
-        """Convert to OpenAI message format for API calls."""
-        role = "user" if self.role == "user" else "assistant"
-
-        if self.role == "user":
-            content = self.get_text_content()
-        else:
-            content = [block.model_dump() for block in self.content]
-            content = json.dumps(content)
-
-        return {"role": role, "content": content}
-
-
-class CopilotRequest(BaseModel):
-    """Request model for the copilot endpoint."""
-
-    copilot_chat_history: List[CopilotChatMessage] = Field(
-        ...,
-        description=(
-            "The chat history between the user and the copilot. "
-            "Used to generate a new response based on the previous conversation."
-        ),
-    )
-    session_id: str = Field(
-        ...,
-        description=(
-            "The session ID of chat session with the assistant. "
-            "Used to fetch the conversation from the tracker."
-        ),
-    )
-
-
-class CopilotContext(BaseModel):
-    """Model containing the context used by the copilot to generate a response."""
-
-    tracker: Optional[DialogueStateTracker] = Field(None)
-    assistant_logs: str = Field("")
-    assistant_files: Dict[str, str] = Field({})
-    copilot_chat_history: List[CopilotChatMessage] = Field([])
-
-    class Config:
-        """Config for LLMBuilderContext."""
-
-        arbitrary_types_allowed = True
-
-
 class BotDataUpdateRequest(BaseModel):
     """Request model for bot data updates."""
 
@@ -202,67 +58,101 @@ class BotDataUpdateRequest(BaseModel):
         allow_population_by_field_name = True
 
 
-class ContentBlock(BaseModel):
-    """Base model for content blocks."""
+class BotData(BaseModel):
+    """Data of a running assistant."""
 
-    type: str = Field(...)
+    domain: Dict[str, Any] = Field(..., description="The domain of the assistant.")
+    flows: Dict[str, Any] = Field(..., description="The flows of the assistant.")
 
 
-class TextBlock(ContentBlock):
-    """Text content block."""
+class AssistantInfo(BaseModel):
+    """Basic information about the loaded assistant."""
 
-    type: Literal["text"] = "text"
-    text: str = Field(...)
+    assistant_id: Optional[str] = Field(
+        None,
+        description=(
+            "Assistant identifier coming from `assistant_id` in the model "
+            "metadata (config.yml)."
+        ),
+    )
 
 
-class CodeBlock(ContentBlock):
-    """Code content block."""
+class ApiErrorResponse(BaseModel):
+    """API error response model."""
 
-    type: Literal["code"] = "code"
-    text: str = Field(...)
-    language: Optional[str] = Field(None)
+    status: Literal["error"] = "error"
+    error: str = Field(...)
+    details: Optional[Dict[str, Any]] = Field(None)
 
 
-class FileBlock(ContentBlock):
-    """File content block."""
+class ServerSentEventType(str, Enum):
+    progress = "progress"
+    error = "error"
+    _EOF = "_EOF"
 
-    type: Literal["file"] = "file"
-    file: str = Field(...)
-    content: str = Field(...)
 
+class ServerSentEvent(BaseModel):
+    """Generic Server-Sent Event payload."""
 
-class LinkBlock(ContentBlock):
-    """Link content block."""
+    event: str = Field(..., description="SSE event name / type")
+    data: Dict[str, Any] = Field(
+        default_factory=dict,
+        description="Arbitrary JSON-serializable payload",
+    )
 
-    type: Literal["link"] = "link"
-    text: str = Field(..., pattern=r"^https?://")
+    @classmethod
+    def build(cls, event: str, data: Any) -> "ServerSentEvent":
+        """General-purpose constructor.
 
+        Args:
+            event: The event name (e.g. "progress", "error").
+            data: Arbitrary key-value pairs to include in the payload.
 
-class CoPilotHelperResponse(BaseModel):
-    """Response model for CoPilot helper."""
+        Returns:
+            A ServerSentEvent instance with the specified event and data.
+        """
+        return cls(event=event, data=data)
 
-    content_blocks: List[Union[TextBlock, CodeBlock, FileBlock, LinkBlock]] = Field(...)
+    @classmethod
+    def eof(cls) -> "ServerSentEvent":
+        """Helper that returns the special end-of-stream marker."""
+        return cls(event=ServerSentEventType._EOF.value, data={})
 
+    def format(self) -> str:
+        """Return the text representation used by SSE protocols."""
+        return (
+            f"event: {self.event}\n"
+            f"data: {json.dumps(self.data, separators=(', ', ': '))}\n\n"
+        )
 
-class ApiErrorResponse(BaseModel):
-    """API error response model."""
 
-    status: Literal["error"] = "error"
-    error: str = Field(...)
-    details: Optional[Dict[str, Any]] = Field(None)
+class JobStatusEvent(ServerSentEvent):
+    """Job status event with special handling for progress and error states."""
 
+    @classmethod
+    def from_status(
+        cls,
+        status: str,
+        message: Optional[str] = None,
+    ) -> "JobStatusEvent":
+        """Factory for job-status events.
 
-class ServerSentEvent(BaseModel):
-    """Server-sent event model."""
+        Args:
+            status: The job status (e.g. "training", "train_success").
+            message: Optional error message for error events.
 
-    event: str = Field(...)
-    data: Dict[str, Any] = Field(...)
+        Returns:
+            A JobStatusEvent instance with the appropriate event type and data.
+        """
+        event_type = (
+            ServerSentEventType.error if message else ServerSentEventType.progress
+        )
 
-    def format(self) -> str:
-        """Format as SSE string."""
-        import json
+        payload: Dict[str, Any] = {"status": status}
+        if message:
+            payload["message"] = message
 
-        return f"event: {self.event}\ndata: {json.dumps(self.data)}\n\n"
+        return cls(event=event_type.value, data=payload)
 
 
 class ValidationResult(BaseModel):
@@ -284,57 +174,24 @@ class TrainingResult(BaseModel):
 BotFiles = Dict[str, Optional[str]]
 
 
-class Document(BaseModel):
-    """Model for document retrieval results."""
+class JobStatus(str, Enum):
+    received = "received"
+    done = "done"
+    error = "error"
 
-    content: str = Field(...)
-    url: Optional[str] = Field(None)
-    title: Optional[str] = Field(None)
-    metadata: Optional[Dict[str, Any]] = Field(None)
+    generating = "generating"
+    generation_success = "generation_success"
+    generation_error = "generation_error"
 
-    @classmethod
-    def from_inkeep_rag_response(cls, rag_item: Dict[str, Any]) -> "Document":
-        """Create a Document object from a single InKeep RAG response item.
+    training = "training"
+    train_success = "train_success"
+    train_error = "train_error"
 
-        Args:
-            rag_item: Single item from InKeep RAG response
+    validating = "validating"
+    validation_success = "validation_success"
+    validation_error = "validation_error"
 
-        Returns:
-            Document object with extracted content and metadata
-        """
-        source = rag_item.get("source", {})
-        text_content = cls._extract_text_from_source(source)
-
-        return cls(
-            content=text_content.strip() if text_content else "",
-            url=rag_item.get("url"),
-            title=rag_item.get("title"),
-            metadata={
-                "type": rag_item.get("type"),
-                "record_type": rag_item.get("record_type"),
-                "context": rag_item.get("context"),
-                "media_type": source.get("media_type"),
-            },
-        )
 
-    @staticmethod
-    def _extract_text_from_source(source: Dict[str, Any]) -> str:
-        """Extract text content from InKeep source object.
-
-        Args:
-            source: Source object from InKeep RAG response
-
-        Returns:
-            Extracted text content
-        """
-        # Try to extract from content array first
-        if "content" in source:
-            text_parts = []
-            for content_item in source["content"]:
-                if content_item.get("type") == "text" and content_item.get("text"):
-                    text_parts.append(content_item["text"])
-            if text_parts:
-                return "\n".join(text_parts)
-
-        # Fallback to source data
-        return source.get("data", "")
+class JobCreateResponse(BaseModel):
+    job_id: str = Field(...)
+    status: JobStatus = JobStatus.received

rasa/builder/project_generator.py

@@ -3,15 +3,21 @@
 import json
 import os
 import shutil
+import tarfile
+import tempfile
 from pathlib import Path
 from textwrap import dedent
 from typing import Any, Dict, List, Optional
 
+import aiofiles
+import aiohttp
 import structlog
 
+import rasa.version
 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.logging_utils import capture_exception_with_context
 from rasa.builder.models import BotFiles
 from rasa.builder.validation_service import validate_project
 from rasa.cli.scaffold import ProjectTemplateName, create_initial_project
@@ -35,10 +41,11 @@ class ProjectGenerator:
         self.project_folder = Path(project_folder)
         self.project_folder.mkdir(parents=True, exist_ok=True)
 
-    def init_from_template(self, template: ProjectTemplateName) -> None:
+    async def init_from_template(self, template: ProjectTemplateName) -> None:
         """Create the initial project files."""
         self.cleanup()
         create_initial_project(self.project_folder.as_posix(), template)
+        await download_cache_for_template(template, self.project_folder.as_posix())
 
     async def generate_project_with_retries(
         self,
@@ -63,7 +70,7 @@ class ProjectGenerator:
         if max_retries is None:
             max_retries = config.MAX_RETRIES
 
-        self.init_from_template(template)
+        await self.init_from_template(template)
 
         project_data = self._get_bot_data_for_llm()
 
@@ -168,11 +175,9 @@ class ProjectGenerator:
                 domain_path = self.project_folder / "domain"
 
             return TrainingDataImporter.load_from_config(
-                config_path=self.project_folder / "config.yml",
-                domain_path=domain_path,
-                training_data_paths=[
-                    self.project_folder / "data",
-                ],
+                config_path=str(self.project_folder / "config.yml"),
+                domain_path=str(domain_path),
+                training_data_paths=[str(self.project_folder / "data")],
                 args={},
             )
 
@@ -280,3 +285,82 @@ class ProjectGenerator:
                     error=str(e),
                     file_path=file_path,
                 )
+
+
+CACHE_BUCKET_URL = "https://trained-templates.s3.us-east-1.amazonaws.com"
+
+
+async def download_cache_for_template(
+    template: ProjectTemplateName, project_folder: str
+) -> None:
+    # get a temp path for the cache file download
+    temporary_cache_file = tempfile.NamedTemporaryFile(suffix=".tar.gz", delete=False)
+
+    try:
+        url = f"{CACHE_BUCKET_URL}/{rasa.version.__version__}-{template.value}.tar.gz"
+        async with aiohttp.ClientSession() as session:
+            async with session.get(url) as response:
+                response.raise_for_status()
+                async with aiofiles.open(temporary_cache_file.name, "wb") as f:
+                    async for chunk in response.content.iter_chunked(1024 * 1024):
+                        await f.write(chunk)
+
+        # extract the cache to the project folder
+        with tarfile.open(temporary_cache_file.name, "r:gz") as tar:
+            tar.extractall(path=project_folder)
+
+        structlogger.info(
+            "project_generator.download_cache_for_template.success",
+            template=template,
+            event_info=(
+                f"Downloaded cache for template, extracted to {project_folder}."
+            ),
+        )
+    except aiohttp.ClientResponseError as e:
+        if e.status == 403:
+            structlogger.debug(
+                "project_generator.download_cache_for_template.no_cache_found",
+                template=template,
+                event_info=("No cache found for template, continuing without it."),
+            )
+        else:
+            structlogger.debug(
+                "project_generator.download_cache_for_template.response_error",
+                error=str(e),
+                status=e.status,
+                template=template,
+                event_info=(
+                    "Failed to download cache for template, continuing without it."
+                ),
+            )
+            capture_exception_with_context(
+                e,
+                "project_generator.download_cache_for_template.response_error",
+                tags={"template": template.value, "status": str(e.status)},
+            )
+    except Exception as exc:
+        structlogger.debug(
+            "project_generator.download_cache_for_template.unexpected_error",
+            error=str(exc),
+            template=template,
+            event_info=(
+                "Unexpected error when downloading cache for template, "
+                "continuing without it."
+            ),
+        )
+        capture_exception_with_context(
+            exc,
+            "project_generator.download_cache_for_template.unexpected_error",
+            tags={"template": template.value},
+        )
+    finally:
+        # Clean up the temporary file
+        try:
+            Path(temporary_cache_file.name).unlink(missing_ok=True)
+        except Exception as exc:
+            structlogger.debug(
+                "project_generator.download_cache_for_template.cleanup_error",
+                error=str(exc),
+                template=template,
+                event_info=("Failed to cleanup cache for template, ignoring."),
+            )

rasa/builder/scrape_rasa_docs.py

@@ -77,7 +77,7 @@ while to_visit and pages_scraped < MAX_PAGES:
             print("⏭️ Skipped (too short)")
             continue
 
-        file_name = save_as_markdown(text)
+        file_name = save_as_markdown(text, url)
         markdown_to_url[file_name] = url
         pages_scraped += 1