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

solace_agent_mesh/gateway/http_sse/repository/project_repository.py

@@ -0,0 +1,172 @@
+"""
+Repository implementation for project data access operations.
+"""
+from typing import List, Optional
+import uuid
+
+from sqlalchemy.orm import Session as DBSession
+from sqlalchemy import or_
+
+from .interfaces import IProjectRepository
+from .models import ProjectModel, ProjectUserModel
+from .entities.project import Project
+from ..routers.dto.requests.project_requests import ProjectFilter
+from ..shared import now_epoch_ms
+
+
+class ProjectRepository(IProjectRepository):
+    """SQLAlchemy implementation of project repository."""
+
+    def __init__(self, db: DBSession):
+        self.db = db
+
+    def create_project(self, name: str, user_id: str, description: Optional[str] = None,
+                      system_prompt: Optional[str] = None, default_agent_id: Optional[str] = None) -> Project:
+        """Create a new user project."""
+        model = ProjectModel(
+            id=str(uuid.uuid4()),
+            name=name,
+            user_id=user_id,
+            description=description,
+            system_prompt=system_prompt,
+            default_agent_id=default_agent_id,
+            created_at=now_epoch_ms(),
+        )
+        self.db.add(model)
+        self.db.flush()
+        self.db.refresh(model)
+        return self._model_to_entity(model)
+
+    def get_user_projects(self, user_id: str) -> List[Project]:
+        """
+        Get all projects owned by a specific user.
+        
+        Note: This returns only projects where the user is the owner (user_id matches).
+        For projects the user has access to via project_users table, use get_accessible_projects().
+        """
+        models = self.db.query(ProjectModel).filter(
+            ProjectModel.user_id == user_id,
+            ProjectModel.deleted_at.is_(None)  # Exclude soft-deleted projects
+        ).all()
+        return [self._model_to_entity(model) for model in models]
+    
+    def get_accessible_projects(self, user_id: str) -> List[Project]:
+        """
+        Get all projects accessible by a user (owned or shared).
+        
+        This includes:
+        - Projects owned by the user (user_id matches)
+        - Projects shared with the user (via project_users table)
+        
+        Args:
+            user_id: The user ID
+            
+        Returns:
+            List[Project]: List of accessible projects
+        """
+        # Query for projects where user is owner OR has access via project_users
+        models = self.db.query(ProjectModel).outerjoin(
+            ProjectUserModel,
+            ProjectModel.id == ProjectUserModel.project_id
+        ).filter(
+            ProjectModel.deleted_at.is_(None),  # Exclude soft-deleted projects
+            or_(
+                ProjectModel.user_id == user_id,
+                ProjectUserModel.user_id == user_id
+            )
+        ).distinct().all()
+        
+        return [self._model_to_entity(model) for model in models]
+
+    def get_filtered_projects(self, project_filter: ProjectFilter) -> List[Project]:
+        """Get projects based on filter criteria."""
+        query = self.db.query(ProjectModel).filter(
+            ProjectModel.deleted_at.is_(None)  # Exclude soft-deleted projects
+        )
+        
+        if project_filter.user_id is not None:
+            query = query.filter(ProjectModel.user_id == project_filter.user_id)
+
+        models = query.all()
+        return [self._model_to_entity(model) for model in models]
+
+    def get_by_id(self, project_id: str, user_id: str) -> Optional[Project]:
+        """
+        Get a project by its ID, ensuring user access.
+        
+        This checks if the user is the owner OR has access via project_users table.
+        """
+        model = self.db.query(ProjectModel).outerjoin(
+            ProjectUserModel,
+            ProjectModel.id == ProjectUserModel.project_id
+        ).filter(
+            ProjectModel.id == project_id,
+            ProjectModel.deleted_at.is_(None),  # Exclude soft-deleted projects
+            or_(
+                ProjectModel.user_id == user_id,
+                ProjectUserModel.user_id == user_id
+            )
+        ).first()
+        
+        return self._model_to_entity(model) if model else None
+
+    def update(self, project_id: str, user_id: str, update_data: dict) -> Optional[Project]:
+        """Update a project with the given data, ensuring user access."""
+        model = self.db.query(ProjectModel).filter(
+            ProjectModel.id == project_id,
+            ProjectModel.user_id == user_id,  # Only allow updates to user's own projects
+            ProjectModel.deleted_at.is_(None)  # Exclude soft-deleted projects
+        ).first()
+        
+        if not model:
+            return None
+        
+        for field, value in update_data.items():
+            if hasattr(model, field):
+                setattr(model, field, value)
+        
+        model.updated_at = now_epoch_ms()
+        self.db.flush()
+        self.db.refresh(model)
+        return self._model_to_entity(model)
+
+    def delete(self, project_id: str, user_id: str) -> bool:
+        """Delete a project by its ID, ensuring user access."""
+        result = self.db.query(ProjectModel).filter(
+            ProjectModel.id == project_id,
+            ProjectModel.user_id == user_id  # Only allow deletion of user's own projects
+        ).delete()
+        self.db.flush()
+        return result > 0
+
+    def soft_delete(self, project_id: str, user_id: str) -> bool:
+        """Soft delete a project by its ID, ensuring user access."""
+        model = self.db.query(ProjectModel).filter(
+            ProjectModel.id == project_id,
+            ProjectModel.user_id == user_id,  # Only allow deletion of user's own projects
+            ProjectModel.deleted_at.is_(None)  # Only delete if not already deleted
+        ).first()
+        
+        if not model:
+            return False
+        
+        model.deleted_at = now_epoch_ms()
+        model.deleted_by = user_id
+        model.updated_at = now_epoch_ms()
+        self.db.flush()
+        return True
+
+    def _model_to_entity(self, model: ProjectModel) -> Project:
+        """Convert SQLAlchemy model to domain entity."""
+        return Project(
+            id=model.id,
+            name=model.name,
+            user_id=model.user_id,
+            description=model.description,
+            system_prompt=model.system_prompt,
+            default_agent_id=model.default_agent_id,
+            created_at=model.created_at,
+            updated_at=model.updated_at,
+            deleted_at=model.deleted_at,
+            deleted_by=model.deleted_by,
+        )

