solace-agent-mesh 1.6.2__py3-none-any.whl → 1.7.0__py3-none-any.whl

solace_agent_mesh/gateway/http_sse/repository/interfaces.py

@@ -9,6 +9,8 @@ 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
@@ -19,14 +21,14 @@ class ISessionRepository(ABC):
 
     @abstractmethod
     def find_by_user(
-        self, session: DBSession, user_id: UserId, pagination: PaginationParams | None = None
+        self, session: DBSession, user_id: UserId, pagination: PaginationParams | None = None, project_id: str | None = None
     ) -> list[Session]:
-        """Find all sessions for a specific user."""
+        """Find all sessions for a specific user, optionally filtered by project."""
         pass
 
     @abstractmethod
-    def count_by_user(self, session: DBSession, user_id: UserId) -> int:
-        """Count total sessions for a specific user."""
+    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
@@ -46,6 +48,41 @@ class ISessionRepository(ABC):
         """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."""
@@ -99,6 +136,37 @@ class IFeedbackRepository(ABC):
         """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."""
@@ -129,3 +197,43 @@ class IChatTaskRepository(ABC):
     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

@@ -5,6 +5,8 @@ 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
@@ -12,10 +14,16 @@ from .task_model import TaskModel
 __all__ = [
     "Base",
     "ChatTaskModel",
+    "FeedbackModel",
+    "ProjectModel",
+    "ProjectUserModel",
     "SessionModel",
+    "CreateProjectModel",
+    "UpdateProjectModel",
+    "CreateProjectUserModel",
+    "UpdateProjectUserModel",
     "CreateSessionModel",
     "UpdateSessionModel",
     "TaskEventModel",
     "TaskModel",
-    "FeedbackModel",
 ]

solace_agent_mesh/gateway/http_sse/repository/models/models_llm.txt

@@ -1,11 +1,11 @@
 ## Quick Summary
-This directory contains SQLAlchemy ORM models and Pydantic schemas for database persistence in the HTTP SSE gateway. It provides models for managing chat sessions, messages, tasks, task events, and user feedback with proper relationships and database schema definitions.
+This directory contains SQLAlchemy ORM models and Pydantic schemas for database persistence in the HTTP SSE gateway. It provides models for managing chat sessions, tasks, task events, and user feedback with proper relationships and database schema definitions.
 
 ## Files Overview
 - `__init__.py` - Package initialization exposing all SQLAlchemy and Pydantic models
 - `base.py` - SQLAlchemy declarative base configuration
+- `chat_task_model.py` - ChatTaskModel for storing chat tasks with session relationships
 - `feedback_model.py` - FeedbackModel for storing user feedback on tasks
-- `message_model.py` - MessageModel and Pydantic schemas for chat messages with session relationships
 - `session_model.py` - SessionModel and Pydantic schemas for managing chat sessions
 - `task_event_model.py` - TaskEventModel for storing A2A task events with task relationships
 - `task_model.py` - TaskModel for managing tasks with event relationships and token usage tracking
@@ -14,7 +14,7 @@ This directory contains SQLAlchemy ORM models and Pydantic schemas for database
 
 ### __init__.py
 **Purpose:** Package entry point that exposes all SQLAlchemy models and Pydantic schemas
-**Import:** `from solace_agent_mesh.gateway.http_sse.repository.models import Base, MessageModel, SessionModel, CreateMessageModel, UpdateMessageModel, CreateSessionModel, UpdateSessionModel, TaskEventModel, TaskModel, FeedbackModel`
+**Import:** `from solace_agent_mesh.gateway.http_sse.repository.models import Base, ChatTaskModel, FeedbackModel, SessionModel, CreateSessionModel, UpdateSessionModel, TaskEventModel, TaskModel`
 
 **Constants/Variables:**
 - `__all__: List[str]` - Public API exports including all models and schemas
