rasa-pro 3.13.0a1.dev6__py3-none-any.whl → 3.13.0a1.dev7__py3-none-any.whl

rasa/builder/llm_service.py

@@ -0,0 +1,327 @@
+"""Service for handling LLM interactions."""
+
+import asyncio
+import importlib
+import json
+from contextlib import asynccontextmanager
+from copy import deepcopy
+from typing import Any, Dict, List, Optional
+
+import importlib_resources
+import openai
+import structlog
+from jinja2 import Template
+
+from rasa.builder import config
+from rasa.builder.exceptions import LLMGenerationError
+from rasa.builder.llm_context import tracker_as_llm_context
+from rasa.builder.models import LLMBuilderContext
+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
+from rasa.shared.utils.io import read_json_file
+from rasa.shared.utils.yaml import read_schema_file
+
+structlogger = structlog.get_logger()
+
+
+class LLMService:
+    """Handles OpenAI LLM interactions with caching for efficiency."""
+
+    def __init__(self):
+        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):
+        """Get or create OpenAI client with proper resource management."""
+        if self._client is None:
+            self._client = openai.AsyncOpenAI(timeout=config.OPENAI_TIMEOUT)
+
+        try:
+            yield self._client
+        except Exception as e:
+            structlogger.error("llm.client_error", error=str(e))
+            raise
+
+    def _prepare_schemas(self):
+        """Prepare and cache schemas for LLM generation."""
+        if self._domain_schema is None:
+            self._domain_schema = _prepare_domain_schema()
+
+        if self._flows_schema is None:
+            self._flows_schema = _prepare_flows_schema()
+
+        if self._helper_schema is None:
+            self._helper_schema = _load_helper_schema()
+
+    async def generate_rasa_project(
+        self, messages: List[Dict[str, Any]]
+    ) -> Dict[str, Any]:
+        """Generate Rasa project data using OpenAI."""
+        self._prepare_schemas()
+
+        try:
+            async with self._get_client() as client:
+                response = await client.chat.completions.create(
+                    model=config.OPENAI_MODEL,
+                    messages=messages,
+                    temperature=config.OPENAI_TEMPERATURE,
+                    response_format={
+                        "type": "json_schema",
+                        "json_schema": {
+                            "name": "rasa_project",
+                            "schema": {
+                                "type": "object",
+                                "properties": {
+                                    "domain": self._domain_schema,
+                                    "flows": self._flows_schema,
+                                },
+                                "required": ["domain", "flows"],
+                            },
+                        },
+                    },
+                )
+
+                content = response.choices[0].message.content
+                if not content:
+                    raise LLMGenerationError("Empty response from LLM")
+
+                try:
+                    return json.loads(content)
+                except json.JSONDecodeError as e:
+                    raise LLMGenerationError(f"Invalid JSON from LLM: {e}")
+
+        except openai.OpenAIError as e:
+            raise LLMGenerationError(f"OpenAI API error: {e}")
+        except asyncio.TimeoutError:
+            raise LLMGenerationError("LLM request timed out")
+
+    async def create_helper_messages(
+        self, llm_builder_context: LLMBuilderContext
+    ) -> List[Dict[str, Any]]:
+        """Create helper messages for LLM builder."""
+        # Format chat history for documentation search
+        chat_dump = self._format_chat_dump(llm_builder_context.chat_history)
+
+        # Search documentation
+        documentation_results = await self.search_documentation(chat_dump)
+        formatted_docs = self._format_documentation_results(documentation_results)
+
+        current_conversation = tracker_as_llm_context(llm_builder_context.tracker)
+
+        # Prepare LLM messages
+        system_messages = get_helper_messages(
+            current_conversation,
+            llm_builder_context.bot_logs,
+            llm_builder_context.chat_bot_files,
+            formatted_docs,
+        )
+
+        # Add user messages
+        messages = system_messages.copy()
+        for msg in llm_builder_context.chat_history:
+            messages.append(
+                {
+                    "role": "user" if msg.type == "user" else "assistant",
+                    "content": json.dumps(msg.content)
+                    if isinstance(msg.content, list)
+                    else msg.content,
+                }
+            )
+        return messages
+
+    async def generate_helper_response(
+        self, messages: List[Dict[str, Any]]
+    ) -> Dict[str, Any]:
+        """Generate helper response using OpenAI."""
+        self._prepare_schemas()
+
+        try:
+            async with self._get_client() as client:
+                response = await client.chat.completions.create(
+                    model=config.OPENAI_MODEL,
+                    messages=messages,
+                    response_format={
+                        "type": "json_schema",
+                        "json_schema": {
+                            "name": "llm_helper",
+                            "schema": self._helper_schema,
+                        },
+                    },
+                )
+
+                content = response.choices[0].message.content
+                if not content:
+                    raise LLMGenerationError("Empty response from LLM helper")
+
+                try:
+                    return json.loads(content)
+                except json.JSONDecodeError 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}")
+        except asyncio.TimeoutError:
+            raise LLMGenerationError("LLM helper request timed out")
+
+    async def search_documentation(
+        self, query: str, max_results: Optional[int] = None
+    ) -> List[Dict[str, Any]]:
+        """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 []
+
+    @staticmethod
+    def _format_chat_dump(messages) -> str:
+        """Format chat messages for documentation search."""
+        result = ""
+        for message in messages:
+            if message.type == "user":
+                content = (
+                    message.content
+                    if isinstance(message.content, str)
+                    else str(message.content)
+                )
+                result += f"User: {content}\n"
+            else:
+                if isinstance(message.content, list):
+                    for part in message.content:
+                        if part.get("type") == "text":
+                            result += f"Assistant: {part.get('text')}\n"
+                else:
+                    result += f"Assistant: {message.content}\n"
+        return result
+
+    @staticmethod
+    def _format_documentation_results(results) -> 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_results += formatted_result + "</result>"
+
+        return f"<sources>{formatted_results}</sources>"
+
+
+# Schema preparation functions (stateless)
+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))
+
+    # Remove parts not needed for CALM bots
+    unnecessary_keys = ["intents", "entities", "forms", "config", "session_config"]
+
+    for key in unnecessary_keys:
+        domain_schema["mapping"].pop(key, None)
+
+    # Remove problematic slot mappings
+    slot_mapping = domain_schema["mapping"]["slots"]["mapping"]["regex;([A-Za-z]+)"][
+        "mapping"
+    ]
+    slot_mapping.pop("mappings", None)
+    slot_mapping.pop("validation", None)
+
+    # Add responses schema
+    domain_schema["mapping"]["responses"] = read_schema_file(
+        RESPONSES_SCHEMA_FILE, PACKAGE_NAME, False
+    )["schema;responses"]
+
+    return domain_schema
+
+
+def _prepare_flows_schema() -> Dict[str, Any]:
+    """Prepare flows schema by removing nlu_trigger."""
+    schema_file = str(
+        importlib_resources.files(PACKAGE_NAME).joinpath(FLOWS_SCHEMA_FILE)
+    )
+    flows_schema = deepcopy(read_json_file(schema_file))
+    flows_schema["$defs"]["flow"]["properties"].pop("nlu_trigger", None)
+    return flows_schema
+
+
+def _load_helper_schema() -> Dict[str, Any]:
+    """Load helper schema."""
+    return read_json_file(
+        importlib_resources.files(PACKAGE_NAME).joinpath(
+            "builder/llm-helper-schema.json"
+        )
+    )
+
+
+# Template functions (stateless with caching)
+_skill_template: Optional[Template] = None
+_helper_template: Optional[Template] = None
+
+
+def get_skill_generation_messages(
+    skill_description: str, project_data: Dict[str, str]
+) -> List[Dict[str, Any]]:
+    """Get messages for skill generation."""
+    global _skill_template
+
+    if _skill_template is None:
+        template_content = importlib.resources.read_text(
+            "rasa.builder",
+            "skill_to_bot_prompt.jinja2",
+        )
+        _skill_template = Template(template_content)
+
+    system_prompt = _skill_template.render(
+        skill_description=skill_description,
+        project_data=project_data,
+    )
+    return [{"role": "system", "content": system_prompt}]
+
+
+def get_helper_messages(
+    current_conversation: str,
+    bot_logs: str,
+    chat_bot_files: Dict[str, str],
+    documentation_results: str,
+) -> List[Dict[str, Any]]:
+    """Get messages for helper response."""
+    global _helper_template
+
+    if _helper_template is None:
+        template_content = importlib.resources.read_text(
+            "rasa.builder",
+            "llm_helper_prompt.jinja2",
+        )
+        _helper_template = Template(template_content)
+
+    system_prompt = _helper_template.render(
+        current_conversation=current_conversation,
+        bot_logs=bot_logs,
+        chat_bot_files=chat_bot_files,
+        documentation_results=documentation_results,
+    )
+    return [{"role": "system", "content": system_prompt}]
+
+
+# Global service instance
+llm_service = LLMService()

rasa/builder/logging_utils.py

@@ -0,0 +1,51 @@
+"""Logging utilities for the prompt-to-bot service."""
+
+import collections
+import logging
+import threading
+from typing import Any, Deque, Dict
+
+from rasa.builder import config
+
+# Thread-safe deque for collecting recent logs
+_recent_logs: Deque[str] = collections.deque(maxlen=config.MAX_LOG_ENTRIES)
+_logs_lock = threading.RLock()
+
+
+def collecting_logs_processor(
+    logger: Any, log_level: str, event_dict: Dict[str, Any]
+) -> Dict[str, Any]:
+    """Structlog processor that collects recent log entries.
+
+    This processor is thread-safe and maintains a rolling buffer of recent logs.
+    """
+    if log_level != logging.getLevelName(logging.DEBUG).lower():
+        event_message = event_dict.get("event_info") or event_dict.get("event", "")
+        log_entry = f"[{log_level}] {event_message}"
+
+        with _logs_lock:
+            _recent_logs.append(log_entry)
+
+    return event_dict
+
+
+def get_recent_logs() -> str:
+    """Get recent log entries as a formatted string.
+
+    Returns:
+        Formatted string of recent log entries, one per line.
+    """
+    with _logs_lock:
+        return "\n".join(list(_recent_logs))
+
+
+def clear_recent_logs() -> None:
+    """Clear the recent logs buffer."""
+    with _logs_lock:
+        _recent_logs.clear()
+
+
+def get_log_count() -> int:
+    """Get the current number of log entries."""
+    with _logs_lock:
+        return len(_recent_logs)

rasa/builder/main.py

@@ -0,0 +1,61 @@
+#!/usr/bin/env python3
+"""Main entry point for the prompt-to-bot service."""
+
+import logging
+import sys
+from typing import Optional
+
+import rasa.core.utils
+from rasa.builder.logging_utils import collecting_logs_processor
+from rasa.builder.service import PromptToBotService
+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
+
+
+def setup_logging():
+    """Setup logging configuration."""
+    log_level = logging.DEBUG
+
+    configure_logging_and_warnings(
+        log_level=log_level,
+        logging_config_file=None,
+        warn_only_once=True,
+        filter_repeated_logs=True,
+    )
+
+    configure_structlog(
+        log_level,
+        include_time=True,
+        additional_processors=[collecting_logs_processor],
+    )
+
+
+def main(project_folder: Optional[str] = None):
+    """Main entry point."""
+    try:
+        # Setup logging
+        setup_logging()
+
+        # Create and configure service
+
+        service = PromptToBotService(project_folder)
+        register_custom_sanic_error_handler(service.app)
+
+        # Log available routes
+        rasa.core.utils.list_routes(service.app)
+
+        # Run the service
+        service.run()
+
+    except KeyboardInterrupt:
+        print("\nService stopped by user")
+        sys.exit(0)
+    except Exception as e:
+        print(f"Failed to start service: {e}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    project_folder = sys.argv[1] if len(sys.argv) > 1 else None
+    main(project_folder)

rasa/builder/models.py

@@ -0,0 +1,174 @@
+"""Pydantic models for request/response validation."""
+
+from typing import Any, Dict, List, Literal, Optional, Union
+
+from pydantic import BaseModel, Field, validator
+
+from rasa.cli.scaffold import ProjectTemplateName
+from rasa.shared.core.trackers import DialogueStateTracker
+
+
+class PromptRequest(BaseModel):
+    """Request model for prompt-to-bot endpoint."""
+
+    prompt: str = Field(
+        ..., min_length=1, max_length=10000, description="The skill description prompt"
+    )
+    client_id: Optional[str] = Field(
+        None, max_length=255, description="Optional client identifier"
+    )
+
+    @validator("prompt")
+    def validate_prompt(cls, v):
+        if not v.strip():
+            raise ValueError("Prompt cannot be empty or whitespace only")
+        return v.strip()
+
+
+class TemplateRequest(BaseModel):
+    """Request model for template-to-bot endpoint."""
+
+    template_name: ProjectTemplateName = Field(
+        ...,
+        description=(
+            f"The template name to use ({ProjectTemplateName.supported_values()})"
+        ),
+    )
+    client_id: Optional[str] = Field(
+        None, max_length=255, description="Optional client identifier"
+    )
+
+    @validator("template_name")
+    def validate_template_name(cls, v):
+        if v not in ProjectTemplateName:
+            raise ValueError(
+                f"Template name must be one of {ProjectTemplateName.supported_values()}"
+            )
+        return v
+
+
+class ChatMessage(BaseModel):
+    """Model for chat messages."""
+
+    type: str = Field(..., pattern="^(user|assistant)$")
+    content: Union[str, List[Dict[str, Any]]] = Field(...)
+
+
+class LLMBuilderRequest(BaseModel):
+    """Request model for LLM builder endpoint."""
+
+    messages: List[ChatMessage] = Field(..., min_items=1, max_items=50)
+
+
+class LLMBuilderContext(BaseModel):
+    """Context model for LLM builder endpoint."""
+
+    tracker: Optional[DialogueStateTracker] = Field(None)
+    bot_logs: str = Field("")
+    chat_bot_files: Dict[str, str] = Field({})
+    chat_history: List[ChatMessage] = Field([])
+
+    class Config:
+        """Config for LLMBuilderContext."""
+
+        arbitrary_types_allowed = True
+
+
+class BotDataUpdateRequest(BaseModel):
+    """Request model for bot data updates."""
+
+    domain_yml: Optional[str] = Field(None, alias="domain.yml")
+    flows_yml: Optional[str] = Field(None, alias="flows.yml")
+    config_yml: Optional[str] = Field(None, alias="config.yml")
+
+    class Config:
+        """Config for BotDataUpdateRequest."""
+
+        allow_population_by_field_name = True
+
+
+class ContentBlock(BaseModel):
+    """Base model for content blocks."""
+
+    type: str = Field(...)
+
+
+class TextBlock(ContentBlock):
+    """Text content block."""
+
+    type: Literal["text"] = "text"
+    text: str = Field(...)
+
+
+class CodeBlock(ContentBlock):
+    """Code content block."""
+
+    type: Literal["code"] = "code"
+    text: str = Field(...)
+    language: Optional[str] = Field(None)
+
+
+class FileBlock(ContentBlock):
+    """File content block."""
+
+    type: Literal["file"] = "file"
+    file: str = Field(...)
+    content: str = Field(...)
+
+
+class LinkBlock(ContentBlock):
+    """Link content block."""
+
+    type: Literal["link"] = "link"
+    text: str = Field(..., pattern=r"^https?://")
+
+
+class LLMHelperResponse(BaseModel):
+    """Response model for LLM helper."""
+
+    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."""
+
+    status: Literal["error"] = "error"
+    error: str = Field(...)
+    details: Optional[Dict[str, Any]] = Field(None)
+
+
+class ServerSentEvent(BaseModel):
+    """Server-sent event model."""
+
+    event: str = Field(...)
+    data: Dict[str, Any] = Field(...)
+
+    def format(self) -> str:
+        """Format as SSE string."""
+        import json
+
+        return f"event: {self.event}\ndata: {json.dumps(self.data)}\n\n"
+
+
+class ValidationResult(BaseModel):
+    """Result of validation operation."""
+
+    is_valid: bool = Field(...)
+    errors: Optional[List[str]] = Field(None)
+    warnings: Optional[List[str]] = Field(None)
+
+
+class TrainingResult(BaseModel):
+    """Result of training operation."""
+
+    success: bool = Field(...)
+    model_path: Optional[str] = Field(None)
+    error: Optional[str] = Field(None)