rasa-pro 3.13.1a14__py3-none-any.whl → 3.13.1a16__py3-none-any.whl

rasa/builder/config.py

@@ -43,13 +43,18 @@ def get_default_config(assistant_id: str) -> Dict[str, Any]:
             )
         )
     )
+
+    if not isinstance(base_config, dict):
+        raise ValueError("Base config is not a dictionary")
+
     base_config["assistant_id"] = assistant_id
+
     return base_config
 
 
 def get_default_endpoints() -> Dict[str, Any]:
     """Get default endpoints configuration."""
-    return read_yaml_file(
+    endpoints_config = read_yaml_file(
         str(
             importlib_resources.files(PACKAGE_NAME).joinpath(
                 "cli/project_templates/default/endpoints.yml"
@@ -57,6 +62,11 @@ def get_default_endpoints() -> Dict[str, Any]:
         )
     )
 
+    if not isinstance(endpoints_config, dict):
+        raise ValueError("Endpoints config is not a dictionary")
+
+    return endpoints_config
+
 
 def get_default_credentials() -> Dict[str, Any]:
     """Get default credentials configuration."""

rasa/builder/exceptions.py

@@ -29,6 +29,12 @@ class LLMGenerationError(PromptToBotError):
     pass
 
 
+class DocumentRetrievalError(PromptToBotError):
+    """Raised when document retrieval fails."""
+
+    pass
+
+
 class SchemaValidationError(PromptToBotError):
     """Raised when schema validation fails."""
 

rasa/builder/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/inkeep_document_retrieval.py

@@ -0,0 +1,212 @@
+import asyncio
+import json
+import os
+from contextlib import asynccontextmanager
+from typing import List, Optional
+
+import importlib_resources
+import openai
+import structlog
+from openai.types.chat import ChatCompletion
+
+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()
+
+
+class InKeepDocumentRetrieval:
+    """Handles the document retrieval from InKeep AI."""
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+    ):
+        self._client: Optional[openai.AsyncOpenAI] = 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)
+
+    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:
+            LLMGenerationError: If the API call fails or returns invalid response
+        """
+        response = await self._call_inkeep_rag_api(
+            query=query,
+            temperature=temperature,
+            timeout=timeout,
+        )
+        documents = self._parse_documents_from_response(response)
+        return documents
+
+    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
+        """
+        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)
+
+                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,
+                        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.api_error",
+                event_info="InKeep Document Retrieval: API error",
+                request_params=request_params,
+                error=e,
+            )
+            raise DocumentRetrievalError(f"InKeep Document Retrieval: API error: {e}")
+        except asyncio.TimeoutError as e:
+            structlogger.error(
+                "inkeep_document_retrieval.timeout_error",
+                event_info="InKeep Document Retrieval: Timeout error",
+                request_params=request_params,
+                error=e,
+            )
+            raise DocumentRetrievalError(f"InKeep AI request timed out: {e}")
+        except Exception as e:
+            structlogger.error(
+                "inkeep_document_retrieval.error",
+                event_info="InKeep Document Retrieval: Error",
+                request_params=request_params,
+                error=e,
+            )
+            raise DocumentRetrievalError(
+                f"InKeep Document Retrieval: Unexpected error: {e}"
+            )
+
+    @asynccontextmanager
+    async def _get_client(self):
+        """Get or create client that handles the API calls to InKeep AI."""
+        if self._client is None:
+            self._client = openai.AsyncOpenAI(
+                api_key=self._api_key,
+                base_url=INKEEP_BASE_URL,
+            )
+
+        try:
+            yield self._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
+        """
+        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_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_response_error",
+                event_info=(
+                    "InKeep Document Retrieval: Parse response error. "
+                    "Returning empty list.",
+                ),
+                error=str(e),
+            )
+            return []

rasa/builder/llm_service.py

@@ -5,17 +5,19 @@ import importlib
 import json
 from contextlib import asynccontextmanager
 from copy import deepcopy
-from typing import Any, Dict, List, Optional
+from typing import Any, AsyncGenerator, Dict, List, Optional
 
 import importlib_resources
 import openai
 import structlog
 from jinja2 import Template
+from pydantic import ValidationError
 
 from rasa.builder import config
 from rasa.builder.exceptions import LLMGenerationError
+from rasa.builder.inkeep_document_retrieval import InKeepDocumentRetrieval
 from rasa.builder.llm_context import tracker_as_llm_context
-from rasa.builder.models import LLMBuilderContext
+from rasa.builder.models import Document, LLMBuilderContext, LLMHelperResponse
 from rasa.constants import PACKAGE_NAME
 from rasa.shared.constants import DOMAIN_SCHEMA_FILE, RESPONSES_SCHEMA_FILE
 from rasa.shared.core.flows.yaml_flows_io import FLOWS_SCHEMA_FILE
@@ -28,14 +30,14 @@ structlogger = structlog.get_logger()
 class LLMService:
     """Handles OpenAI LLM interactions with caching for efficiency."""
 
-    def __init__(self):
+    def __init__(self) -> None:
         self._client: Optional[openai.AsyncOpenAI] = None
         self._domain_schema: Optional[Dict[str, Any]] = None
         self._flows_schema: Optional[Dict[str, Any]] = None
         self._helper_schema: Optional[Dict[str, Any]] = None
 
     @asynccontextmanager
-    async def _get_client(self):
+    async def _get_client(self) -> AsyncGenerator[openai.AsyncOpenAI, None]:
         """Get or create OpenAI client with proper resource management."""
         if self._client is None:
             self._client = openai.AsyncOpenAI(timeout=config.OPENAI_TIMEOUT)
@@ -46,7 +48,7 @@ class LLMService:
             structlogger.error("llm.client_error", error=str(e))
             raise
 
-    def _prepare_schemas(self):
+    def _prepare_schemas(self) -> None:
         """Prepare and cache schemas for LLM generation."""
         if self._domain_schema is None:
             self._domain_schema = _prepare_domain_schema()
@@ -135,7 +137,7 @@ class LLMService:
 
     async def generate_helper_response(
         self, messages: List[Dict[str, Any]]
-    ) -> Dict[str, Any]:
+    ) -> LLMHelperResponse:
         """Generate helper response using OpenAI."""
         self._prepare_schemas()
 
@@ -158,9 +160,11 @@ class LLMService:
                     raise LLMGenerationError("Empty response from LLM helper")
 
                 try:
-                    return json.loads(content)
+                    return LLMHelperResponse.model_validate_json(json.loads(content))
                 except json.JSONDecodeError as e:
                     raise LLMGenerationError(f"Invalid JSON from LLM helper: {e}")
+                except ValidationError as e:
+                    raise LLMGenerationError(f"Invalid JSON from LLM helper: {e}")
 
         except openai.OpenAIError as e:
             raise LLMGenerationError(f"OpenAI API error in helper: {e}")
@@ -169,30 +173,14 @@ class LLMService:
 
     async def search_documentation(
         self, query: str, max_results: Optional[int] = None
-    ) -> List[Dict[str, Any]]:
+    ) -> List[Document]:
         """Search documentation using OpenAI vector store."""
-        if max_results is None:
-            max_results = config.OPENAI_MAX_VECTOR_RESULTS
-
-        try:
-            async with self._get_client() as client:
-                results = await client.vector_stores.search(
-                    vector_store_id=config.OPENAI_VECTOR_STORE_ID,
-                    query=query,
-                    max_num_results=max_results,
-                    rewrite_query=True,
-                )
-
-                return results.data
-
-        except openai.OpenAIError as e:
-            structlogger.warning(
-                "llm.documentation_search_failed", error=str(e), query=query
-            )
-            return []
+        inkeep_document_retrieval = InKeepDocumentRetrieval()
+        documents = await inkeep_document_retrieval.retrieve_documents(query)
+        return documents
 
     @staticmethod
-    def _format_chat_dump(messages) -> str:
+    def _format_chat_dump(messages: List[Dict[str, Any]]) -> str:
         """Format chat messages for documentation search."""
         result = ""
         for message in messages:
@@ -213,16 +201,15 @@ class LLMService:
         return result
 
     @staticmethod
-    def _format_documentation_results(results) -> str:
+    def _format_documentation_results(results: List[Document]) -> str:
         """Format documentation search results."""
         if not results:
             return "<sources>No relevant documentation found.</sources>"
 
         formatted_results = ""
         for result in results:
-            formatted_result = f"<result url='{result.attributes.get('url', '')}'>"
-            for part in result.content:
-                formatted_result += f"<content>{part.text}</content>"
+            formatted_result = f"<result url='{result.url}'>"
+            formatted_result += f"<content>{result.content}</content>"
             formatted_results += formatted_result + "</result>"
 
         return f"<sources>{formatted_results}</sources>"
@@ -233,6 +220,9 @@ def _prepare_domain_schema() -> Dict[str, Any]:
     """Prepare domain schema by removing unnecessary parts."""
     domain_schema = deepcopy(read_schema_file(DOMAIN_SCHEMA_FILE, PACKAGE_NAME, False))
 
+    if not isinstance(domain_schema, dict):
+        raise ValueError("Domain schema is not a dictionary")
+
     # Remove parts not needed for CALM bots
     unnecessary_keys = ["intents", "entities", "forms", "config", "session_config"]
 

rasa/builder/main.py

@@ -5,13 +5,23 @@ import logging
 import sys
 from typing import Optional
 
+import structlog
+from sanic import HTTPResponse, Sanic
+from sanic.request import Request
+from sanic_openapi import openapi3_blueprint
+
 import rasa.core.utils
+from rasa.builder import config
 from rasa.builder.logging_utils import collecting_logs_processor
-from rasa.builder.service import BotBuilderService
+from rasa.builder.service import bp, setup_project_generator
+from rasa.core.channels.studio_chat import StudioChatInput
+from rasa.server import configure_cors
 from rasa.utils.common import configure_logging_and_warnings
 from rasa.utils.log_utils import configure_structlog
 from rasa.utils.sanic_error_handler import register_custom_sanic_error_handler
 
+structlogger = structlog.get_logger()
+
 
 def setup_logging() -> None:
     """Setup logging configuration."""
@@ -31,22 +41,98 @@ def setup_logging() -> None:
     )
 
 
+def setup_input_channel() -> StudioChatInput:
+    """Setup the input channel for chat interactions."""
+    studio_chat_credentials = config.get_default_credentials().get(
+        StudioChatInput.name()
+    )
+    return StudioChatInput.from_credentials(credentials=studio_chat_credentials)
+
+
+def setup_middleware(app: Sanic) -> None:
+    """Setup middleware for request/response processing."""
+
+    @app.middleware("request")
+    async def log_request(request: Request) -> None:
+        structlogger.info(
+            "request.received",
+            method=request.method,
+            path=request.path,
+            remote_addr=request.remote_addr or "unknown",
+        )
+
+    @app.middleware("response")
+    async def log_response(request: Request, response: HTTPResponse) -> None:
+        structlogger.info(
+            "request.completed",
+            method=request.method,
+            path=request.path,
+            status=response.status,
+        )
+
+
+def create_app(project_folder: Optional[str] = None) -> Sanic:
+    """Create and configure the Sanic app."""
+    app = Sanic("BotBuilderService")
+
+    # Basic app configuration
+    app.config.REQUEST_TIMEOUT = 60  # 1 minute timeout
+    app.ctx.agent = None
+
+    # Set up project generator and store in app context
+    app.ctx.project_generator = setup_project_generator(project_folder)
+
+    # Set up input channel and store in app context
+    app.ctx.input_channel = setup_input_channel()
+
+    # Register the blueprint
+    app.blueprint(bp)
+
+    # OpenAPI docs
+    app.blueprint(openapi3_blueprint)
+    app.config.API_TITLE = "Bot Builder API"
+    app.config.API_VERSION = rasa.__version__
+    app.config.API_DESCRIPTION = (
+        "API for building conversational AI bots from prompts and templates. "
+        "The API allows to change the assistant and retrain it with new data."
+    )
+
+    # Setup middleware
+    setup_middleware(app)
+
+    configure_cors(app, cors_origins=config.CORS_ORIGINS)
+
+    # Register input channel webhooks
+    from rasa.core import channels
+
+    channels.channel.register([app.ctx.input_channel], app, route="/webhooks/")
+
+    return app
+
+
 def main(project_folder: Optional[str] = None) -> None:
     """Main entry point."""
     try:
         # Setup logging
         setup_logging()
 
-        # Create and configure service
-
-        service = BotBuilderService(project_folder)
-        register_custom_sanic_error_handler(service.app)
-
-        # Log available routes
-        rasa.core.utils.list_routes(service.app)
+        # Create and configure app
+        app = create_app(project_folder)
+        register_custom_sanic_error_handler(app)
 
         # Run the service
-        service.run()
+        structlogger.info(
+            "service.starting",
+            host=config.BUILDER_SERVER_HOST,
+            port=config.BUILDER_SERVER_PORT,
+        )
+
+        app.run(
+            host=config.BUILDER_SERVER_HOST,
+            port=config.BUILDER_SERVER_PORT,
+            legacy=True,
+            motd=False,
+        )
 
     except KeyboardInterrupt:
         print("\nService stopped by user")

rasa/builder/models.py

@@ -19,7 +19,7 @@ class PromptRequest(BaseModel):
     )
 
     @validator("prompt")
-    def validate_prompt(cls, v):
+    def validate_prompt(cls, v: str) -> str:
         if not v.strip():
             raise ValueError("Prompt cannot be empty or whitespace only")
         return v.strip()
@@ -39,7 +39,7 @@ class TemplateRequest(BaseModel):
     )
 
     @validator("template_name")
-    def validate_template_name(cls, v):
+    def validate_template_name(cls, v: Any) -> Any:
         if v not in ProjectTemplateName:
             raise ValueError(
                 f"Template name must be one of {ProjectTemplateName.supported_values()}"
@@ -129,14 +129,6 @@ class LLMHelperResponse(BaseModel):
     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."""
 
@@ -172,3 +164,62 @@ class TrainingResult(BaseModel):
     success: bool = Field(...)
     model_path: Optional[str] = Field(None)
     error: Optional[str] = Field(None)
+
+
+BotFiles = Dict[str, Optional[str]]
+
+
+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", "")