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

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

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