solace_agent_mesh/gateway/http_sse/repository/project_user_repository.py

@@ -0,0 +1,186 @@
+"""
+Repository implementation for project user access data operations.
+"""
+from typing import List, Optional
+import uuid
+
+from sqlalchemy.orm import Session as DBSession
+
+from .models import ProjectUserModel
+from .entities.project_user import ProjectUser
+from ..shared import now_epoch_ms
+
+
+class ProjectUserRepository:
+    """SQLAlchemy implementation of project user repository."""
+
+    def __init__(self, db: DBSession):
+        self.db = db
+
+    def add_user_to_project(
+        self,
+        project_id: str,
+        user_id: str,
+        role: str,
+        added_by_user_id: str
+    ) -> ProjectUser:
+        """
+        Add a user to a project with a specific role.
+        
+        Args:
+            project_id: The project ID
+            user_id: The user ID to add
+            role: The role to assign (owner, editor, viewer)
+            added_by_user_id: The user ID who is granting access
+            
+        Returns:
+            ProjectUser: The created project user access record
+        """
+        model = ProjectUserModel(
+            id=str(uuid.uuid4()),
+            project_id=project_id,
+            user_id=user_id,
+            role=role,
+            added_at=now_epoch_ms(),
+            added_by_user_id=added_by_user_id,
+        )
+        self.db.add(model)
+        self.db.commit()
+        self.db.refresh(model)
+        return self._model_to_entity(model)
+
+    def get_project_users(self, project_id: str) -> List[ProjectUser]:
+        """
+        Get all users who have access to a project.
+        
+        Args:
+            project_id: The project ID
+            
+        Returns:
+            List[ProjectUser]: List of users with access to the project
+        """
+        models = self.db.query(ProjectUserModel).filter(
+            ProjectUserModel.project_id == project_id
+        ).all()
+        return [self._model_to_entity(model) for model in models]
+
+    def get_user_projects_access(self, user_id: str) -> List[ProjectUser]:
+        """
+        Get all projects a user has access to.
+        
+        Args:
+            user_id: The user ID
+            
+        Returns:
+            List[ProjectUser]: List of project access records for the user
+        """
+        models = self.db.query(ProjectUserModel).filter(
+            ProjectUserModel.user_id == user_id
+        ).all()
+        return [self._model_to_entity(model) for model in models]
+
+    def get_user_project_access(
+        self,
+        project_id: str,
+        user_id: str
+    ) -> Optional[ProjectUser]:
+        """
+        Get a specific user's access to a project.
+        
+        Args:
+            project_id: The project ID
+            user_id: The user ID
+            
+        Returns:
+            Optional[ProjectUser]: The access record if found, None otherwise
+        """
+        model = self.db.query(ProjectUserModel).filter(
+            ProjectUserModel.project_id == project_id,
+            ProjectUserModel.user_id == user_id
+        ).first()
+        
+        return self._model_to_entity(model) if model else None
+
+    def update_user_role(
+        self,
+        project_id: str,
+        user_id: str,
+        new_role: str
+    ) -> Optional[ProjectUser]:
+        """
+        Update a user's role for a project.
+        
+        Args:
+            project_id: The project ID
+            user_id: The user ID
+            new_role: The new role to assign
+            
+        Returns:
+            Optional[ProjectUser]: The updated access record if found, None otherwise
+        """
+        model = self.db.query(ProjectUserModel).filter(
+            ProjectUserModel.project_id == project_id,
+            ProjectUserModel.user_id == user_id
+        ).first()
+        
+        if not model:
+            return None
+        
+        model.role = new_role
+        self.db.commit()
+        self.db.refresh(model)
+        return self._model_to_entity(model)
+
+    def remove_user_from_project(
+        self,
+        project_id: str,
+        user_id: str
+    ) -> bool:
+        """
+        Remove a user's access to a project.
+        
+        Args:
+            project_id: The project ID
+            user_id: The user ID to remove
+            
+        Returns:
+            bool: True if removed successfully, False otherwise
+        """
+        result = self.db.query(ProjectUserModel).filter(
+            ProjectUserModel.project_id == project_id,
+            ProjectUserModel.user_id == user_id
+        ).delete()
+        self.db.commit()
+        return result > 0
+
+    def user_has_access(
+        self,
+        project_id: str,
+        user_id: str
+    ) -> bool:
+        """
+        Check if a user has access to a project.
+        
+        Args:
+            project_id: The project ID
+            user_id: The user ID
+            
+        Returns:
+            bool: True if user has access, False otherwise
+        """
+        count = self.db.query(ProjectUserModel).filter(
+            ProjectUserModel.project_id == project_id,
+            ProjectUserModel.user_id == user_id
+        ).count()
+        return count > 0
+
+    def _model_to_entity(self, model: ProjectUserModel) -> ProjectUser:
+        """Convert SQLAlchemy model to domain entity."""
+        return ProjectUser(
+            id=model.id,
+            project_id=model.project_id,
+            user_id=model.user_id,
+            role=model.role,
+            added_at=model.added_at,
+            added_by_user_id=model.added_by_user_id,
+        )

