solace-agent-mesh 1.11.2__py3-none-any.whl

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

@@ -0,0 +1,32 @@
+"""
+Task domain entity.
+"""
+
+from pydantic import BaseModel
+
+
+class Task(BaseModel):
+    """Task domain entity."""
+
+    id: str
+    user_id: str
+    parent_task_id: str | None = None
+    start_time: int
+    end_time: int | None = None
+    status: str | None = None
+    initial_request_text: str | None = None
+    
+    # Token usage fields
+    total_input_tokens: int | None = None
+    total_output_tokens: int | None = None
+    total_cached_input_tokens: int | None = None
+    token_usage_details: dict | None = None
+    
+    # Background task execution fields
+    execution_mode: str | None = "foreground"
+    last_activity_time: int | None = None
+    background_execution_enabled: bool | None = False
+    max_execution_time_ms: int | None = None
+
+    class Config:
+        from_attributes = True

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

@@ -0,0 +1,21 @@
+"""
+Task Event domain entity.
+"""
+from typing import Any
+
+from pydantic import BaseModel
+
+
+class TaskEvent(BaseModel):
+    """TaskEvent domain entity."""
+
+    id: str
+    task_id: str
+    user_id: str | None = None
+    created_time: int
+    topic: str
+    direction: str
+    payload: dict[str, Any]
+
+    class Config:
+        from_attributes = True

solace_agent_mesh/gateway/http_sse/repository/feedback_repository.py

@@ -0,0 +1,125 @@
+"""
+Feedback repository implementation using SQLAlchemy.
+"""
+
+from sqlalchemy.orm import Session as DBSession
+
+from ..shared.pagination import PaginationParams
+from ..shared.types import UserId
+from .entities import Feedback
+from .interfaces import IFeedbackRepository
+from .models import FeedbackModel
+
+
+class FeedbackRepository(IFeedbackRepository):
+    """SQLAlchemy implementation of feedback repository."""
+
+    def save(self, session: DBSession, feedback: Feedback) -> Feedback:
+        """Save feedback."""
+        model = FeedbackModel(
+            id=feedback.id,
+            session_id=feedback.session_id,
+            task_id=feedback.task_id,
+            user_id=feedback.user_id,
+            rating=feedback.rating,
+            comment=feedback.comment,
+            created_time=feedback.created_time,
+        )
+        session.add(model)
+        session.flush()
+        session.refresh(model)
+        return self._model_to_entity(model)
+
+    def search(
+        self,
+        session: DBSession,
+        user_id: UserId,
+        start_date: int | None = None,
+        end_date: int | None = None,
+        task_id: str | None = None,
+        session_id: str | None = None,
+        rating: str | None = None,
+        pagination: PaginationParams | None = None,
+    ) -> list[Feedback]:
+        """
+        Search feedback with flexible filtering.
+        All filters are optional and can be combined.
+        """
+        query = session.query(FeedbackModel)
+
+        # User filter (unless admin querying all users)
+        if user_id != "*":
+            query = query.filter(FeedbackModel.user_id == user_id)
+
+        # Time-based filters
+        if start_date:
+            query = query.filter(FeedbackModel.created_time >= start_date)
+        if end_date:
+            query = query.filter(FeedbackModel.created_time <= end_date)
+
+        # Resource-based filters
+        if task_id:
+            query = query.filter(FeedbackModel.task_id == task_id)
+        if session_id:
+            query = query.filter(FeedbackModel.session_id == session_id)
+        if rating:
+            query = query.filter(FeedbackModel.rating == rating)
+
+        # Order by most recent first
+        query = query.order_by(FeedbackModel.created_time.desc())
+
+        # Apply pagination
+        if pagination:
+            query = query.offset(pagination.offset).limit(pagination.page_size)
+
+        models = query.all()
+        return [self._model_to_entity(model) for model in models]
+
+    def delete_feedback_older_than(self, session: DBSession, cutoff_time_ms: int, batch_size: int) -> int:
+        """
+        Delete feedback records older than the cutoff time.
+        Uses batch deletion to avoid long-running transactions.
+
+        Args:
+            cutoff_time_ms: Epoch milliseconds - feedback with created_time before this will be deleted
+            batch_size: Number of feedback records to delete per batch
+
+        Returns:
+            Total number of feedback records deleted
+        """
+        total_deleted = 0
+
+        while True:
+            # Find a batch of feedback IDs to delete
+            feedback_ids_to_delete = (
+                session.query(FeedbackModel.id)
+                .filter(FeedbackModel.created_time < cutoff_time_ms)
+                .limit(batch_size)
+                .all()
+            )
+
+            if not feedback_ids_to_delete:
+                break
+
+            # Extract IDs from the result tuples
+            ids = [feedback_id[0] for feedback_id in feedback_ids_to_delete]
+
+            # Delete this batch
+            deleted_count = (
+                session.query(FeedbackModel)
+                .filter(FeedbackModel.id.in_(ids))
+                .delete(synchronize_session=False)
+            )
+
+            session.commit()
+            total_deleted += deleted_count
+
+            # If we deleted fewer than batch_size, we're done
+            if deleted_count < batch_size:
+                break
+
+        return total_deleted
+
+    def _model_to_entity(self, model: FeedbackModel) -> Feedback:
+        """Convert SQLAlchemy model to domain entity."""
+        return Feedback.model_validate(model)

