rasa-pro 3.14.0.dev5__py3-none-any.whl → 3.14.0.dev6__py3-none-any.whl

rasa/builder/copilot/telemetry.py

@@ -1,195 +0,0 @@
-import datetime as dt
-import os
-import uuid
-from typing import Iterable, Optional, Sequence
-
-import structlog
-
-from rasa import telemetry
-from rasa.builder.copilot.constants import COPILOT_SEGMENT_WRITE_KEY_ENV_VAR
-from rasa.builder.copilot.copilot_response_handler import CopilotResponseHandler
-from rasa.builder.document_retrieval.models import Document
-from rasa.telemetry import (
-    SEGMENT_TRACK_ENDPOINT,
-    segment_request_payload,
-    send_segment_request,
-    with_default_context_fields,
-)
-
-structlogger = structlog.get_logger()
-
-COPILOT_USER_MESSAGE_EVENT = "copilot_user_message"
-COPILOT_BOT_MESSAGE_EVENT = "copilot_bot_message"
-
-COPILOT_SEGMENT_WRITE_KEY = os.getenv(COPILOT_SEGMENT_WRITE_KEY_ENV_VAR)
-if _SEGMENT_ON := bool(COPILOT_SEGMENT_WRITE_KEY):
-    structlogger.info("builder.telemetry.enabled")
-else:
-    structlogger.warning("builder.telemetry.disabled")
-
-
-def _track(event: str, user_id: str, properties: dict) -> None:
-    """Track an event with Segment.
-
-    Args:
-        event: The name of the event to track.
-        user_id: The ID of the user associated with the event.
-        properties: Additional properties to include with the event.
-
-    Raises:
-        Exception: If tracking fails, an exception is logged.
-    """
-    if not _SEGMENT_ON or not telemetry.is_telemetry_enabled():
-        structlogger.debug("builder.telemetry._track.disabled")
-        return
-    structlogger.debug("builder.telemetry._track.enabled")
-
-    try:
-        payload = segment_request_payload(
-            user_id, event, properties, context=with_default_context_fields()
-        )
-        structlogger.debug("builder.telemetry._track.sending", payload=payload)
-
-        send_segment_request(SEGMENT_TRACK_ENDPOINT, payload, COPILOT_SEGMENT_WRITE_KEY)
-    except Exception as e:  # skipcq:PYL-W0703
-        structlogger.warning("builder.telemetry.track_failed", error=str(e))
-
-
-class CopilotTelemetry:
-    def __init__(
-        self,
-        *,
-        project_id: str,
-        user_id: str,
-    ) -> None:
-        """Initialize Telemetry instance."""
-        self._project_id = project_id
-        self._user_id = user_id
-        # TODO Load prompt version
-        self._prompt_version = "1"
-
-    def log_user_turn(self, text: str) -> None:
-        """Track a user message in the conversation.
-
-        Args:
-            text: The text of the user message.
-        """
-        structlogger.debug("builder.telemetry.log_user_turn", text=text)
-        _track(
-            COPILOT_USER_MESSAGE_EVENT,
-            self._user_id,
-            {
-                "project_id": self._project_id,
-                "message_id": uuid.uuid4().hex,
-                "text": text,
-                "timestamp": dt.datetime.utcnow().isoformat(),
-            },
-        )
-
-    def log_copilot_turn(
-        self,
-        *,
-        text: str,
-        source_urls: Sequence[str],
-        flags: Iterable[str],
-        latency_ms: int,
-        model: str,
-        input_tokens: Optional[int] = None,
-        output_tokens: Optional[int] = None,
-        total_tokens: Optional[int] = None,
-    ) -> None:
-        """Track a copilot message in the conversation.
-
-        Args:
-            text: The text of the copilot message.
-            source_urls: URLs of the sources used to generate the response.
-            flags: Flags indicating special conditions or features.
-            latency_ms: End-to-end Copilot latency to produce this response.
-            model: The model used to generate the response.
-            input_tokens: Number of input tokens used (optional).
-            output_tokens: Number of output tokens generated (optional).
-            total_tokens: Total number of tokens used (input + output) (optional).
-        """
-        structlogger.debug("builder.telemetry.log_copilot_turn", text=text)
-        _track(
-            COPILOT_BOT_MESSAGE_EVENT,
-            self._user_id,
-            {
-                "project_id": self._project_id,
-                "message_id": uuid.uuid4().hex,
-                "text": text,
-                "prompt_version": self._prompt_version,
-                "source_urls": list(source_urls),
-                "flags": list(flags),
-                "latency_ms": latency_ms,
-                "model": model,
-                "input_tokens": input_tokens,
-                "output_tokens": output_tokens,
-                "total_tokens": total_tokens,
-                "timestamp": dt.datetime.utcnow().isoformat(),
-            },
-        )
-
-    @staticmethod
-    def _extract_flags(handler: CopilotResponseHandler) -> list[str]:
-        """Extract flags from the response handler.
-
-        Args:
-            handler: The response handler containing generated responses.
-
-        Returns:
-            A list of flags indicating special conditions or features.
-        """
-        flags = {r.response_category.value for r in handler.generated_responses}
-        return sorted(flags)
-
-    @staticmethod
-    def _full_text(handler: CopilotResponseHandler) -> str:
-        """Extract full text from the response handler.
-
-        Args:
-            handler: The response handler containing generated responses.
-
-        Returns:
-            The concatenated content of all generated responses.
-        """
-        return "".join(
-            response.content
-            for response in handler.generated_responses
-            if getattr(response, "content", None)
-        )
-
-    def log_copilot_from_handler(
-        self,
-        *,
-        handler: CopilotResponseHandler,
-        used_documents: list[Document],
-        latency_ms: int,
-        model: str,
-        prompt_tokens: int,
-        completion_tokens: int,
-        total_tokens: int,
-    ) -> None:
-        """Log a copilot message from the response handler.
-
-        Args:
-            handler: The response handler containing generated responses.
-            used_documents: List of documents used as supporting evidence.
-            latency_ms: End-to-end Copilot latency to produce this response.
-            model: The model used to generate the response.
-            prompt_tokens: Number of input tokens used.
-            completion_tokens: Number of output tokens generated.
-            total_tokens: Total number of tokens used (input + output).
-        """
-        structlogger.debug("builder.telemetry.log_copilot_from_handler")
-        text = self._full_text(handler)
-        self.log_copilot_turn(
-            text=text,
-            source_urls=[d.url for d in used_documents if d.url],
-            flags=self._extract_flags(handler),
-            latency_ms=latency_ms,
-            model=model,
-            input_tokens=prompt_tokens,
-            output_tokens=completion_tokens,
-            total_tokens=total_tokens,
-        )

