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

solace_agent_mesh/gateway/http_sse/repository/chat_task_repository.py

@@ -6,8 +6,8 @@ from typing import List, Optional
 
 from sqlalchemy.orm import Session as DBSession
 
-from ..shared import now_epoch_ms
-from ..shared.types import SessionId, UserId
+from solace_agent_mesh.shared.utils.timestamp_utils import now_epoch_ms
+from solace_agent_mesh.shared.utils.types import SessionId, UserId
 from .entities import ChatTask
 from .interfaces import IChatTaskRepository
 from .models import ChatTaskModel

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

@@ -0,0 +1,81 @@
+"""
+Project domain entity.
+"""
+
+from typing import Optional
+from pydantic import BaseModel, Field
+
+from solace_agent_mesh.shared.utils.timestamp_utils import now_epoch_ms
+
+
+class Project(BaseModel):
+    """Project domain entity with business logic."""
+    
+    id: str
+    name: str = Field(..., min_length=1, max_length=255)
+    user_id: str
+    description: Optional[str] = Field(None, max_length=1000)
+    system_prompt: Optional[str] = Field(None, max_length=4000)
+    default_agent_id: Optional[str] = None
+    created_at: int
+    updated_at: Optional[int] = None
+    deleted_at: Optional[int] = None
+    deleted_by: Optional[str] = None
+    
+    def update_name(self, new_name: str) -> None:
+        """Update project name with validation."""
+        if not new_name or len(new_name.strip()) == 0:
+            raise ValueError("Project name cannot be empty")
+        if len(new_name) > 255:
+            raise ValueError("Project name cannot exceed 255 characters")
+        
+        self.name = new_name.strip()
+        self.updated_at = now_epoch_ms()
+    
+    def update_description(self, new_description: Optional[str]) -> None:
+        """Update project description with validation."""
+        if new_description is not None:
+            if len(new_description) > 1000:
+                raise ValueError("Project description cannot exceed 1000 characters")
+            self.description = new_description.strip() if new_description else None
+        else:
+            self.description = None
+        
+        self.updated_at = now_epoch_ms()
+    
+    def update_default_agent(self, agent_id: Optional[str]) -> None:
+        """Update project default agent."""
+        self.default_agent_id = agent_id
+        self.updated_at = now_epoch_ms()
+    
+    def soft_delete(self, user_id: str) -> None:
+        """Soft delete the project."""
+        if not self.can_be_deleted_by_user(user_id):
+            raise ValueError("User does not have permission to delete this project")
+        
+        self.deleted_at = now_epoch_ms()
+        self.deleted_by = user_id
+        self.updated_at = now_epoch_ms()
+    
+    def is_deleted(self) -> bool:
+        """Check if project is soft deleted."""
+        return self.deleted_at is not None
+    
+    def can_be_accessed_by_user(self, user_id: str) -> bool:
+        """Check if project can be accessed by the given user."""
+        # User projects are only accessible by their owner and not deleted
+        return self.user_id == user_id and not self.is_deleted()
+    
+    def can_be_edited_by_user(self, user_id: str) -> bool:
+        """Check if project can be edited by the given user."""
+        # Users can only edit their own projects that are not deleted
+        return self.user_id == user_id and not self.is_deleted()
+    
+    def can_be_deleted_by_user(self, user_id: str) -> bool:
+        """Check if project can be deleted by the given user."""
+        # Users can only delete their own projects that are not already deleted
+        return self.user_id == user_id and not self.is_deleted()
+    
+    def mark_as_updated(self) -> None:
+        """Mark project as updated."""
+        self.updated_at = now_epoch_ms()

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