solace_agent_mesh/gateway/http_sse/repository/interfaces.py

@@ -0,0 +1,239 @@
+"""
+Repository interfaces defining contracts for data access.
+"""
+
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING, Optional
+from sqlalchemy.orm import Session as DBSession
+
+from ..shared.pagination import PaginationParams
+from ..shared.types import SessionId, UserId
+from .entities import Feedback, Session, Task, TaskEvent
+from .entities.project import Project
+from ..routers.dto.requests.project_requests import ProjectFilter
+
+if TYPE_CHECKING:
+    from .entities import ChatTask
+
+
+class ISessionRepository(ABC):
+    """Interface for session data access operations."""
+
+    @abstractmethod
+    def find_by_user(
+        self, session: DBSession, user_id: UserId, pagination: PaginationParams | None = None, project_id: str | None = None
+    ) -> list[Session]:
+        """Find all sessions for a specific user, optionally filtered by project."""
+        pass
+
+    @abstractmethod
+    def count_by_user(self, session: DBSession, user_id: UserId, project_id: str | None = None) -> int:
+        """Count total sessions for a specific user, optionally filtered by project."""
+        pass
+
+    @abstractmethod
+    def find_user_session(
+        self, session: DBSession, session_id: SessionId, user_id: UserId
+    ) -> Session | None:
+        """Find a specific session belonging to a user."""
+        pass
+
+    @abstractmethod
+    def save(self, session: DBSession, session_obj: Session) -> Session:
+        """Save or update a session."""
+        pass
+
+    @abstractmethod
+    def delete(self, session: DBSession, session_id: SessionId, user_id: UserId) -> bool:
+        """Delete a session belonging to a user."""
+        pass
+
+    @abstractmethod
+    def soft_delete(self, session: DBSession, session_id: SessionId, user_id: UserId) -> bool:
+        """Soft delete a session belonging to a user."""
+        pass
+
+    @abstractmethod
+    def move_to_project(
+        self, session: DBSession, session_id: SessionId, user_id: UserId, new_project_id: str | None
+    ) -> Session | None:
+        """Move a session to a different project."""
+        pass
+
+    @abstractmethod
+    def search(
+        self,
+        session: DBSession,
+        user_id: UserId,
+        query: str,
+        pagination: PaginationParams | None = None,
+        project_id: str | None = None
+    ) -> list[Session]:
+        """Search sessions by name or content."""
+        pass
+
+    @abstractmethod
+    def count_search_results(
+        self,
+        session: DBSession,
+        user_id: UserId,
+        query: str,
+        project_id: str | None = None
+    ) -> int:
+        """Count search results for pagination."""
+        pass
+
+
+class ITaskRepository(ABC):
+    """Interface for task data access operations."""
+
+    @abstractmethod
+    def save_task(self, session: DBSession, task: Task) -> Task:
+        """Create or update a task."""
+        pass
+
+    @abstractmethod
+    def save_event(self, session: DBSession, event: TaskEvent) -> TaskEvent:
+        """Save a task event."""
+        pass
+
+    @abstractmethod
+    def find_by_id(self, session: DBSession, task_id: str) -> Task | None:
+        """Find a task by its ID."""
+        pass
+
+    @abstractmethod
+    def find_by_id_with_events(
+        self, session: DBSession, task_id: str
+    ) -> tuple[Task, list[TaskEvent]] | None:
+        """Find a task with all its events."""
+        pass
+
+    @abstractmethod
+    def search(
+        self,
+        session: DBSession,
+        user_id: UserId,
+        start_date: int | None = None,
+        end_date: int | None = None,
+        search_query: str | None = None,
+        pagination: PaginationParams | None = None,
+    ) -> list[Task]:
+        """Search for tasks with filters."""
+        pass
+
+    @abstractmethod
+    def delete_tasks_older_than(self, session: DBSession, cutoff_time_ms: int, batch_size: int) -> int:
+        """Delete tasks older than cutoff time using batch deletion."""
+        pass
+
+
+class IFeedbackRepository(ABC):
+    """Interface for feedback data access operations."""
+
+    @abstractmethod
+    def save(self, session: DBSession, feedback: Feedback) -> Feedback:
+        """Save feedback."""
+        pass
+
+    @abstractmethod
+    def search(
+        self,
+        session: DBSession,
+        user_id: UserId,
+        start_date: int | None = None,
+        end_date: int | None = None,
+        task_id: str | None = None,
+        session_id: str | None = None,
+        rating: str | None = None,
+        pagination: PaginationParams | None = None,
+    ) -> list[Feedback]:
+        """
+        Search feedback with flexible filtering.
+        All filters are optional and can be combined.
+
+        Args:
+            session: Database session
+            user_id: User ID to filter by, or "*" for all users (admin)
+            start_date: Start of date range in epoch milliseconds
+            end_date: End of date range in epoch milliseconds
+            task_id: Filter by specific task ID
+            session_id: Filter by specific session ID
+            rating: Filter by rating type ("up" or "down")
+            pagination: Pagination parameters
+
+        Returns:
+            List of feedback entries matching the filters
+        """
+        pass
+
+    @abstractmethod
+    def delete_feedback_older_than(self, session: DBSession, cutoff_time_ms: int, batch_size: int) -> int:
+        """Delete feedback older than cutoff time using batch deletion."""
+        pass
+
+
+class IChatTaskRepository(ABC):
+    """Interface for chat task data access operations."""
+
+    @abstractmethod
+    def save(self, session: DBSession, task: "ChatTask") -> "ChatTask":
+        """Save or update a chat task (upsert)."""
+        pass
+
+    @abstractmethod
+    def find_by_session(
+        self, session: DBSession, session_id: SessionId, user_id: UserId
+    ) -> list["ChatTask"]:
+        """Find all tasks for a session."""
+        pass
+
+    @abstractmethod
+    def find_by_id(self, session: DBSession, task_id: str, user_id: UserId) -> Optional["ChatTask"]:
+        """Find a specific task."""
+        pass
+
+    @abstractmethod
+    def delete_by_session(self, session: DBSession, session_id: SessionId) -> bool:
+        """Delete all tasks for a session."""
+        pass
+
+
+class IProjectRepository(ABC):
+    """Interface for project repository operations."""
+
+    @abstractmethod
+    def create_project(self, name: str, user_id: str, description: Optional[str] = None,
+                      system_prompt: Optional[str] = None) -> Project:
+        """Create a new user project."""
+        pass
+
+    @abstractmethod
+    def get_user_projects(self, user_id: str) -> list[Project]:
+        """Get all projects owned by a specific user."""
+        pass
+
+    @abstractmethod
+    def get_filtered_projects(self, project_filter: ProjectFilter) -> list[Project]:
+        """Get projects based on filter criteria."""
+        pass
+
+    @abstractmethod
+    def get_by_id(self, project_id: str, user_id: str) -> Optional[Project]:
+        """Get a project by its ID, ensuring user access."""
+        pass
+
+    @abstractmethod
+    def update(self, project_id: str, user_id: str, update_data: dict) -> Optional[Project]:
+        """Update a project with the given data, ensuring user access."""
+        pass
+
+    @abstractmethod
+    def delete(self, project_id: str, user_id: str) -> bool:
+        """Delete a project by its ID, ensuring user access."""
+        pass
+
+    @abstractmethod
+    def soft_delete(self, project_id: str, user_id: str) -> bool:
+        """Soft delete a project by its ID, ensuring user access."""
+        pass

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

