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

rasa/builder/document_retrieval/constants.py

@@ -0,0 +1,16 @@
+import importlib_resources
+
+from rasa.constants import PACKAGE_NAME
+
+INKEEP_API_KEY_ENV_VAR = "INKEEP_API_KEY"
+
+INKEEP_RAG_RESPONSE_SCHEMA_PATH = str(
+    importlib_resources.files(PACKAGE_NAME)
+    .joinpath("builder")
+    .joinpath("document_retrieval")
+    .joinpath("inkeep-rag-response-schema.json")
+)
+
+
+INKEEP_DOCUMENT_RETRIEVAL_MODEL = "inkeep-rag"
+INKEEP_BASE_URL = "https://api.inkeep.com/v1/"

rasa/builder/{inkeep_document_retrieval.py → document_retrieval/inkeep_document_retrieval.py}

@@ -2,28 +2,23 @@ import asyncio
 import json
 import os
 from contextlib import asynccontextmanager
-from typing import List, Optional
+from typing import AsyncGenerator, List, Optional
 
-import importlib_resources
 import openai
 import structlog
 from openai.types.chat import ChatCompletion
 
+from rasa.builder.copilot.constants import ROLE_USER
+from rasa.builder.document_retrieval.constants import (
+    INKEEP_API_KEY_ENV_VAR,
+    INKEEP_BASE_URL,
+    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.builder.models import Document
-from rasa.constants import PACKAGE_NAME
 from rasa.shared.utils.io import read_json_file
 
-INKEEP_API_KEY_ENV_VAR = "INKEEP_API_KEY"
-INKEEP_RAG_RESPONSE_SCHEMA_PATH = str(
-    importlib_resources.files(PACKAGE_NAME).joinpath(
-        "builder/inkeep-rag-response-schema.json"
-    )
-)
-
-INKEEP_DOCUMENT_RETRIEVAL_MODEL = "inkeep-rag"
-INKEEP_BASE_URL = "https://api.inkeep.com/v1/"
-
 structlogger = structlog.get_logger()
 
 
@@ -92,25 +87,24 @@ class InKeepDocumentRetrieval:
         Raises:
             LLMGenerationError: If the API call fails or returns invalid response
         """
-        request_params = {
-            "model": INKEEP_DOCUMENT_RETRIEVAL_MODEL,
-            "messages": [{"role": "user", "content": query}],
-            "temperature": temperature,
-            "timeout": timeout,
-            "response_format": {
-                "type": "json_schema",
-                "json_schema": self._rag_schema,
-            },
-        }
         try:
             async with self._get_client() as client:
-                response = await client.chat.completions.create(**request_params)
+                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. ",
-                        request_params=request_params,
+                        query=query,
                         response_content=response.choices[0].message.content,
                     )
                     raise DocumentRetrievalError(
@@ -123,7 +117,7 @@ class InKeepDocumentRetrieval:
             structlogger.error(
                 "inkeep_document_retrieval.call_inkeep_rag_api.api_error",
                 event_info="InKeep Document Retrieval: API error",
-                request_params=request_params,
+                query=query,
                 error=e,
             )
             raise DocumentRetrievalError(f"InKeep Document Retrieval: API error: {e}")
@@ -131,7 +125,7 @@ class InKeepDocumentRetrieval:
             structlogger.error(
                 "inkeep_document_retrieval.call_inkeep_rag_api.timeout_error",
                 event_info="InKeep Document Retrieval: Timeout error",
-                request_params=request_params,
+                query=query,
                 error=e,
             )
             raise DocumentRetrievalError(f"InKeep AI request timed out: {e}")
@@ -139,7 +133,7 @@ class InKeepDocumentRetrieval:
             structlogger.error(
                 "inkeep_document_retrieval.call_inkeep_rag_api.error",
                 event_info="InKeep Document Retrieval: Error",
-                request_params=request_params,
+                query=query,
                 error=e,
             )
             raise DocumentRetrievalError(
@@ -147,7 +141,7 @@ class InKeepDocumentRetrieval:
             )
 
     @asynccontextmanager
-    async def _get_client(self):
+    async def _get_client(self) -> AsyncGenerator[openai.AsyncOpenAI, None]:
         """Get or create client that handles the API calls to InKeep AI."""
         if self._client is None:
             self._client = openai.AsyncOpenAI(

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(None)
+    title: Optional[str] = Field(None)
+    metadata: Optional[Dict[str, Any]] = Field(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 = []
+        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/guardrails/__init__.py

@@ -0,0 +1 @@
+

rasa/builder/guardrails/constants.py

@@ -0,0 +1,4 @@
+LAKERA_API_KEY_ENV_VAR = "LAKERA_API_KEY"
+LAKERA_BASE_URL = "https://api.lakera.ai/v2"
+LAKERA_GUARD_ENDPOINT = "guard"
+LAKERA_GUARD_RESULTS_ENDPOINT = "guard/results"

rasa/builder/guardrails/exceptions.py

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

rasa/builder/guardrails/lakera.py

@@ -0,0 +1,188 @@
+"""Lakera AI guardrails provider implementation."""
+
+import asyncio
+import os
+import time
+from contextlib import asynccontextmanager
+from typing import Any, AsyncGenerator, Dict, Optional
+
+import aiohttp
+import structlog
+
+from rasa.builder.guardrails.constants import (
+    LAKERA_API_KEY_ENV_VAR,
+    LAKERA_BASE_URL,
+    LAKERA_GUARD_ENDPOINT,
+    LAKERA_GUARD_RESULTS_ENDPOINT,
+)
+from rasa.builder.guardrails.exceptions import GuardrailsError
+from rasa.builder.guardrails.models import (
+    GuardrailResponse,
+    LakeraGuardrailRequest,
+    LakeraGuardrailResponse,
+)
+
+structlogger = structlog.get_logger()
+
+
+class LakeraAIGuardrails:
+    """Guardrails provider using Lakera AI."""
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        base_url: Optional[str] = None,
+    ):
+        """Initialize Lakera guardrails provider.
+
+        Args:
+            severity_threshold: The minimum severity level for the guardrail to flag
+                the user request as unsafe.
+            api_key: Lakera AI API key.
+            base_url: Optional base URL for the API. If not provided, the default
+                Lakera API URL (https://api.lakera.ai/v2) will be used.
+        """
+        self.base_url: str = base_url or LAKERA_BASE_URL
+        self._api_key: Optional[str] = api_key or os.getenv(LAKERA_API_KEY_ENV_VAR)
+        self._session: Optional[aiohttp.ClientSession] = None
+
+    @property
+    def guard_endpoint(self) -> str:
+        """Get the guard endpoint for the Lakera API."""
+        return f"{self.base_url}/{LAKERA_GUARD_ENDPOINT}"
+
+    @property
+    def guard_results_endpoint(self) -> str:
+        """Get the guard results endpoint for the Lakera API."""
+        return f"{self.base_url}/{LAKERA_GUARD_RESULTS_ENDPOINT}"
+
+    @asynccontextmanager
+    async def _get_session(self) -> AsyncGenerator[aiohttp.ClientSession, None]:
+        """Create a fresh ClientSession, yield it, and always close it."""
+        session = aiohttp.ClientSession(headers=self._get_headers())
+        try:
+            yield session
+        except Exception as e:
+            structlogger.error("lakera_guardrails.session_error", error=str(e))
+            raise
+        finally:
+            try:
+                await session.close()
+            except Exception as exc:
+                structlogger.warning(
+                    "lakera_guardrails.session_close_error",
+                    event_info="Failed to close aiohttp client session cleanly.",
+                    error=str(exc),
+                )
+
+    def _get_headers(self) -> Dict[str, Any]:
+        """Get the headers for the Lakera API request."""
+        headers: Dict[str, Any] = {}
+        if self._api_key is not None:
+            headers["Authorization"] = f"Bearer {self._api_key}"
+        return headers
+
+    async def send_request(self, request: LakeraGuardrailRequest) -> GuardrailResponse:
+        """Send a request to the Lakera API.
+
+        Args:
+            request: The guardrail request to send to the Lakera API.
+
+        Returns:
+            GuardrailResponse with the results of the check.
+
+        Raises:
+            GuardrailsError: If the request times out or returns a non-200 status code.
+            Exception: If the request fails for any other reason.
+        """
+        start_time = time.time()
+        try:
+            async with self._get_session() as session:
+                raw_response = await self._send_http_request(session, request)
+                response = LakeraGuardrailResponse.from_raw_response(
+                    raw_response,
+                    hello_rasa_user_id=request.hello_rasa_user_id,
+                    hello_rasa_project_id=request.hello_rasa_project_id,
+                )
+                processing_time_ms = (time.time() - start_time) * 1000
+                response.processing_time_ms = processing_time_ms
+                return response
+
+        # Propagate the GuardrailsError if it occurs.
+        except GuardrailsError as e:
+            raise e
+
+        except asyncio.TimeoutError:
+            message = "Lakera API request timed out."
+            structlogger.error(
+                "lakera_guardrails.send_request.timeout_error",
+                event_info=message,
+                processing_time_ms=(time.time() - start_time) * 1000,
+            )
+            raise GuardrailsError(message)
+
+        # Propagate the unexpected exceptions.
+        except Exception as e:
+            message = "Lakera API request failed."
+            structlogger.error(
+                "lakera_guardrails.send_request.unexpected_error",
+                event_info="Lakera API request failed.",
+                request=request,
+                error=e,
+                processing_time_ms=(time.time() - start_time) * 1000,
+            )
+            raise e
+
+    async def _send_http_request(
+        self, session: aiohttp.ClientSession, request: LakeraGuardrailRequest
+    ) -> Dict[str, Any]:
+        """Make an HTTP request to the Lakera API.
+
+        Args:
+            session: The aiohttp session to use for the request.
+            request: The guardrail request to send.
+
+        Returns:
+            The raw JSON response from the API.
+
+        Raises:
+            GuardrailsError: If the request fails or response parsing fails.
+        """
+        # Log the request details for debugging
+        json_payload = request.to_json_payload()
+        structlogger.debug(
+            "lakera_guardrails.send_request.request",
+            url=self.guard_endpoint,
+            method="POST",
+            request_body=json_payload,
+        )
+
+        async with session.post(
+            self.guard_endpoint,
+            json=json_payload,
+        ) as client_response:
+            # Check if the response is successful. If not, raise an error.
+            if client_response.status >= 400:
+                error_text = await client_response.text()
+                message = (
+                    f"Lakera API request failed with status "
+                    f"`{client_response.status}`. Error: "
+                    f"`{error_text}`."
+                )
+                structlogger.error(
+                    "lakera_guardrails.send_request.http_error",
+                    event_info=message,
+                    url=self.guard_endpoint,
+                    status=client_response.status,
+                    error=error_text,
+                    request_body=json_payload,
+                )
+                raise GuardrailsError(message)
+
+            # Parse the response as a dictionary.
+            raw_response = await client_response.json()
+            structlogger.debug(
+                "lakera_guardrails.send_request.response",
+                response_body=raw_response,
+            )
+            return raw_response