rasa-pro 3.14.0.dev7__py3-none-any.whl → 3.14.0.dev8__py3-none-any.whl

rasa/builder/document_retrieval/inkeep-rag-response-schema.json

@@ -0,0 +1,64 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "type": "object",
+  "properties": {
+    "content": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "properties": {
+          "type": {
+            "type": "string"
+          },
+          "source": {
+            "type": "object",
+            "properties": {
+              "content": {
+                "type": "array",
+                "items": {
+                  "type": "object",
+                  "properties": {
+                    "type": {
+                      "type": "string"
+                    },
+                    "media_type": {
+                      "type": "string"
+                    },
+                    "text": {
+                      "type": "string"
+                    },
+                    "data": {
+                      "type": "string"
+                    }
+                  }
+                }
+              },
+              "type": {
+                "type": "string"
+              },
+              "media_type": {
+                "type": "string"
+              },
+              "data": {
+                "type": "string"
+              }
+            }
+          },
+          "title": {
+            "type": "string"
+          },
+          "context": {
+            "type": "string"
+          },
+          "record_type": {
+            "type": "string"
+          },
+          "url": {
+            "type": "string"
+          }
+        }
+      }
+    }
+  },
+  "required": ["content"]
+} 

rasa/builder/document_retrieval/inkeep_document_retrieval.py