@@ -0,0 +1,34 @@
+"""
+SQLAlchemy models and Pydantic models for database persistence.
+"""
+
+from .base import Base
+from .chat_task_model import ChatTaskModel
+from .feedback_model import FeedbackModel
+from .project_model import ProjectModel, CreateProjectModel, UpdateProjectModel
+from .project_user_model import ProjectUserModel, CreateProjectUserModel, UpdateProjectUserModel
+from .session_model import SessionModel, CreateSessionModel, UpdateSessionModel
+from .task_event_model import TaskEventModel
+from .task_model import TaskModel
+from .prompt_model import PromptGroupModel, PromptModel, PromptGroupUserModel
+
+__all__ = [
+    "Base",
+    "ChatTaskModel",
+    "FeedbackModel",
+    "ProjectModel",
+    "ProjectUserModel",
+    "SessionModel",
+    "CreateProjectModel",
+    "UpdateProjectModel",
+    "CreateProjectUserModel",
+    "UpdateProjectUserModel",
+    "CreateSessionModel",
+    "UpdateSessionModel",
+    "TaskEventModel",
+    "TaskModel",
+    "FeedbackModel",
+    "PromptGroupModel",
+    "PromptModel",
+    "PromptGroupUserModel",
+]

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

@@ -0,0 +1,7 @@
+"""
+SQLAlchemy base and shared database configuration.
+"""
+
+from sqlalchemy.orm import declarative_base
+
+Base = declarative_base()

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