solace_agent_mesh/gateway/http_sse/repository/repository_llm.txt

@@ -0,0 +1,308 @@
+# DEVELOPER GUIDE: repository
+
+## Quick Summary
+
+The repository directory implements the data access layer for the HTTP SSE gateway using the Repository pattern with SQLAlchemy ORM. It provides a clean separation between domain entities (business logic) and database persistence through abstract interfaces and concrete implementations. The architecture consists of repository interfaces defining contracts, SQLAlchemy implementations, domain entities with validation, and ORM models for database schema. The entities/ subdirectory contains business objects while models/ contains database persistence logic, working together to provide comprehensive data management for chat sessions, tasks, feedback, and events.
+
+## Files and Subdirectories Overview
+
+**Direct files:**
+- `__init__.py` - Main package exports for repository interfaces, implementations, entities, and models
+- `interfaces.py` - Abstract repository interfaces defining data access contracts
+- `session_repository.py` - SQLAlchemy implementation of session data access operations
+- `chat_task_repository.py` - SQLAlchemy implementation of chat task data access operations  
+- `feedback_repository.py` - SQLAlchemy implementation of feedback data access operations
+- `task_repository.py` - SQLAlchemy implementation of task data access operations
+
+**Subdirectories:**
+- `entities/` - Domain entities with business logic for sessions, tasks, feedback, and events
+- `models/` - SQLAlchemy ORM models for database persistence and schema definition
+
+## Developer API Reference
+
+### Direct Files
+
+#### __init__.py
+**Purpose:** Central package exports for all repository components
+**Import:** `from solace_agent_mesh.gateway.http_sse.repository import ISessionRepository, SessionRepository, Session, Base, SessionModel`
+
+**Exports:**
+- `ISessionRepository` - Session repository interface
+- `SessionRepository` - Session repository implementation
+- `Session` - Session domain entity
+- `Base` - SQLAlchemy declarative base
+- `SessionModel` - SQLAlchemy session model
+
+#### interfaces.py
+**Purpose:** Defines abstract repository interfaces for data access contracts
+**Import:** `from solace_agent_mesh.gateway.http_sse.repository.interfaces import ISessionRepository, ITaskRepository, IFeedbackRepository, IChatTaskRepository`
+
+**Classes:**
+- `ISessionRepository(ABC)` - Abstract interface for session data operations
+  - `find_by_user(session: DBSession, user_id: UserId, pagination: PaginationParams | None = None) -> list[Session]` - Find all sessions for a user
+  - `count_by_user(session: DBSession, user_id: UserId) -> int` - Count total sessions for a user
+  - `find_user_session(session: DBSession, session_id: SessionId, user_id: UserId) -> Session | None` - Find specific user session
+  - `save(session: DBSession, session_obj: Session) -> Session` - Save or update a session
+  - `delete(session: DBSession, session_id: SessionId, user_id: UserId) -> bool` - Delete user session
+
+- `ITaskRepository(ABC)` - Abstract interface for task data operations
+  - `save_task(session: DBSession, task: Task) -> Task` - Create or update a task
+  - `save_event(session: DBSession, event: TaskEvent) -> TaskEvent` - Save a task event
+  - `find_by_id(session: DBSession, task_id: str) -> Task | None` - Find a task by its ID
+  - `find_by_id_with_events(session: DBSession, task_id: str) -> tuple[Task, list[TaskEvent]] | None` - Find a task with all its events
+  - `search(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
+  - `delete_tasks_older_than(session: DBSession, cutoff_time_ms: int, batch_size: int) -> int` - Delete tasks older than cutoff time
+
+- `IFeedbackRepository(ABC)` - Abstract interface for feedback data operations
+  - `save(session: DBSession, feedback: Feedback) -> Feedback` - Save feedback
+  - `delete_feedback_older_than(session: DBSession, cutoff_time_ms: int, batch_size: int) -> int` - Delete feedback older than cutoff time
+
+- `IChatTaskRepository(ABC)` - Abstract interface for chat task data operations
+  - `save(session: DBSession, task: ChatTask) -> ChatTask` - Save or update a chat task (upsert)
+  - `find_by_session(session: DBSession, session_id: SessionId, user_id: UserId) -> list[ChatTask]` - Find all tasks for a session
+  - `find_by_id(session: DBSession, task_id: str, user_id: UserId) -> Optional[ChatTask]` - Find a specific task
+  - `delete_by_session(session: DBSession, session_id: SessionId) -> bool` - Delete all tasks for a session
+
+#### session_repository.py
+**Purpose:** SQLAlchemy implementation of session repository interface
+**Import:** `from solace_agent_mesh.gateway.http_sse.repository.session_repository import SessionRepository`
+
+**Classes:**
+- `SessionRepository(PaginatedRepository[SessionModel, Session], ISessionRepository)` - SQLAlchemy session repository implementation
+  - `find_by_user(session: DBSession, user_id: UserId, pagination: PaginationParams | None = None) -> list[Session]` - Find user sessions with pagination
+  - `count_by_user(session: DBSession, user_id: UserId) -> int` - Count total sessions for a user
+  - `find_user_session(session: DBSession, session_id: SessionId, user_id: UserId) -> Session | None` - Find specific user session
+  - `save(db_session: DBSession, session: Session) -> Session` - Save or update session in database
+  - `delete(db_session: DBSession, session_id: SessionId, user_id: UserId) -> bool` - Delete user session
+
+#### chat_task_repository.py
+**Purpose:** SQLAlchemy implementation of chat task repository interface
+**Import:** `from solace_agent_mesh.gateway.http_sse.repository.chat_task_repository import ChatTaskRepository`
+
+**Classes:**
+- `ChatTaskRepository(IChatTaskRepository)` - SQLAlchemy chat task repository implementation
+  - `save(session: DBSession, task: ChatTask) -> ChatTask` - Save or update a chat task (upsert)
+  - `find_by_session(session: DBSession, session_id: SessionId, user_id: UserId) -> List[ChatTask]` - Find all tasks for a session
+  - `find_by_id(session: DBSession, task_id: str, user_id: UserId) -> Optional[ChatTask]` - Find a specific task
+  - `delete_by_session(session: DBSession, session_id: SessionId) -> bool` - Delete all tasks for a session
+  - `_model_to_entity(model: ChatTaskModel) -> ChatTask` - Convert SQLAlchemy model to domain entity
+
+#### feedback_repository.py
+**Purpose:** SQLAlchemy implementation of feedback repository interface
+**Import:** `from solace_agent_mesh.gateway.http_sse.repository.feedback_repository import FeedbackRepository`
+
+**Classes:**
+- `FeedbackRepository(IFeedbackRepository)` - SQLAlchemy feedback repository implementation
+  - `save(session: DBSession, feedback: Feedback) -> Feedback` - Save feedback to database
+  - `delete_feedback_older_than(session: DBSession, cutoff_time_ms: int, batch_size: int) -> int` - Delete feedback older than cutoff time using batch deletion
+  - `_model_to_entity(model: FeedbackModel) -> Feedback` - Convert SQLAlchemy model to domain entity
+
+#### task_repository.py
+**Purpose:** SQLAlchemy implementation of task repository interface
+**Import:** `from solace_agent_mesh.gateway.http_sse.repository.task_repository import TaskRepository`
+
+**Classes:**
+- `TaskRepository(ITaskRepository)` - SQLAlchemy task repository implementation
+  - `save_task(session: DBSession, task: Task) -> Task` - Create or update a task
+  - `save_event(session: DBSession, event: TaskEvent) -> TaskEvent` - Save a task event
+  - `find_by_id(session: DBSession, task_id: str) -> Task | None` - Find a task by its ID
+  - `find_by_id_with_events(session: DBSession, task_id: str) -> tuple[Task, list[TaskEvent]] | None` - Find a task with all its events
+  - `search(session: DBSession, user_id: UserId, start_date: int | None = None, end_date: int | None = None, pagination: PaginationParams | None = None) -> list[Task]` - Search for tasks with filters
+  - `delete_tasks_older_than(session: DBSession, cutoff_time_ms: int, batch_size: int) -> int` - Delete tasks older than cutoff time using batch deletion
+  - `_task_model_to_entity(model: TaskModel) -> Task` - Convert SQLAlchemy task model to domain entity
+  - `_event_model_to_entity(model: TaskEventModel) -> TaskEvent` - Convert SQLAlchemy event model to domain entity
+
+### Subdirectory APIs
+
+#### entities/
+**Purpose:** Provides domain entities with business logic for sessions, tasks, feedback, and events
+**Key Exports:** ChatTask, Feedback, Session, Task, TaskEvent
+**Import Examples:**
+```python
+from solace_agent_mesh.gateway.http_sse.repository.entities import ChatTask, Feedback, Session, Task, TaskEvent
+```
+
+#### models/
+**Purpose:** Provides SQLAlchemy ORM models for database persistence and schema definition
+**Key Exports:** Base, ChatTaskModel, FeedbackModel, SessionModel, TaskModel, TaskEventModel, CreateSessionModel, UpdateSessionModel
+**Import Examples:**
+```python
+from solace_agent_mesh.gateway.http_sse.repository.models import Base, SessionModel, ChatTaskModel, TaskModel, FeedbackModel
+```
+
+## Complete Usage Guide
+
+### 1. Setting Up the Repository Layer
+
+```python
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker
+from solace_agent_mesh.gateway.http_sse.repository import (
+    Base, SessionRepository, ChatTaskRepository, TaskRepository, FeedbackRepository
+)
+
+# Create database engine and session
+engine = create_engine("sqlite:///chat.db")
+Base.metadata.create_all(engine)
+SessionMaker = sessionmaker(bind=engine)
+db_session = SessionMaker()
+
+# Initialize repositories
+session_repo = SessionRepository()
+chat_task_repo = ChatTaskRepository()
+task_repo = TaskRepository()
+feedback_repo = FeedbackRepository()
+```
+
+### 2. Working with Sessions
+
+```python
+from solace_agent_mesh.gateway.http_sse.repository.entities import Session
+from solace_agent_mesh.gateway.http_sse.shared.pagination import PaginationParams
+import time
+
+# Create a new session
+session = Session(
+    id="session_123",
+    user_id="user_456",
+    name="Customer Support Chat",
+    agent_id="agent_789",
+    created_time=int(time.time() * 1000)
+)
+
+# Save session
+saved_session = session_repo.save(db_session, session)
+
+# Find user sessions with pagination
+pagination = PaginationParams(page=1, page_size=10)
+user_sessions = session_repo.find_by_user(db_session, "user_456", pagination)
+
+# Count total sessions for user
+total_sessions = session_repo.count_by_user(db_session, "user_456")
+
+# Find specific session
+found_session = session_repo.find_user_session(db_session, "session_123", "user_456")
+
+# Update session
+if found_session:
+    found_session.update_name("Updated Chat Name")
+    session_repo.save(db_session, found_session)
+
+# Delete session
+deleted = session_repo.delete(db_session, "session_123", "user_456")
+db_session.commit()
+```
+
+### 3. Working with Chat Tasks
+
+```python
+from solace_agent_mesh.gateway.http_sse.repository.entities import ChatTask
+import json
+
+# Create a chat task with message bubbles
+message_bubbles = json.dumps([
+    {"type": "user", "content": "Hello, I need help"},
+    {"type": "agent", "content": "Hi! How can I assist you today?"}
+])
+
+chat_task = ChatTask(
+    id="chat_task_123",
+    session_id="session_123",
+    user_id="user_456",
+    user_message="Hello, I need help",
+    message_bubbles=message_bubbles,
+    created_time=int(time.time() * 1000)
+)
+
+# Save chat task
+saved_task = chat_task_repo.save(db_session, chat_task)
+
+# Find all tasks for a session
+session_tasks = chat_task_repo.find_by_session(db_session, "session_123", "user_456")
+
+# Find specific task
+found_task = chat_task_repo.find_by_id(db_session, "chat_task_123", "user_456")
+
+# Add feedback to task
+if found_task:
+    found_task.add_feedback("positive", "Great response!")
+    chat_task_repo.save(db_session, found_task)
+
+# Delete all tasks for a session
+deleted = chat_task_repo.delete_by_session(db_session, "session_123")
+db_session.commit()
+```
+
+### 4. Working with Tasks and Events
+
+```python
+from solace_agent_mesh.gateway.http_sse.repository.entities import Task, TaskEvent
+
+# Create a new task
+task = Task(
+    id="task_123",
+    user_id="user_456",
+    start_time=int(time.time() * 1000),
+    status="in_progress",
+    initial_request_text="Help me with my order",
+    total_input_tokens=150,
+    total_output_tokens=300
+)
+
+# Save task
+saved_task = task_repo.save_task(db_session, task)
+
+# Create task event
+event = TaskEvent(
+    id="event_123",
+    task_id="task_123",
+    user_id="user_456",
+    created_time=int(time.time() * 1000),
+    topic="task.status.changed",
+    direction="outbound",
+    payload={"status": "completed", "result": "success"}
+)
+
+# Save event
+saved_event = task_repo.save_event(db_session, event)
+
+# Find task with events
+result = task_repo.find_by_id_with_events(db_session, "task_123")
+if result:
+    task, events = result
+    print(f"Task {task.id} has {len(events)} events")
+
+# Search tasks with filters
+from solace_agent_mesh.gateway.http_sse.shared.pagination import PaginationParams
+pagination_params = PaginationParams(page=1, page_size=10)
+start_date = int((time.time() - 86400) * 1000)  # 24 hours ago
+end_date = int(time.time() * 1000)
+
+tasks = task_repo.search(
+    db_session,
+    user_id="user_456",
+    start_date=start_date,
+    end_date=end_date,
+    pagination=pagination_params
+)
+
+# Batch delete old tasks
+cutoff_time = int((time.time() - 7 * 86400) * 1000)  # 7 days ago
+deleted_count = task_repo.delete_tasks_older_than(db_session, cutoff_time, batch_size=100)
+print(f"Deleted {deleted_count} old tasks")
+```
+
+### 5. Working with Feedback
+
+```python
+from solace_agent_mesh.gateway.http_sse.repository.entities import Feedback
+
+# Create feedback
+feedback = Feedback(
+    id="feedback_123",
+    session_id="session_123",
+    task_id="task_123",
+    user_id="user_456",
+    rating="up",
+
+# content_hash: 9dc7b1b626d834a08c7dad6774af9b5c2190e1e635d0be92c54121eed438521f