@@ -36,6 +36,49 @@ engine = create_engine("sqlite:///example.db")
 Base.metadata.create_all(engine)
 ```
 
+### chat_task_model.py
+**Purpose:** SQLAlchemy model for storing chat tasks with session relationships
+**Import:** `from solace_agent_mesh.gateway.http_sse.repository.models.chat_task_model import ChatTaskModel`
+
+**Classes:**
+- `ChatTaskModel(Base)` - SQLAlchemy model for chat tasks
+  - `id: Column[String]` - Primary key task identifier
+  - `session_id: Column[String]` - Foreign key to sessions table with CASCADE delete (indexed)
+  - `user_id: Column[String]` - User identifier (indexed)
+  - `user_message: Column[Text]` - Optional user message content
+  - `message_bubbles: Column[Text]` - Required message bubbles data
+  - `task_metadata: Column[Text]` - Optional task metadata
+  - `created_time: Column[BigInteger]` - Creation timestamp in epoch milliseconds (indexed)
+  - `updated_time: Column[BigInteger]` - Optional update timestamp
+  - `session: relationship` - SQLAlchemy relationship to SessionModel
+
+**Usage Examples:**
+```python
+from solace_agent_mesh.gateway.http_sse.repository.models.chat_task_model import ChatTaskModel
+from sqlalchemy.orm import sessionmaker
+
+# Create a chat task
+chat_task = ChatTaskModel(
+    id="task_123",
+    session_id="session_456",
+    user_id="user_789",
+    user_message="Hello, how can you help me?",
+    message_bubbles='[{"type": "user", "content": "Hello"}]',
+    task_metadata='{"priority": "high"}',
+    created_time=1640995200000,
+    updated_time=1640995260000
+)
+
+# Add to database
+Session = sessionmaker(bind=engine)
+db_session = Session()
+db_session.add(chat_task)
+db_session.commit()
+
+# Access related session
+session = chat_task.session
+```
+
 ### feedback_model.py
 **Purpose:** SQLAlchemy model for storing user feedback on tasks
 **Import:** `from solace_agent_mesh.gateway.http_sse.repository.models.feedback_model import FeedbackModel`
@@ -73,60 +116,8 @@ db_session.add(feedback)
 db_session.commit()
 ```
 
-### message_model.py
-**Purpose:** SQLAlchemy model and Pydantic schemas for storing chat messages with session relationships
-**Import:** `from solace_agent_mesh.gateway.http_sse.repository.models.message_model import MessageModel, CreateMessageModel, UpdateMessageModel`
-
-**Classes:**
-- `MessageModel(Base)` - SQLAlchemy model for chat messages
-  - `id: Column[String]` - Primary key message identifier
-  - `session_id: Column[String]` - Foreign key to sessions table with CASCADE delete
-  - `message: Column[Text]` - Message content
-  - `created_time: Column[BigInteger]` - Creation timestamp (auto-generated)
-  - `sender_type: Column[String]` - Type of message sender (max 50 chars)
-  - `sender_name: Column[String]` - Name of message sender (max 255 chars)
-  - `session: relationship` - SQLAlchemy relationship to SessionModel
-
-- `CreateMessageModel(BaseModel)` - Pydantic model for creating messages
-  - `id: str` - Message identifier
-  - `session_id: str` - Session identifier
-  - `message: str` - Message content
-  - `sender_type: str` - Sender type
-  - `sender_name: str` - Sender name
-  - `created_time: int` - Creation timestamp
-
-- `UpdateMessageModel(BaseModel)` - Pydantic model for updating messages
-  - `message: str` - Updated message content
-  - `sender_type: str` - Updated sender type
-  - `sender_name: str` - Updated sender name
-
-**Usage Examples:**
-```python
-from solace_agent_mesh.gateway.http_sse.repository.models.message_model import MessageModel, CreateMessageModel
-from sqlalchemy.orm import sessionmaker
-
-# Create using SQLAlchemy model
-message = MessageModel(
-    id="msg_123",
-    session_id="session_456",
-    message="Hello, world!",
-    sender_type="user",
-    sender_name="John Doe"
-)
-
-# Create using Pydantic model
-create_data = CreateMessageModel(
-    id="msg_124",
-    session_id="session_456",
-    message="How are you?",
-    sender_type="user",
-    sender_name="John Doe",
-    created_time=1640995200000
-)
-```
-
 ### session_model.py
