atlas-chat 0.1.0__py3-none-any.whl

atlas/domain/errors.py

@@ -0,0 +1,96 @@
+"""Domain-level errors and exceptions."""
+
+from typing import Optional
+
+
+class DomainError(Exception):
+    """Base domain error."""
+    def __init__(self, message: str, code: Optional[str] = None):
+        super().__init__(message)
+        self.message = message
+        self.code = code
+
+
+class ValidationError(DomainError):
+    """Validation error."""
+    pass
+
+
+class SessionError(DomainError):
+    """Session-related error."""
+    pass
+
+
+class MessageError(DomainError):
+    """Message-related error."""
+    pass
+
+
+class AuthenticationError(DomainError):
+    """Authentication error."""
+    pass
+
+
+class AuthorizationError(DomainError):
+    """Authorization error."""
+    pass
+
+
+class ConfigurationError(DomainError):
+    """Configuration error."""
+    pass
+
+
+class LLMError(DomainError):
+    """LLM-related error."""
+    pass
+
+
+class LLMServiceError(LLMError):
+    """Generic LLM service failure that is not a validation issue."""
+    pass
+
+
+class ToolError(DomainError):
+    """Tool execution error."""
+    pass
+
+
+class ToolAuthorizationError(AuthorizationError):
+    """Raised when user is not authorized to use a specific tool."""
+    pass
+
+
+class DataSourcePermissionError(AuthorizationError):
+    """Raised when user lacks permission to access a data source."""
+    pass
+
+
+class LLMConfigurationError(ConfigurationError):
+    """Raised when LLM configuration is invalid or incomplete."""
+    pass
+
+
+class SessionNotFoundError(SessionError):
+    """Raised when a session cannot be found."""
+    pass
+
+
+class PromptOverrideError(DomainError):
+    """Raised when MCP prompt override fails."""
+    pass
+
+
+class RateLimitError(LLMError):
+    """Raised when LLM rate limit is exceeded."""
+    pass
+
+
+class LLMTimeoutError(LLMError):
+    """Raised when LLM request times out."""
+    pass
+
+
+class LLMAuthenticationError(AuthenticationError):
+    """Raised when LLM authentication fails."""
+    pass

atlas/domain/messages/__init__.py

@@ -0,0 +1,12 @@
+"""Domain models for messages."""
+
+from .models import ConversationHistory, Message, MessageRole, MessageType, ToolCall, ToolResult
+
+__all__ = [
+    "Message",
+    "MessageRole",
+    "MessageType",
+    "ToolCall",
+    "ToolResult",
+    "ConversationHistory",
+]

atlas/domain/messages/models.py

@@ -0,0 +1,160 @@
+"""Domain models for messages."""
+
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from enum import Enum
+from typing import Any, Dict, List, Literal, Optional
+from uuid import UUID, uuid4
+
+
+class MessageRole(Enum):
+    """Message role enumeration."""
+    USER = "user"
+    ASSISTANT = "assistant"
+    SYSTEM = "system"
+    TOOL = "tool"
+
+
+class MessageType(Enum):
+    """Message type enumeration."""
+    CHAT = "chat"
+    CHAT_RESPONSE = "chat_response"
+    ERROR = "error"
+    TOOL_CALL = "tool_call"
+    TOOL_RESULT = "tool_result"
+    AGENT_UPDATE = "agent_update"
+    INTERMEDIATE_UPDATE = "intermediate_update"
+    DOWNLOAD_FILE = "download_file"
+    FILE_DOWNLOAD = "file_download"
+
+
+@dataclass
+class Message:
+    """Domain model for a chat message."""
+    id: UUID = field(default_factory=uuid4)
+    role: MessageRole = MessageRole.USER
+    content: str = ""
+    timestamp: datetime = field(default_factory=lambda: datetime.now(timezone.utc))
+    metadata: Dict[str, Any] = field(default_factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary for serialization."""
+        return {
+            "id": str(self.id),
+            "role": self.role.value,
+            "content": self.content,
+            "timestamp": self.timestamp.isoformat(),
+            "metadata": self.metadata
+        }
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "Message":
+        """Create from dictionary."""
+        return cls(
+            id=UUID(data["id"]) if "id" in data else uuid4(),
+            role=MessageRole(data.get("role", "user")),
+            content=data.get("content", ""),
+            timestamp=datetime.fromisoformat(data["timestamp"]) if "timestamp" in data else datetime.now(timezone.utc),
+            metadata=data.get("metadata", {})
+        )
+
+
+@dataclass
+class ToolCall:
+    """Domain model for a tool call."""
+    id: str
+    name: str
+    arguments: Dict[str, Any]
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary."""
+        return {
+            "id": self.id,
+            "name": self.name,
+            "arguments": self.arguments
+        }
+
+
+@dataclass
+class ToolResult:
+    """Domain model for a tool result with v2 MCP support."""
+    tool_call_id: str
+    content: str
+    success: bool = True
+    error: Optional[str] = None
+    artifacts: List[Dict[str, Any]] = field(default_factory=list)
+    display_config: Optional[Dict[str, Any]] = None
+    meta_data: Optional[Dict[str, Any]] = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary."""
+        result = {
+            "tool_call_id": self.tool_call_id,
+            "content": self.content,
+            "success": self.success,
+            "error": self.error,
+            "artifacts": self.artifacts,
+        }
+        if self.display_config:
+            result["display_config"] = self.display_config
+        if self.meta_data:
+            result["meta_data"] = self.meta_data
+        return result
+
+
+@dataclass
+class ConversationHistory:
+    """Domain model for conversation history."""
+    messages: List[Message] = field(default_factory=list)
+
+    def add_message(self, message: Message) -> None:
+        """Add a message to the history."""
+        self.messages.append(message)
+
+    def get_messages_for_llm(self) -> List[Dict[str, str]]:
+        """Get messages formatted for LLM API."""
+        return [
+            {"role": msg.role.value, "content": msg.content}
+            for msg in self.messages
+        ]
+
+    def to_dict(self) -> List[Dict[str, Any]]:
+        """Convert to dictionary list."""
+        return [msg.to_dict() for msg in self.messages]
+
+
+@dataclass
+class ElicitationRequest:
+    """Domain model for an elicitation request from MCP server."""
+    elicitation_id: str
+    tool_call_id: str
+    tool_name: str
+    message: str
+    response_schema: Dict[str, Any]
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary for WebSocket transmission."""
+        return {
+            "type": "elicitation_request",
+            "elicitation_id": self.elicitation_id,
+            "tool_call_id": self.tool_call_id,
+            "tool_name": self.tool_name,
+            "message": self.message,
+            "response_schema": self.response_schema
+        }
+
+
+@dataclass
+class ElicitationResponse:
+    """Domain model for an elicitation response from user."""
+    elicitation_id: str
+    action: Literal["accept", "decline", "cancel"]
+    data: Optional[Dict[str, Any]] = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary."""
+        return {
+            "elicitation_id": self.elicitation_id,
+            "action": self.action,
+            "data": self.data
+        }