@@ -0,0 +1,238 @@
+import asyncio
+import json
+import os
+from contextlib import asynccontextmanager
+from typing import AsyncGenerator, List, Optional
+
+import openai
+import structlog
+from openai.types.chat import ChatCompletion
+
+from rasa.builder import config
+from rasa.builder.copilot.constants import ROLE_USER
+from rasa.builder.document_retrieval.constants import (
+    INKEEP_API_KEY_ENV_VAR,
+    INKEEP_DOCUMENT_RETRIEVAL_MODEL,
+    INKEEP_RAG_RESPONSE_SCHEMA_PATH,
+)
+from rasa.builder.document_retrieval.models import Document
+from rasa.builder.exceptions import DocumentRetrievalError
+from rasa.shared.utils.io import read_json_file
+
+structlogger = structlog.get_logger()
+
+
+class InKeepDocumentRetrieval:
+    """Handles the document retrieval from InKeep AI."""
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+    ):
+        self._rag_schema = read_json_file(INKEEP_RAG_RESPONSE_SCHEMA_PATH)
+        self._api_key = api_key or os.getenv(INKEEP_API_KEY_ENV_VAR)
+
+    @property
+    def api_key(self) -> str:
+        """Resolve the correct API key/token based on proxy usage."""
+        using_proxy = bool(config.HELLO_LLM_PROXY_BASE_URL)
+        if using_proxy:
+            if not config.RASA_PRO_LICENSE:
+                raise DocumentRetrievalError(
+                    "HELLO_LLM_PROXY_BASE_URL is set but RASA_PRO_LICENSE is missing. "
+                    "Proxy requires a Rasa Pro license token for authentication."
+                )
+            return config.RASA_PRO_LICENSE
+
+        if not self._api_key:
+            raise DocumentRetrievalError(
+                "INKEEP_API_KEY is missing. Provide it via env INKEEP_API_KEY "
+                "or pass api_key= to InKeepDocumentRetrieval."
+            )
+        return self._api_key
+
+    async def retrieve_documents(
+        self, query: str, temperature: float = 0.0, timeout: float = 30.0
+    ) -> List[Document]:
+        """Retrieve relevant documents using InKeep AI based on the given query.
+
+        Args:
+            query: The search query
+            temperature: Controls randomness in generation (0.0 for deterministic)
+            timeout: Timeout for the API call
+
+        Returns:
+            List of Document objects containing retrieved content
+
+        Raises:
+            DocumentRetrievalError: When document retrieval fails due to:
+                - Empty response from InKeep AI API
+                - OpenAI API errors (authentication, rate limiting, etc.)
+                - Request timeout
+                - Unexpected errors during API communication
+        """
+        try:
+            response = await self._call_inkeep_rag_api(
+                query=query,
+                temperature=temperature,
+                timeout=timeout,
+            )
+            documents = self._parse_documents_from_response(response)
+            return documents
+        except DocumentRetrievalError as e:
+            structlogger.error(
+                "inkeep_document_retrieval.retrieve_documents.error",
+                event_info="InKeep Document Retrieval: Error",
+                query=query,
+                error=str(e),
+            )
+            raise e
+
+    async def _call_inkeep_rag_api(
+        self, query: str, temperature: float, timeout: float
+    ) -> ChatCompletion:
+        """Call InKeep AI RAG's API endpoint and return the response content.
+
+        Args:
+            query: The search query to send to InKeep
+            temperature: Controls randomness in generation (0.0 for deterministic)
+            timeout: Timeout for the API call
+
+        Returns:
+            The response content from InKeep AI. The response is made of the retrieved
+            documents.
+
+        Raises:
+            LLMGenerationError: If the API call fails or returns invalid response
+        """
+        try:
+            async with self._get_client() as client:
+                response = await client.chat.completions.create(
+                    model=INKEEP_DOCUMENT_RETRIEVAL_MODEL,
+                    messages=[{"role": ROLE_USER, "content": query}],
+                    temperature=temperature,
+                    timeout=timeout,
+                    response_format={
+                        "type": "json_schema",
+                        "json_schema": self._rag_schema,
+                    },
+                )
+
+                if not response.choices[0].message.content:
+                    structlogger.warning(
+                        "inkeep_document_retrieval.empty_response",
+                        event_info="InKeep AI returned an empty response. ",
+                        query=query,
+                        response_content=response.choices[0].message.content,
+                    )
+                    raise DocumentRetrievalError(
+                        "InKeep Document Retrieval: Empty response"
+                    )
+
+                return response
+
+        except openai.OpenAIError as e:
+            structlogger.error(
+                "inkeep_document_retrieval.call_inkeep_rag_api.api_error",
+                event_info="InKeep Document Retrieval: API error",
+                query=query,
+                error=e,
+            )
+            raise DocumentRetrievalError(f"InKeep Document Retrieval: API error: {e}")
+        except asyncio.TimeoutError as e:
+            structlogger.error(
+                "inkeep_document_retrieval.call_inkeep_rag_api.timeout_error",
+                event_info="InKeep Document Retrieval: Timeout error",
+                query=query,
+                error=e,
+            )
+            raise DocumentRetrievalError(f"InKeep AI request timed out: {e}")
+        except Exception as e:
+            structlogger.error(
+                "inkeep_document_retrieval.call_inkeep_rag_api.error",
+                event_info="InKeep Document Retrieval: Error",
+                query=query,
+                error=e,
+            )
+            raise DocumentRetrievalError(
+                f"InKeep Document Retrieval: Unexpected error: {e}"
+            )
+
+    @asynccontextmanager
+    async def _get_client(self) -> AsyncGenerator[openai.AsyncOpenAI, None]:
+        """Get or create client that handles the API calls to InKeep AI."""
+        # Ensure trailing slash to match client expectations/tests
+        base_url = f"{config.INKEEP_BASE_URL.rstrip('/')}/"
+        client = openai.AsyncOpenAI(base_url=base_url, api_key=self.api_key)
+        structlogger.debug("inkeep_document_retrieval._get_client", base_url=base_url)
+
+        try:
+            yield client
+        except Exception as e:
+            structlogger.error(
+                "inkeep_document_retrieval.client_error",
+                event_info="InKeep Document Retrieval: Client error",
+                error=str(e),
+            )
+            raise
+
+    def _parse_documents_from_response(
+        self, response: ChatCompletion
+    ) -> List[Document]:
+        """Parse the InKeep AI response into Document objects.
+
+        Args:
+            response: ChatCompletion response from InKeep AI's RAG model.
+
+        Returns:
+            List of Document objects. Empty list is returned if the response is empty
+            or if the response is invalid.
+        """
+        try:
+            content = response.choices[0].message.content
+            if not content:
+                return []
+
+            response_data = json.loads(content)
+            documents = []
+
+            for item in response_data.get("content", []):
+                try:
+                    document = Document.from_inkeep_rag_response(item)
+                    documents.append(document)
+                except Exception as e:
+                    structlogger.warning(
+                        "inkeep_document_retrieval.invalid_document_skipped",
+                        event_info=(
+                            "InKeep Document Retrieval: Invalid document structure "
+                            "skipped. Returning empty list for this item."
+                        ),
+                        error=str(e),
+                        item=item,
+                    )
+                    # Continue processing other items, skip this invalid one
+                    continue
+
+            return documents
+
+        except json.JSONDecodeError as e:
+            structlogger.warning(
+                "inkeep_document_retrieval.parse_documents_from_response"
+                ".parse_response_failed",
+                event_info=(
+                    "InKeep Document Retrieval: Parse response failed. "
+                    "Returning empty list.",
+                ),
+                error=str(e),
+            )
+            return []
+        except Exception as e:
+            structlogger.error(
+                "inkeep_document_retrieval.parse_documents_from_response.error",
+                event_info=(
+                    "InKeep Document Retrieval: Parse response error. "
+                    "Returning empty list.",
+                ),
+                error=str(e),
+            )
+            return []