@@ -0,0 +1,47 @@
+"""
+Project user access domain entity.
+"""
+
+from typing import Optional
+from pydantic import BaseModel, Field
+
+from solace_agent_mesh.shared.utils.timestamp_utils import now_epoch_ms
+
+
+class ProjectUser(BaseModel):
+    """
+    Project user access domain entity.
+    
+    Represents a user's access to a project with a specific role.
+    """
+    
+    id: str
+    project_id: str
+    user_id: str
+    role: str = Field(..., pattern="^(owner|editor|viewer)$") 
+    added_at: int
+    added_by_user_id: str
+    
+    def can_edit_project(self) -> bool:
+        """Check if this user can edit the project based on their role."""
+        return self.role in ["owner", "editor"]
+    
+    def can_manage_users(self) -> bool:
+        """Check if this user can manage other users' access to the project."""
+        return self.role == "owner"
+    
+    def can_view_project(self) -> bool:
+        """Check if this user can view the project."""
+        return self.role in ["owner", "editor", "viewer"]
+    
+    def update_role(self, new_role: str) -> None:
+        """Update the user's role with validation."""
+        valid_roles = ["owner", "editor", "viewer"]
+        if new_role not in valid_roles:
+            raise ValueError(f"Invalid role. Must be one of: {', '.join(valid_roles)}")
+        
+        self.role = new_role
+    
+    class Config:
+        """Pydantic configuration."""
+        frozen = False  

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

@@ -4,8 +4,8 @@ Session domain entity.
 
 from pydantic import BaseModel, ConfigDict
 
-from ...shared import now_epoch_ms
-from ...shared.types import AgentId, SessionId, UserId
+from solace_agent_mesh.shared.utils.timestamp_utils import now_epoch_ms
+from solace_agent_mesh.shared.utils.types import AgentId, SessionId, UserId
 
 
 class Session(BaseModel):
@@ -17,8 +17,13 @@ class Session(BaseModel):
     user_id: UserId
     name: str | None = None
     agent_id: AgentId | None = None
+    project_id: str | None = None
+    project_name: str | None = None
+    has_running_background_task: bool = False  # Enriched field, not stored in DB
     created_time: int
     updated_time: int | None = None
+    deleted_at: int | None = None
+    deleted_by: str | None = None
 
     def update_name(self, new_name: str) -> None:
         """Update session name with validation."""
@@ -34,10 +39,28 @@ class Session(BaseModel):
         """Mark session as having recent activity."""
         self.updated_time = now_epoch_ms()
 
+    def soft_delete(self, user_id: UserId) -> None:
+        """Soft delete the session."""
+        if not self.can_be_deleted_by_user(user_id):
+            raise ValueError("User does not have permission to delete this session")
+        
+        self.deleted_at = now_epoch_ms()
+        self.deleted_by = user_id
+        self.updated_time = now_epoch_ms()
+
+    def is_deleted(self) -> bool:
+        """Check if session is soft deleted."""
+        return self.deleted_at is not None
+
+    def move_to_project(self, new_project_id: str | None) -> None:
+        """Move session to a different project."""
+        self.project_id = new_project_id
+        self.updated_time = now_epoch_ms()
+
     def can_be_deleted_by_user(self, user_id: UserId) -> bool:
         """Check if user can delete this session."""
         return self.user_id == user_id
 
     def can_be_accessed_by_user(self, user_id: UserId) -> bool:
         """Check if user can access this session."""
-        return self.user_id == user_id
+        return self.user_id == user_id and not self.is_deleted()

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

@@ -10,6 +10,7 @@ class Task(BaseModel):
 
     id: str
     user_id: str
+    parent_task_id: str | None = None
     start_time: int
     end_time: int | None = None
     status: str | None = None
@@ -20,6 +21,12 @@ class Task(BaseModel):
     total_output_tokens: int | None = None
     total_cached_input_tokens: int | None = None
     token_usage_details: dict | None = None
+    
+    # Background task execution fields
+    execution_mode: str | None = "foreground"
+    last_activity_time: int | None = None
+    background_execution_enabled: bool | None = False
+    max_execution_time_ms: int | None = None
 
     class Config:
         from_attributes = True

