solace-agent-mesh 1.4.12__py3-none-any.whl → 1.5.0__py3-none-any.whl

solace_agent_mesh/gateway/http_sse/repository/entities/message.py

@@ -1,41 +0,0 @@
-"""
-Message domain entity.
-"""
-
-from pydantic import BaseModel, ConfigDict
-
-from ...shared.enums import MessageType, SenderType
-from ...shared.types import MessageId, SessionId
-
-
-class Message(BaseModel):
-    """Message domain entity with business logic."""
-
-    model_config = ConfigDict(from_attributes=True)
-
-    id: MessageId
-    session_id: SessionId
-    message: str
-    sender_type: SenderType
-    sender_name: str
-    message_type: MessageType = MessageType.TEXT
-    created_time: int
-
-    def validate_message_content(self) -> None:
-        """Validate message content."""
-        if not self.message or len(self.message.strip()) == 0:
-            raise ValueError("Message content cannot be empty")
-        if len(self.message) > 10_000_000:
-            raise ValueError("Message content exceeds maximum length (10MB)")
-
-    def is_from_user(self) -> bool:
-        """Check if message is from a user."""
-        return self.sender_type == SenderType.USER
-
-    def is_from_agent(self) -> bool:
-        """Check if message is from an agent."""
-        return self.sender_type == SenderType.AGENT
-
-    def is_system_message(self) -> bool:
-        """Check if message is a system message."""
-        return self.sender_type == SenderType.SYSTEM

solace_agent_mesh/gateway/http_sse/repository/message_repository.py

@@ -1,84 +0,0 @@
-"""
-Message repository implementation using SQLAlchemy.
-"""
-
-from sqlalchemy.orm import Session as DBSession
-
-from ..shared.base_repository import PaginatedRepository
-from ..shared.enums import MessageType, SenderType
-from ..shared.types import PaginationInfo, SessionId
-from .entities import Message
-from .interfaces import IMessageRepository
-from .models import MessageModel, CreateMessageModel, UpdateMessageModel
-
-
-class MessageRepository(PaginatedRepository[MessageModel, Message], IMessageRepository):
-    """SQLAlchemy implementation of message repository using BaseRepository."""
-
-    def __init__(self, db: DBSession):
-        super().__init__(MessageModel, Message)
-        self.db = db
-
-    @property
-    def entity_name(self) -> str:
-        """Return the entity name for error messages."""
-        return "message"
-
-    def find_by_session(
-        self, session_id: SessionId, pagination: PaginationInfo | None = None
-    ) -> list[Message]:
-        """Find all messages in a session."""
-        query = self.db.query(MessageModel).filter(
-            MessageModel.session_id == session_id
-        )
-        query = query.order_by(MessageModel.created_time.asc())
-
-        if pagination:
-            offset = (pagination.page - 1) * pagination.page_size
-            query = query.offset(offset).limit(pagination.page_size)
-
-        models = query.all()
-        return [self._convert_model_to_entity(model) for model in models]
-
-    def save(self, message: Message) -> Message:
-        """Save or update a message."""
-        existing_model = self.db.query(MessageModel).filter(MessageModel.id == message.id).first()
-
-        if existing_model:
-            update_model = UpdateMessageModel(
-                message=message.message,
-                sender_type=message.sender_type.value,
-                sender_name=message.sender_name,
-            )
-            return self.update(self.db, message.id, update_model.model_dump())
-        else:
-            create_model = CreateMessageModel(
-                id=message.id,
-                session_id=message.session_id,
-                message=message.message,
-                sender_type=message.sender_type.value,
-                sender_name=message.sender_name,
-                created_time=message.created_time,
-            )
-            return self.create(self.db, create_model.model_dump())
-
-    def delete_by_session(self, session_id: SessionId) -> bool:
-        """Delete all messages in a session."""
-        result = (
-            self.db.query(MessageModel)
-            .filter(MessageModel.session_id == session_id)
-            .delete()
-        )
-        return result > 0
-
-    def _convert_model_to_entity(self, model: MessageModel) -> Message:
-        """Convert SQLAlchemy model to domain entity with enum handling."""
-        return Message(
-            id=model.id,
-            session_id=model.session_id,
-            message=model.message,
-            sender_type=SenderType(model.sender_type),
-            sender_name=model.sender_name,
-            message_type=MessageType.TEXT,  # Default for now
-            created_time=model.created_time,
-        )

solace_agent_mesh/gateway/http_sse/repository/models/message_model.py

@@ -1,45 +0,0 @@
-"""
-Message SQLAlchemy model and Pydantic models for strongly-typed operations.
-"""
-
-from pydantic import BaseModel
-from sqlalchemy import BigInteger, Column, ForeignKey, String, Text
-from sqlalchemy.orm import relationship
-
-from ...shared import now_epoch_ms
-from .base import Base
-
-
-class MessageModel(Base):
-    """SQLAlchemy model for messages."""
-
-    __tablename__ = "chat_messages"
-
-    id = Column(String, primary_key=True)
-    session_id = Column(
-        String, ForeignKey("sessions.id", ondelete="CASCADE"), nullable=False
-    )
-    message = Column(Text, nullable=False)
-    created_time = Column(BigInteger, nullable=False, default=now_epoch_ms)
-    sender_type = Column(String(50))
-    sender_name = Column(String(255))
-
-    # Relationship to session
-    session = relationship("SessionModel", back_populates="messages")
-
-
-class CreateMessageModel(BaseModel):
-    """Pydantic model for creating a message."""
-    id: str
-    session_id: str
-    message: str
-    sender_type: str
-    sender_name: str
-    created_time: int
-
-
-class UpdateMessageModel(BaseModel):
-    """Pydantic model for updating a message."""
-    message: str
-    sender_type: str
-    sender_name: str