rasa-pro 3.13.1a18__py3-none-any.whl → 3.13.3__py3-none-any.whl

rasa/builder/config.py

@@ -1,79 +0,0 @@
-"""Configuration module for the prompt-to-bot service."""
-
-import os
-from typing import Any, Dict
-
-import importlib_resources
-
-from rasa.constants import PACKAGE_NAME
-from rasa.shared.utils.yaml import read_yaml, read_yaml_file
-
-# OpenAI Configuration
-OPENAI_MODEL = os.getenv("OPENAI_MODEL", "gpt-4.1-2025-04-14")
-OPENAI_TEMPERATURE = float(os.getenv("OPENAI_TEMPERATURE", "0.7"))
-OPENAI_VECTOR_STORE_ID = os.getenv(
-    "OPENAI_VECTOR_STORE_ID", "vs_685123376e288191a005b6b144d3026f"
-)
-OPENAI_MAX_VECTOR_RESULTS = int(os.getenv("OPENAI_MAX_VECTOR_RESULTS", "10"))
-OPENAI_TIMEOUT = int(os.getenv("OPENAI_TIMEOUT", "30"))
-
-# Server Configuration
-BUILDER_SERVER_HOST = os.getenv("SERVER_HOST", "0.0.0.0")
-BUILDER_SERVER_PORT = int(os.getenv("SERVER_PORT", "5050"))
-MAX_RETRIES = int(os.getenv("MAX_RETRIES", "5"))
-MAX_LOG_ENTRIES = int(os.getenv("MAX_LOG_ENTRIES", "30"))
-
-# CORS Configuration
-_cors_origins_env = os.getenv("CORS_ORIGINS", "*")
-CORS_ORIGINS = _cors_origins_env.split(",") if _cors_origins_env != "*" else ["*"]
-
-# Validation Configuration
-VALIDATION_FAIL_ON_WARNINGS = (
-    os.getenv("VALIDATION_FAIL_ON_WARNINGS", "false").lower() == "true"
-)
-VALIDATION_MAX_HISTORY = None  # Could be configured if needed
-
-
-def get_default_config(assistant_id: str) -> Dict[str, Any]:
-    """Get default Rasa configuration."""
-    base_config = read_yaml_file(
-        str(
-            importlib_resources.files(PACKAGE_NAME).joinpath(
-                "cli/project_templates/default/config.yml"
-            )
-        )
-    )
-
-    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."""
-    endpoints_config = read_yaml_file(
-        str(
-            importlib_resources.files(PACKAGE_NAME).joinpath(
-                "cli/project_templates/default/endpoints.yml"
-            )
-        )
-    )
-
-    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."""
-    default_credentials_yaml = """
-    studio_chat:
-      user_message_evt: "user_message"
-      bot_message_evt: "bot_message"
-      session_persistence: true
-    """
-    return read_yaml(default_credentials_yaml)

rasa/builder/create_openai_vector_store.py

