solace-agent-mesh 1.6.1__py3-none-any.whl → 1.13.2__py3-none-any.whl

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

@@ -0,0 +1,159 @@
+"""
+Prompt SQLAlchemy models for prompt library feature.
+"""
+
+from enum import Enum
+from sqlalchemy import BigInteger, Column, String, Text, Integer, Boolean, ForeignKey, UniqueConstraint, Enum as SQLEnum
+from sqlalchemy.orm import relationship
+
+from solace_agent_mesh.shared.utils.timestamp_utils import now_epoch_ms
+from .base import Base
+
+
+class PromptGroupRole(str, Enum):
+    """Valid roles for prompt group users."""
+    OWNER = "owner"
+    EDITOR = "editor"
+    VIEWER = "viewer"
+
+
+class PromptGroupModel(Base):
+    """SQLAlchemy model for prompt groups"""
+    
+    __tablename__ = "prompt_groups"
+    
+    # Primary key - String type (not UUID)
+    id = Column(String, primary_key=True)
+    
+    # Core fields
+    name = Column(String(255), nullable=False, index=True)
+    description = Column(Text, nullable=True)
+    category = Column(String(100), nullable=True, index=True)
+    command = Column(String(50), nullable=True, unique=True, index=True)
+    
+    # Ownership
+    user_id = Column(String, nullable=False, index=True)
+    author_name = Column(String(255), nullable=True)
+    
+    # Production prompt reference
+    production_prompt_id = Column(
+        String, 
+        ForeignKey("prompts.id", ondelete="SET NULL"), 
+        nullable=True
+    )
+    
+    # Sharing (optional - for future enhancement)
+    is_shared = Column(Boolean, default=False, nullable=False)
+    
+    # User preferences
+    is_pinned = Column(Boolean, default=False, nullable=False, index=True)
+    
+    # Timestamps - BigInteger (epoch milliseconds) to match SAM convention
+    created_at = Column(BigInteger, nullable=False, default=now_epoch_ms)
+    updated_at = Column(
+        BigInteger, 
+        nullable=False, 
+        default=now_epoch_ms, 
+        onupdate=now_epoch_ms
+    )
+    
+    # Relationships
+    prompts = relationship(
+        "PromptModel",
+        back_populates="group",
+        foreign_keys="PromptModel.group_id",
+        cascade="all, delete-orphan"
+    )
+    production_prompt = relationship(
+        "PromptModel",
+        foreign_keys=[production_prompt_id],
+        post_update=True
+    )
+    prompt_group_users = relationship(
+        "PromptGroupUserModel",
+        back_populates="prompt_group",
+        cascade="all, delete-orphan"
+    )
+    
+    def __repr__(self):
+        return f"<PromptGroupModel(id={self.id}, name={self.name}, command={self.command})>"
+
+
+class PromptModel(Base):
+    """SQLAlchemy model for individual prompt versions"""
+    
+    __tablename__ = "prompts"
+    
+    # Primary key - String type (not UUID)
+    id = Column(String, primary_key=True)
+    
+    # Content
+    prompt_text = Column(Text, nullable=False)
+    
+    # Versioned metadata fields (copied from group at version creation time)
+    name = Column(String(255), nullable=True)
+    description = Column(Text, nullable=True)
+    category = Column(String(100), nullable=True)
+    command = Column(String(50), nullable=True)
+    
+    # Group relationship
+    group_id = Column(
+        String,
+        ForeignKey("prompt_groups.id", ondelete="CASCADE"),
+        nullable=False,
+        index=True
+    )
+    
+    # Ownership
+    user_id = Column(String, nullable=False, index=True)
+    
+    # Versioning
+    version = Column(Integer, default=1, nullable=False)
+    
+    # Timestamps - BigInteger (epoch milliseconds)
+    created_at = Column(BigInteger, nullable=False, default=now_epoch_ms)
+    updated_at = Column(
+        BigInteger,
+        nullable=False,
+        default=now_epoch_ms,
+        onupdate=now_epoch_ms
+    )
+    
+    # Relationships
+    group = relationship(
+        "PromptGroupModel",
+        back_populates="prompts",
+        foreign_keys=[group_id]
+    )
+    
+    def __repr__(self):
+        return f"<PromptModel(id={self.id}, group_id={self.group_id}, version={self.version})>"
+
+
+class PromptGroupUserModel(Base):
+    """
+    SQLAlchemy model for prompt group user access.
+    
+    This junction table tracks which users have access to which prompt groups,
+    enabling multi-user collaboration on prompts with role-based permissions.
+    """
+    
+    __tablename__ = "prompt_group_users"
+    
+    id = Column(String, primary_key=True)
+    prompt_group_id = Column(String, ForeignKey("prompt_groups.id", ondelete="CASCADE"), nullable=False)
+    user_id = Column(String, nullable=False)
+    role = Column(SQLEnum(PromptGroupRole), nullable=False, default=PromptGroupRole.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 prompt group
+    __table_args__ = (
+        UniqueConstraint('prompt_group_id', 'user_id', name='uq_prompt_group_user'),
+    )
+    
+    # Relationships
+    prompt_group = relationship("PromptGroupModel", back_populates="prompt_group_users")
+    
+    def __repr__(self):
+        return f"<PromptGroupUserModel(id={self.id}, prompt_group_id={self.prompt_group_id}, user_id={self.user_id}, role={self.role})>"

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

@@ -2,11 +2,11 @@
 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
+from solace_agent_mesh.shared.utils.timestamp_utils import now_epoch_ms
 from .base import Base
 
 
@@ -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/models/task_model.py

@@ -2,7 +2,7 @@
 Task SQLAlchemy model.
 """
 
-from sqlalchemy import BigInteger, Column, Integer, JSON, String, Text
+from sqlalchemy import BigInteger, Boolean, Column, Integer, JSON, String, Text
 from sqlalchemy.orm import relationship
 
 from .base import Base
@@ -15,6 +15,7 @@ class TaskModel(Base):
 
     id = Column(String, primary_key=True)
     user_id = Column(String, nullable=False, index=True)
+    parent_task_id = Column(String, nullable=True, index=True)
     start_time = Column(BigInteger, nullable=False)
     end_time = Column(BigInteger, nullable=True)
     status = Column(String, nullable=True)
@@ -25,6 +26,12 @@ class TaskModel(Base):
     total_output_tokens = Column(Integer, nullable=True)
     total_cached_input_tokens = Column(Integer, nullable=True)
     token_usage_details = Column(JSON, nullable=True)
+    
+    # Background task execution columns
+    execution_mode = Column(String(20), nullable=True, default="foreground", index=True)
+    last_activity_time = Column(BigInteger, nullable=True, index=True)
+    background_execution_enabled = Column(Boolean, nullable=True, default=False)
+    max_execution_time_ms = Column(BigInteger, nullable=True)
 
     # Relationship to events
     events = relationship(

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 solace_agent_mesh.shared.utils.timestamp_utils 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 solace_agent_mesh.shared.utils.timestamp_utils 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,
+        )