@@ -0,0 +1,31 @@
+"""
+ChatTask SQLAlchemy model.
+"""
+
+from sqlalchemy import BigInteger, Column, ForeignKey, String, Text
+from sqlalchemy.orm import relationship
+
+from .base import Base
+
+
+class ChatTaskModel(Base):
+    """SQLAlchemy model for chat tasks."""
+
+    __tablename__ = "chat_tasks"
+
+    id = Column(String, primary_key=True)
+    session_id = Column(
+        String,
+        ForeignKey("sessions.id", ondelete="CASCADE"),
+        nullable=False,
+        index=True
+    )
+    user_id = Column(String, nullable=False, index=True)
+    user_message = Column(Text, nullable=True)
+    message_bubbles = Column(Text, nullable=False)
+    task_metadata = Column(Text, nullable=True)
+    created_time = Column(BigInteger, nullable=False, index=True)
+    updated_time = Column(BigInteger, nullable=True)
+
+    # Relationship to session
+    session = relationship("SessionModel", back_populates="chat_tasks")

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

@@ -0,0 +1,21 @@
+"""
+Feedback SQLAlchemy model.
+"""
+
+from sqlalchemy import BigInteger, Column, String, Text
+
+from .base import Base
+
+
+class FeedbackModel(Base):
+    """SQLAlchemy model for user feedback."""
+
+    __tablename__ = "feedback"
+
+    id = Column(String, primary_key=True)
+    session_id = Column(String, nullable=False)
+    task_id = Column(String, nullable=False, index=True)
+    user_id = Column(String, nullable=False, index=True)
+    rating = Column(String, nullable=False)  # e.g., 'up', 'down'
+    comment = Column(Text, nullable=True)
+    created_time = Column(BigInteger, nullable=False)