rasa/builder/copilot/templated_messages/copilot_internal_messages_templates.yml

@@ -1,16 +0,0 @@
-# Templates for role ROLE_RASA_INTERNAL
-# Note: Only 'training_error_log_analysis' and 'e2e_testing_error_log_analysis' are
-# valid response categories for rasa internal messages for now.
-# Future contexts can be added here + in ResponseCategory enumeration.
-
-templates:
-  # Templated utterance when training fails.
-  training_error_log_analysis: |
-    The assistant training failed. Your task is to analyze provided error logs
-    and help me fix the issue.
-
-  # Templated utterance when e2e testing fails.
-  e2e_testing_error_log_analysis: |
-    The e2e testing failed. Your task is to analyze provided error from the E2E
-    test logs and help me fix the issue. Help me understand if the issue is within
-    the the E2E test or the assistant.

rasa/builder/copilot/templated_messages/copilot_templated_responses.yml

@@ -1,26 +0,0 @@
-responses:
-  roleplay_response: |
-    Looks like we’ve slipped into chatting as if I were your bot. I’m here to help you
-    build and improve your Rasa agent, not to roleplay as it. If you'd like to test your
-    agent, add your message in the chat preview on the right. If you’re not sure what to
-    test, I can help you create a new skill or suggest a few example conversations to
-    try.
-
-  out_of_scope_response: |
-    I’m here to help you build and improve your Rasa chatbot. I can explain concepts,
-    walk you through changes, or debug things with you.
-    
-    Do you want me to show you what your assistant can do right now, or help you add
-    something new?
-
-  error_fallback_response: |
-    Your project ran into an error, but I'm not sure what caused it. Take a look at the
-    logs for the full details.
-
-  guardrail_policy_violation_response: |
-    I’m here to help you with Rasa agent development in a safe and respectful
-    environment. I cannot assist with harmful content, inappropriate material, or
-    attempts to manipulate my responses. Continued attempts to use the system in this
-    way may result in project termination and account blocking.
-
-  copilot_redacted_message: "[Copilot response redacted for guardrails check.]"

rasa/builder/document_retrieval/constants.py

@@ -1,15 +0,0 @@
-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"

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

@@ -1,238 +0,0 @@
-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

@@ -1,62 +0,0 @@
-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", "")