solace_agent_mesh/gateway/http_sse/repository/feedback_repository.py

@@ -4,6 +4,8 @@ Feedback repository implementation using SQLAlchemy.
 
 from sqlalchemy.orm import Session as DBSession
 
+from solace_agent_mesh.shared.api.pagination import PaginationParams
+from solace_agent_mesh.shared.utils.types import UserId
 from .entities import Feedback
 from .interfaces import IFeedbackRepository
 from .models import FeedbackModel
@@ -28,6 +30,51 @@ class FeedbackRepository(IFeedbackRepository):
         session.refresh(model)
         return self._model_to_entity(model)
 
+    def search(
+        self,
+        session: DBSession,
+        user_id: UserId,
+        start_date: int | None = None,
+        end_date: int | None = None,
+        task_id: str | None = None,
+        session_id: str | None = None,
+        rating: str | None = None,
+        pagination: PaginationParams | None = None,
+    ) -> list[Feedback]:
+        """
+        Search feedback with flexible filtering.
+        All filters are optional and can be combined.
+        """
+        query = session.query(FeedbackModel)
+
+        # User filter (unless admin querying all users)
+        if user_id != "*":
+            query = query.filter(FeedbackModel.user_id == user_id)
+
+        # Time-based filters
+        if start_date:
+            query = query.filter(FeedbackModel.created_time >= start_date)
+        if end_date:
+            query = query.filter(FeedbackModel.created_time <= end_date)
+
+        # Resource-based filters
+        if task_id:
+            query = query.filter(FeedbackModel.task_id == task_id)
+        if session_id:
+            query = query.filter(FeedbackModel.session_id == session_id)
+        if rating:
+            query = query.filter(FeedbackModel.rating == rating)
+
+        # Order by most recent first
+        query = query.order_by(FeedbackModel.created_time.desc())
+
+        # Apply pagination
+        if pagination:
+            query = query.offset(pagination.offset).limit(pagination.page_size)
+
+        models = query.all()
+        return [self._model_to_entity(model) for model in models]
+
     def delete_feedback_older_than(self, session: DBSession, cutoff_time_ms: int, batch_size: int) -> int:
         """
         Delete feedback records older than the cutoff time.

solace_agent_mesh/gateway/http_sse/repository/interfaces.py

@@ -6,9 +6,11 @@ from abc import ABC, abstractmethod
 from typing import TYPE_CHECKING, Optional
 from sqlalchemy.orm import Session as DBSession
 
-from ..shared.pagination import PaginationParams
-from ..shared.types import SessionId, UserId
+from solace_agent_mesh.shared.api.pagination import PaginationParams
+from solace_agent_mesh.shared.utils.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,17 +5,30 @@ SQLAlchemy models and Pydantic models for database persistence.
 from .base import Base
 from .chat_task_model import ChatTaskModel
 from .feedback_model import FeedbackModel
+from .project_model import ProjectModel, CreateProjectModel, UpdateProjectModel
+from .project_user_model import ProjectUserModel, CreateProjectUserModel, UpdateProjectUserModel
 from .session_model import SessionModel, CreateSessionModel, UpdateSessionModel
 from .task_event_model import TaskEventModel
 from .task_model import TaskModel
+from .prompt_model import PromptGroupModel, PromptModel, PromptGroupUserModel
 
 __all__ = [
     "Base",
     "ChatTaskModel",
+    "FeedbackModel",
+    "ProjectModel",
+    "ProjectUserModel",
     "SessionModel",
+    "CreateProjectModel",
+    "UpdateProjectModel",
+    "CreateProjectUserModel",
+    "UpdateProjectUserModel",
     "CreateSessionModel",
     "UpdateSessionModel",
     "TaskEventModel",
     "TaskModel",
     "FeedbackModel",
+    "PromptGroupModel",
+    "PromptModel",
+    "PromptGroupUserModel",
 ]

solace_agent_mesh/gateway/http_sse/repository/models/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