rasa/builder/document_retrieval/models.py

@@ -0,0 +1,62 @@
+from typing import Any, Dict, Optional
+
+import structlog
+from pydantic import BaseModel, Field
+
+structlogger = structlog.get_logger()
+
+
+class Document(BaseModel):
+    """Model for document retrieval results."""
+
+    content: str = Field(...)
+    url: Optional[str] = Field(default=None)
+    title: Optional[str] = Field(default=None)
+    metadata: Optional[Dict[str, Any]] = Field(default=None)
+
+    @classmethod
+    def from_inkeep_rag_response(cls, rag_item: Dict[str, Any]) -> "Document":
+        """Create a Document object from a single InKeep RAG response item.
+
+        Args:
+            rag_item: Single item from InKeep RAG response
+
+        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", "")

rasa/builder/download.py

@@ -0,0 +1,140 @@
+"""Download utilities for bot projects."""
+
+import io
+import os
+import sys
+import tarfile
+from textwrap import dedent
+from typing import Dict, Optional
+
+
+def _get_env_content() -> str:
+    """Generate .env file content."""
+    return f"RASA_PRO_LICENSE={os.getenv('RASA_PRO_LICENSE')}\n"
+
+
+def _get_python_version_content() -> str:
+    """Generate .python-version file content with current Python version."""
+    return f"{sys.version_info.major}.{sys.version_info.minor}\n"
+
+
+def _get_pyproject_toml_content(project_id: str) -> str:
+    """Generate pyproject.toml file content."""
+    return dedent(
+        f"""
+        [project]
+        name = "{project_id}"
+        version = "0.1.0"
+        description = "Add your description for your Rasa bot here"
+        readme = "README.md"
+        dependencies = ["rasa-pro>=3.13"]
+        requires-python = ">={sys.version_info.major}.{sys.version_info.minor}"
+        """
+    )
+
+
+def _get_readme_content() -> str:
+    """Generate README.md file content with basic instructions."""
+    return dedent(
+        """
+        # Rasa Assistant
+
+        This is your Rasa assistant project. Below are the basic commands to
+        get started.
+
+        ## Prerequisites
+        Make sure you have [uv](https://docs.astral.sh/uv/) installed.
+
+        ## Training the Assistant
+
+        To train your assistant with the current configuration and training data:
+
+        ```bash
+        uv run rasa train
+        ```
+
+        This will create a model in the `models/` directory.
+
+        ## Testing the Assistant
+
+        To test your assistant interactively in the command line:
+
+        ```bash
+        uv run rasa inspect
+        ```
+
+        ## Running the Assistant
+
+        To start the Rasa server:
+
+        ```bash
+        uv run rasa run
+        ```
+
+        The server will be available at `http://localhost:5005`.
+
+        ## Project Structure
+
+        - `config.yml` - Configuration for your NLU pipeline and policies
+        - `domain.yml` - Defines intents, entities, slots, responses, and actions
+        - `data/` - Flows of your bot
+        - `actions/` - Custom action code (if any)
+
+        ## Next Steps
+
+        1. Customize your domain and flows
+        2. Train your model with `rasa train`
+        3. Test your assistant with `rasa inspect`
+        4. Deploy your assistant with `rasa run`
+
+        For more information, visit the [Rasa documentation](https://rasa.com/docs/).
+        """
+    )
+
+
+def _add_file_to_tar(tar: tarfile.TarFile, filename: str, content: str) -> None:
+    """Add a file with the given content to the tar archive.
+
+    Args:
+        tar: The tar file object to add to
+        filename: Name of the file in the archive
+        content: Content of the file as a string
+    """
+    file_data = content.encode("utf-8")
+    tarinfo = tarfile.TarInfo(name=filename)
+    tarinfo.size = len(file_data)
+    tar.addfile(tarinfo, io.BytesIO(file_data))
+
+
+def create_bot_project_archive(
+    bot_files: Dict[str, Optional[str]], project_id: str
+) -> bytes:
+    """Create a tar.gz archive containing bot files and additional project files.
+
+    Args:
+        bot_files: Dictionary mapping file names to their content
+        project_id: Name of the project for the archive filename and pyproject.toml
+
+    Returns:
+        bytes: The tar.gz archive data
+    """
+    tar_buffer = io.BytesIO()
+
+    with tarfile.open(fileobj=tar_buffer, mode="w:gz") as tar:
+        # Add bot files to archive
+        for filename, content in bot_files.items():
+            if content is not None:
+                _add_file_to_tar(tar, filename, content)
+
+        # Add additional project files
+        _add_file_to_tar(tar, ".env", _get_env_content())
+        _add_file_to_tar(tar, ".python-version", _get_python_version_content())
+        _add_file_to_tar(
+            tar,
+            "pyproject.toml",
+            _get_pyproject_toml_content(project_id),
+        )
+        _add_file_to_tar(tar, "README.md", _get_readme_content())
+
+    tar_buffer.seek(0)
+    return tar_buffer.getvalue()

rasa/builder/exceptions.py

@@ -0,0 +1,91 @@
+"""Custom exceptions for the prompt-to-bot service."""
+
+from typing import Any, Dict, List, Optional
+
+
+class PromptToBotError(Exception):
+    """Base exception for prompt-to-bot service."""
+
+    pass
+
+
+class ValidationError(PromptToBotError):
+    """Raised when Rasa project validation fails."""
+
+    def __init__(
+        self, message: str, validation_logs: Optional[List[Dict[str, Any]]] = None
+    ):
+        super().__init__(message)
+        self.validation_logs = validation_logs or []
+
+    def get_logs(self, log_levels: Optional[List[str]]) -> List[Dict[str, Any]]:
+        """Get logs filtered by given log levels."""
+        if len(self.validation_logs) == 0:
+            return []
+
+        error_log_entries: List[Dict[str, Any]] = []
+        for log_entry in self.validation_logs:
+            if log_levels is not None and log_entry.get("log_level") in log_levels:
+                error_log_entries.append(log_entry)
+
+        return error_log_entries
+
+    def get_error_message_with_logs(
+        self, log_levels: Optional[List[str]] = None
+    ) -> str:
+        """Get the error message with validation logs for specified log levels.
+
+        Args:
+            log_levels: List of log levels to include. If None, includes all logs.
+
+        Returns:
+            Error message with validation logs appended.
+        """
+        error_message = str(self)
+
+        # Include all logs when no specific levels are specified
+        logs = self.validation_logs if log_levels is None else self.get_logs(log_levels)
+
+        if logs:
+            logs_text = "\n".join([str(log) for log in logs])
+            error_message += f"\n\nValidation Logs:\n{logs_text}\n"
+
+        return error_message
+
+
+class TrainingError(PromptToBotError):
+    """Raised when model training fails."""
+
+    pass
+
+
+class LLMGenerationError(PromptToBotError):
+    """Raised when LLM generation fails."""
+
+    pass
+
+
+class DocumentRetrievalError(PromptToBotError):
+    """Raised when document retrieval fails."""
+
+    pass
+
+
+class SchemaValidationError(PromptToBotError):
+    """Raised when schema validation fails."""
+
+    pass
+
+
+class AgentLoadError(PromptToBotError):
+    """Raised when agent loading fails."""
+
+    pass
+
+
+class ProjectGenerationError(PromptToBotError):
+    """Raised when project generation fails after retries."""
+
+    def __init__(self, message: str, attempts: int):
+        super().__init__(f"{message} (failed after {attempts} attempts)")
+        self.attempts = attempts

rasa/builder/guardrails/__init__.py

@@ -0,0 +1 @@
+

rasa/builder/guardrails/constants.py

@@ -0,0 +1,9 @@
+from typing import Literal
+
+LAKERA_API_KEY_ENV_VAR = "LAKERA_API_KEY"
+LAKERA_GUARD_ENDPOINT = "guard"
+LAKERA_GUARD_RESULTS_ENDPOINT = "guard/results"
+
+BLOCK_SCOPE_USER: Literal["user"] = "user"
+BLOCK_SCOPE_PROJECT: Literal["project"] = "project"
+BlockScope = Literal["user", "project"]

rasa/builder/guardrails/exceptions.py

@@ -0,0 +1,4 @@
+class GuardrailsError(Exception):
+    """Raised when a guardrails error occurs."""
+
+    pass