-**Purpose:** SQLAlchemy model and Pydantic schemas for managing chat sessions with message relationships
+**Purpose:** SQLAlchemy model and Pydantic schemas for managing chat sessions with chat task relationships
 **Import:** `from solace_agent_mesh.gateway.http_sse.repository.models.session_model import SessionModel, CreateSessionModel, UpdateSessionModel`
 
 **Classes:**
@@ -137,7 +128,7 @@ create_data = CreateMessageModel(
   - `agent_id: Column[String]` - Optional agent identifier
   - `created_time: Column[BigInteger]` - Creation timestamp (auto-generated)
   - `updated_time: Column[BigInteger]` - Last update timestamp (auto-updated)
-  - `messages: relationship` - SQLAlchemy relationship to MessageModel with cascade delete
+  - `chat_tasks: relationship` - SQLAlchemy relationship to ChatTaskModel with cascade delete
 
 - `CreateSessionModel(BaseModel)` - Pydantic model for creating sessions
   - `id: str` - Session identifier
@@ -175,8 +166,8 @@ create_data = CreateSessionModel(
     updated_time=1640995200000
 )
 
-# Access related messages
-messages = session.messages  # Returns list of MessageModel instances
+# Access related chat tasks
+chat_tasks = session.chat_tasks  # Returns list of ChatTaskModel instances
 ```
 
 ### task_event_model.py
@@ -263,4 +254,4 @@ db_session.commit()
 events = task.events  # Returns list of TaskEventModel instances
 ```
 
-# content_hash: 0583795702abeb023659a686bf3cfa551016bdd0284b01f2448dd9d4d2050f3b
+# content_hash: 65d43bc49dd561efb9955aae2fc39945567e4302c406eea9718ce797d083646c

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

@@ -0,0 +1,51 @@
+"""
+SQLAlchemy model for project data.
+"""
+
+from sqlalchemy import Column, String, Boolean, BigInteger, Text
+from sqlalchemy.orm import relationship
+from pydantic import BaseModel
+
+from .base import Base
+
+
+class ProjectModel(Base):
+    """SQLAlchemy model for projects."""
+    
+    __tablename__ = "projects"
+    
+    id = Column(String, primary_key=True)
+    name = Column(String, nullable=False)
+    user_id = Column(String, nullable=False)
+    description = Column(Text, nullable=True)
+    system_prompt = Column(Text, nullable=True)
+    default_agent_id = Column(String, nullable=True)
+    created_at = Column(BigInteger, nullable=False)
+    updated_at = Column(BigInteger, nullable=True)  
+    deleted_at = Column(BigInteger, nullable=True)   
+    deleted_by = Column(String, nullable=True)       
+    
+    # Relationships
+    sessions = relationship("SessionModel", back_populates="project")
+    project_users = relationship("ProjectUserModel", back_populates="project", cascade="all, delete-orphan")
+
+
+class CreateProjectModel(BaseModel):
+    """Pydantic model for creating a project."""
+    id: str
+    name: str
+    user_id: str | None = None
+    description: str | None = None
+    system_prompt: str | None = None
+    default_agent_id: str | None = None
+    created_at: int
+    updated_at: int | None = None
+
+
+class UpdateProjectModel(BaseModel):
+    """Pydantic model for updating a project."""
+    name: str | None = None
+    description: str | None = None
+    system_prompt: str | None = None
+    default_agent_id: str | None = None
+    updated_at: int

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

@@ -0,0 +1,75 @@
+"""
+SQLAlchemy model for project user access (junction table).
+"""
+
+from enum import Enum
+from sqlalchemy import Column, String, BigInteger, ForeignKey, UniqueConstraint, Enum as SQLEnum
+from sqlalchemy.orm import relationship
+from pydantic import BaseModel, field_validator
+from typing import Literal
+
+from .base import Base
+
+
+class ProjectRole(str, Enum):
+    """Valid roles for project users."""
+    OWNER = "owner"
+    EDITOR = "editor"
+    VIEWER = "viewer"
+
+
+class ProjectUserModel(Base):
+    """
+    SQLAlchemy model for project user access.
+    
+    This junction table tracks which users have access to which projects,
+    enabling multi-user collaboration on projects.
+    """
+    
+    __tablename__ = "project_users"
+    
+    id = Column(String, primary_key=True)
+    project_id = Column(String, ForeignKey("projects.id", ondelete="CASCADE"), nullable=False)
+    user_id = Column(String, nullable=False)
+    role = Column(SQLEnum(ProjectRole), nullable=False, default=ProjectRole.VIEWER)
+    added_at = Column(BigInteger, nullable=False)  # Epoch timestamp in milliseconds
+    added_by_user_id = Column(String, nullable=False)  # User who granted access
+    
+    # Ensure a user can only be added once per project
+    __table_args__ = (
+        UniqueConstraint('project_id', 'user_id', name='uq_project_user'),
+    )
+    
+    # Relationships
+    project = relationship("ProjectModel", back_populates="project_users")
+
+
+class CreateProjectUserModel(BaseModel):
+    """Pydantic model for creating a project user access record."""
+    id: str
+    project_id: str
+    user_id: str
+    role: Literal["owner", "editor", "viewer"] = "viewer"
+    added_at: int
+    added_by_user_id: str
+    
+    @field_validator('role')
+    @classmethod
+    def validate_role(cls, v: str) -> str:
+        """Validate that role is one of the allowed values."""
+        if v not in [role.value for role in ProjectRole]:
+            raise ValueError(f"Role must be one of: {', '.join([role.value for role in ProjectRole])}")
+        return v
+
+
+class UpdateProjectUserModel(BaseModel):
+    """Pydantic model for updating a project user access record."""
+    role: Literal["owner", "editor", "viewer"] | None = None
+    
+    @field_validator('role')
+    @classmethod
+    def validate_role(cls, v: str | None) -> str | None:
+        """Validate that role is one of the allowed values."""
+        if v is not None and v not in [role.value for role in ProjectRole]:
+            raise ValueError(f"Role must be one of: {', '.join([role.value for role in ProjectRole])}")
+        return v

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

@@ -2,8 +2,8 @@
 Session SQLAlchemy model and Pydantic models for strongly-typed operations.
 """
 
+from sqlalchemy import BigInteger, Column, String, ForeignKey
 from pydantic import BaseModel
-from sqlalchemy import BigInteger, Column, String
 from sqlalchemy.orm import relationship
 
 from ...shared import now_epoch_ms
@@ -19,15 +19,19 @@ class SessionModel(Base):
     name = Column(String, nullable=True)
     user_id = Column(String, nullable=False)
     agent_id = Column(String, nullable=True)
+    project_id = Column(String, ForeignKey("projects.id"), nullable=True)
     created_time = Column(BigInteger, nullable=False, default=now_epoch_ms)
     updated_time = Column(
         BigInteger, nullable=False, default=now_epoch_ms, onupdate=now_epoch_ms
     )
+    deleted_at = Column(BigInteger, nullable=True)
+    deleted_by = Column(String, nullable=True)
 
     # Relationship to chat tasks
     chat_tasks = relationship(
         "ChatTaskModel", back_populates="session", cascade="all, delete-orphan"
     )
+    project = relationship("ProjectModel", back_populates="sessions")
 
 
 class CreateSessionModel(BaseModel):
@@ -36,6 +40,7 @@ class CreateSessionModel(BaseModel):
     name: str | None
     user_id: str
     agent_id: str | None
+    project_id: str | None = None
     created_time: int
     updated_time: int
 
@@ -44,4 +49,5 @@ class UpdateSessionModel(BaseModel):
     """Pydantic model for updating a session."""
     name: str | None = None
     agent_id: str | None = None
+    project_id: str | None = None
     updated_time: int

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,
+        )