@@ -1,228 +0,0 @@
-#!/usr/bin/env python3
-"""Script to create and populate OpenAI vector store with Rasa documentation."""
-
-import json
-import sys
-from pathlib import Path
-from typing import Dict, List
-
-import openai
-import structlog
-
-structlogger = structlog.get_logger()
-
-# Configuration
-DOCS_DIR = "rasa_docs_md"
-FILE_IDS_FILE = "file_ids.json"
-MARKDOWN_TO_URL_FILE = "markdown_to_url.json"
-ASSISTANT_NAME = "Rasa Docs Assistant"
-
-
-def load_url_mapping() -> Dict[str, str]:
-    """Load the markdown filename to URL mapping."""
-    markdown_to_url_file = Path(MARKDOWN_TO_URL_FILE)
-
-    if not markdown_to_url_file.exists():
-        raise FileNotFoundError(
-            f"URL mapping file {markdown_to_url_file} not found. "
-            "Please run scrape_rasa_docs.py first."
-        )
-
-    with open(markdown_to_url_file, "r") as f:
-        return json.load(f)
-
-
-def get_markdown_files(docs_dir: str = DOCS_DIR) -> List[Path]:
-    """Get all markdown files in the docs directory."""
-    docs_path = Path(docs_dir)
-
-    if not docs_path.exists():
-        raise FileNotFoundError(f"Documentation directory {docs_dir} not found")
-
-    md_files = list(docs_path.glob("*.md"))
-    if not md_files:
-        raise FileNotFoundError(f"No markdown files found in {docs_dir}")
-
-    structlogger.info("vector_store.found_files", count=len(md_files))
-    return md_files
-
-
-def load_or_upload_files(client: openai.OpenAI) -> List[Dict[str, str]]:
-    """Load existing file IDs or upload files to OpenAI."""
-    file_ids_file = Path(FILE_IDS_FILE)
-
-    if file_ids_file.exists():
-        structlogger.info("vector_store.loading_existing_files")
-        with open(file_ids_file, "r") as f:
-            return json.load(f)
-
-    return upload_files(client)
-
-
-def upload_files(client: openai.OpenAI) -> List[Dict[str, str]]:
-    """Upload markdown files to OpenAI."""
-    structlogger.info("vector_store.uploading_files")
-
-    md_files = get_markdown_files()
-    uploaded_files = []
-
-    for md_file in md_files:
-        try:
-            with open(md_file, "rb") as f:
-                uploaded = client.files.create(file=f, purpose="assistants")
-
-            file_info = {"file_id": uploaded.id, "file_name": md_file.name}
-            uploaded_files.append(file_info)
-
-            structlogger.info(
-                "vector_store.file_uploaded",
-                file_name=md_file.name,
-                file_id=uploaded.id,
-            )
-
-        except Exception as e:
-            structlogger.error(
-                "vector_store.upload_failed", file_name=md_file.name, error=str(e)
-            )
-            raise
-
-    # Save file IDs for future use
-    with open(FILE_IDS_FILE, "w") as f:
-        json.dump(uploaded_files, f, indent=2)
-
-    structlogger.info("vector_store.upload_complete", count=len(uploaded_files))
-    return uploaded_files
-
-
-def prepare_files_with_metadata(files: List[Dict[str, str]]) -> List[Dict[str, str]]:
-    """Prepare files with URL metadata."""
-    url_mapping = load_url_mapping()
-
-    files_with_metadata = []
-    for file_info in files:
-        file_name = file_info["file_name"]
-        url = url_mapping.get(file_name, "")
-
-        if not url:
-            structlogger.warning("vector_store.missing_url", file_name=file_name)
-
-        files_with_metadata.append(
-            {"file_id": file_info["file_id"], "file_name": file_name, "url": url}
-        )
-
-    return files_with_metadata
-
-
-def create_vector_store(
-    client: openai.OpenAI, files_with_metadata: List[Dict[str, str]]
-) -> str:
-    """Create vector store and add files."""
-    try:
-        # Create vector store
-        structlogger.info("vector_store.creating")
-        vector_store = client.vector_stores.create(name=ASSISTANT_NAME)
-
-        # Add files to vector store
-        for file_meta in files_with_metadata:
-            try:
-                client.vector_stores.files.create(
-                    vector_store_id=vector_store.id,
-                    file_id=file_meta["file_id"],
-                    attributes={"url": file_meta["url"]},
-                )
-
-                structlogger.info(
-                    "vector_store.file_added",
-                    file_name=file_meta["file_name"],
-                    url=file_meta["url"],
-                )
-
-            except Exception as e:
-                structlogger.error(
-                    "vector_store.file_add_failed",
-                    file_name=file_meta["file_name"],
-                    error=str(e),
-                )
-                # Continue with other files
-
-        structlogger.info(
-            "vector_store.created",
-            vector_store_id=vector_store.id,
-            files_count=len(files_with_metadata),
-        )
-
-        return vector_store.id
-
-    except Exception as e:
-        structlogger.error("vector_store.creation_failed", error=str(e))
-        raise
-
-
-def run_vector_store_creation() -> str:
-    """Run the complete vector store creation process."""
-    client = openai.OpenAI()
-
-    try:
-        # Load or upload files
-        files = load_or_upload_files(client)
-
-        # Prepare files with metadata
-        files_with_metadata = prepare_files_with_metadata(files)
-
-        # Create vector store
-        vector_store_id = create_vector_store(client, files_with_metadata)
-
-        print("\n🎉 Vector store created successfully!")
-        print(f"Vector store ID: {vector_store_id}")
-        print(f"Files processed: {len(files_with_metadata)}")
-
-        return vector_store_id
-
-    except Exception as e:
-        structlogger.error("vector_store.process_failed", error=str(e))
-        print(f"\n❌ Vector store creation failed: {e}")
-        raise
-
-
-def setup_logging():
-    """Setup basic logging."""
-    import logging.config
-
-    logging_config = {
-        "version": 1,
-        "disable_existing_loggers": False,
-        "formatters": {
-            "standard": {"format": "%(asctime)s [%(levelname)s] %(name)s: %(message)s"},
-        },
-        "handlers": {
-            "default": {
-                "level": "INFO",
-                "formatter": "standard",
-                "class": "logging.StreamHandler",
-            },
-        },
-        "loggers": {"": {"handlers": ["default"], "level": "INFO", "propagate": False}},
-    }
-
-    logging.config.dictConfig(logging_config)
-
-
-def main():
-    """Main entry point for the script."""
-    setup_logging()
-
-    try:
-        run_vector_store_creation()
-        return 0
-
-    except KeyboardInterrupt:
-        print("\n⏹️ Process interrupted by user")
-        return 1
-
-    except Exception as e:
-        print(f"\n💥 Unexpected error: {e}")
-        return 1
-
-
-if __name__ == "__main__":
-    sys.exit(main())

rasa/builder/exceptions.py

@@ -1,55 +0,0 @@
-"""Custom exceptions for the prompt-to-bot service."""
-
-from typing import Any, 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[Any] = None):
-        super().__init__(message)
-        self.validation_logs = validation_logs
-
-
-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/inkeep-rag-response-schema.json

@@ -1,64 +0,0 @@
-{
-  "$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

@@ -1,212 +0,0 @@
-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 []