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

solace_agent_mesh/gateway/http_sse/services/project_service.py

@@ -0,0 +1,403 @@
+"""
+Business service for project-related operations.
+"""
+
+from typing import List, Optional, TYPE_CHECKING
+import logging
+from fastapi import UploadFile
+from datetime import datetime, timezone
+
+from ....agent.utils.artifact_helpers import get_artifact_info_list, save_artifact_with_metadata
+
+try:
+    from google.adk.artifacts import BaseArtifactService
+except ImportError:
+
+    class BaseArtifactService:
+        pass
+
+
+from ....common.a2a.types import ArtifactInfo
+from ..repository.interfaces import IProjectRepository
+from ..repository.entities.project import Project
+
+if TYPE_CHECKING:
+    from ..component import WebUIBackendComponent
+
+
+class ProjectService:
+    """Service layer for project business logic."""
+
+    def __init__(
+        self,
+        component: "WebUIBackendComponent" = None,
+    ):
+        self.component = component
+        self.artifact_service = component.get_shared_artifact_service() if component else None
+        self.app_name = component.get_config("name", "WebUIBackendApp") if component else "WebUIBackendApp"
+        self.logger = logging.getLogger(__name__)
+
+    def _get_repositories(self, db):
+        """Create project repository for the given database session."""
+        from ..repository.project_repository import ProjectRepository
+        return ProjectRepository(db)
+
+    def is_persistence_enabled(self) -> bool:
+        """Checks if the service is configured with a persistent backend."""
+        return self.component and self.component.database_url is not None
+
+    async def create_project(
+        self,
+        db,
+        name: str,
+        user_id: str,
+        description: Optional[str] = None,
+        system_prompt: Optional[str] = None,
+        default_agent_id: Optional[str] = None,
+        files: Optional[List[UploadFile]] = None,
+        file_metadata: Optional[dict] = None,
+    ) -> Project:
+        """
+        Create a new project for a user.
+
+        Args:
+            db: Database session
+            name: Project name
+            user_id: ID of the user creating the project
+            description: Optional project description
+            system_prompt: Optional system prompt
+            default_agent_id: Optional default agent ID for new chats
+            files: Optional list of files to associate with the project
+
+        Returns:
+            DomainProject: The created project
+
+        Raises:
+            ValueError: If project name is invalid or user_id is missing
+        """
+        self.logger.info(f"Creating new project '{name}' for user {user_id}")
+
+        # Business validation
+        if not name or not name.strip():
+            raise ValueError("Project name cannot be empty")
+
+        if not user_id:
+            raise ValueError("User ID is required to create a project")
+
+        project_repository = self._get_repositories(db)
+
+        # Check for duplicate project name for this user
+        existing_projects = project_repository.get_user_projects(user_id)
+        if any(p.name.lower() == name.strip().lower() for p in existing_projects):
+            raise ValueError(f"A project with the name '{name.strip()}' already exists")
+
+        # Create the project
+        project_domain = project_repository.create_project(
+            name=name.strip(),
+            user_id=user_id,
+            description=description.strip() if description else None,
+            system_prompt=system_prompt.strip() if system_prompt else None,
+            default_agent_id=default_agent_id,
+        )
+
+        if files and self.artifact_service:
+            self.logger.info(
+                f"Project {project_domain.id} created, now saving {len(files)} artifacts."
+            )
+            project_session_id = f"project-{project_domain.id}"
+            for file in files:
+                content_bytes = await file.read()
+                metadata = {"source": "project"}
+                if file_metadata and file.filename in file_metadata:
+                    desc = file_metadata[file.filename]
+                    if desc:
+                        metadata["description"] = desc
+
+                await save_artifact_with_metadata(
+                    artifact_service=self.artifact_service,
+                    app_name=self.app_name,
+                    user_id=project_domain.user_id,
+                    session_id=project_session_id,
+                    filename=file.filename,
+                    content_bytes=content_bytes,
+                    mime_type=file.content_type,
+                    metadata_dict=metadata,
+                    timestamp=datetime.now(timezone.utc),
+                )
+            self.logger.info(f"Saved {len(files)} artifacts for project {project_domain.id}")
+
+        self.logger.info(
+            f"Successfully created project {project_domain.id} for user {user_id}"
+        )
+        return project_domain
+
+    def get_project(self, db, project_id: str, user_id: str) -> Optional[Project]:
+        """
+        Get a project by ID, ensuring the user has access to it.
+
+        Args:
+            db: Database session
+            project_id: The project ID
+            user_id: The requesting user ID
+
+        Returns:
+            Optional[Project]: The project if found and accessible, None otherwise
+        """
+        project_repository = self._get_repositories(db)
+        return project_repository.get_by_id(project_id, user_id)
+
+    def get_user_projects(self, db, user_id: str) -> List[Project]:
+        """
+        Get all projects owned by a specific user.
+
+        Args:
+            db: Database session
+            user_id: The user ID
+            
+        Returns:
+            List[DomainProject]: List of user's projects
+        """
+        self.logger.debug(f"Retrieving projects for user {user_id}")
+        project_repository = self._get_repositories(db)
+        db_projects = project_repository.get_user_projects(user_id)
+        return db_projects
+
+    async def get_project_artifacts(self, db, project_id: str, user_id: str) -> List[ArtifactInfo]:
+        """
+        Get a list of artifacts for a given project.
+        
+        Args:
+            db: The database session
+            project_id: The project ID
+            user_id: The requesting user ID
+            
+        Returns:
+            List[ArtifactInfo]: A list of artifacts
+            
+        Raises:
+            ValueError: If project not found or access denied
+        """
+        project = self.get_project(db, project_id, user_id)
+        if not project:
+            raise ValueError("Project not found or access denied")
+
+        if not self.artifact_service:
+            self.logger.warning(f"Attempted to get artifacts for project {project_id} but no artifact service is configured.")
+            return []
+
+        storage_user_id = project.user_id
+        storage_session_id = f"project-{project.id}"
+
+        self.logger.info(f"Fetching artifacts for project {project.id} with storage session {storage_session_id} and user {storage_user_id}")
+
+        artifacts = await get_artifact_info_list(
+            artifact_service=self.artifact_service,
+            app_name=self.app_name,
+            user_id=storage_user_id,
+            session_id=storage_session_id,
+        )
+        return artifacts
+
+    async def add_artifacts_to_project(
+        self,
+        db,
+        project_id: str,
+        user_id: str,
+        files: List[UploadFile],
+        file_metadata: Optional[dict] = None
+    ) -> List[dict]:
+        """
+        Add one or more artifacts to a project.
+        
+        Args:
+            db: The database session
+            project_id: The project ID
+            user_id: The requesting user ID
+            files: List of files to add
+            file_metadata: Optional dictionary of metadata (e.g., descriptions)
+            
+        Returns:
+            List[dict]: A list of results from the save operations
+            
+        Raises:
+            ValueError: If project not found or access denied
+        """
+        project = self.get_project(db, project_id, user_id)
+        if not project:
+            raise ValueError("Project not found or access denied")
+
+        if not self.artifact_service:
+            self.logger.warning(f"Attempted to add artifacts to project {project_id} but no artifact service is configured.")
+            raise ValueError("Artifact service is not configured")
+        
+        if not files:
+            return []
+
+        self.logger.info(f"Adding {len(files)} artifacts to project {project_id} for user {user_id}")
+        storage_session_id = f"project-{project.id}"
+        results = []
+
+        for file in files:
+            content_bytes = await file.read()
+            metadata = {"source": "project"}
+            if file_metadata and file.filename in file_metadata:
+                desc = file_metadata[file.filename]
+                if desc:
+                    metadata["description"] = desc
+            
+            result = await save_artifact_with_metadata(
+                artifact_service=self.artifact_service,
+                app_name=self.app_name,
+                user_id=project.user_id, # Always use project owner's ID for storage
+                session_id=storage_session_id,
+                filename=file.filename,
+                content_bytes=content_bytes,
+                mime_type=file.content_type,
+                metadata_dict=metadata,
+                timestamp=datetime.now(timezone.utc),
+            )
+            results.append(result)
+        
+        self.logger.info(f"Finished adding {len(files)} artifacts to project {project_id}")
+        return results
+
+    async def delete_artifact_from_project(self, db, project_id: str, user_id: str, filename: str) -> bool:
+        """
+        Deletes an artifact from a project.
+        
+        Args:
+            db: The database session
+            project_id: The project ID
+            user_id: The requesting user ID
+            filename: The filename of the artifact to delete
+            
+        Returns:
+            bool: True if deletion was attempted, False if project not found
+            
+        Raises:
+            ValueError: If user cannot modify the project or artifact service is missing
+        """
+        project = self.get_project(db, project_id, user_id)
+        if not project:
+            return False
+
+        if not self.artifact_service:
+            self.logger.warning(f"Attempted to delete artifact from project {project_id} but no artifact service is configured.")
+            raise ValueError("Artifact service is not configured")
+
+        storage_session_id = f"project-{project.id}"
+        
+        self.logger.info(f"Deleting artifact '{filename}' from project {project_id} for user {user_id}")
+        
+        await self.artifact_service.delete_artifact(
+            app_name=self.app_name,
+            user_id=project.user_id, # Always use project owner's ID for storage
+            session_id=storage_session_id,
+            filename=filename,
+        )
+        return True
+
+    def update_project(self, db, project_id: str, user_id: str,
+                           name: Optional[str] = None, description: Optional[str] = None,
+                           system_prompt: Optional[str] = None, default_agent_id: Optional[str] = ...) -> Optional[Project]:
+        """
+        Update a project's details.
+
+        Args:
+            db: Database session
+            project_id: The project ID
+            user_id: The requesting user ID
+            name: New project name (optional)
+            description: New project description (optional)
+            system_prompt: New system prompt (optional)
+            default_agent_id: New default agent ID (optional, use ... sentinel to indicate not provided)
+
+        Returns:
+            Optional[Project]: The updated project if successful, None otherwise
+        """
+        # Validate business rules
+        if name is not None and name is not ... and not name.strip():
+            raise ValueError("Project name cannot be empty")
+
+        # Build update data
+        update_data = {}
+        if name is not None and name is not ...:
+            update_data["name"] = name.strip()
+        if description is not None and description is not ...:
+            update_data["description"] = description.strip() if description else None
+        if system_prompt is not None and system_prompt is not ...:
+            update_data["system_prompt"] = system_prompt.strip() if system_prompt else None
+        if default_agent_id is not ...:
+            update_data["default_agent_id"] = default_agent_id
+
+        if not update_data:
+            # Nothing to update - get existing project
+            return self.get_project(db, project_id, user_id)
+
+        project_repository = self._get_repositories(db)
+        self.logger.info(f"Updating project {project_id} for user {user_id}")
+        updated_project = project_repository.update(project_id, user_id, update_data)
+
+        if updated_project:
+            self.logger.info(f"Successfully updated project {project_id}")
+
+        return updated_project
+
+    def delete_project(self, db, project_id: str, user_id: str) -> bool:
+        """
+        Delete a project.
+
+        Args:
+            db: Database session
+            project_id: The project ID
+            user_id: The requesting user ID
+
+        Returns:
+            bool: True if deleted successfully, False otherwise
+        """
+        # First verify the project exists and user has access
+        existing_project = self.get_project(db, project_id, user_id)
+        if not existing_project:
+            return False
+
+        project_repository = self._get_repositories(db)
+        self.logger.info(f"Deleting project {project_id} for user {user_id}")
+        success = project_repository.delete(project_id, user_id)
+
+        if success:
+            self.logger.info(f"Successfully deleted project {project_id}")
+
+        return success
+
+    def soft_delete_project(self, db, project_id: str, user_id: str) -> bool:
+        """
+        Soft delete a project (mark as deleted without removing from database).
+        Also cascades soft delete to all sessions associated with this project.
+
+        Args:
+            db: Database session
+            project_id: The project ID
+            user_id: The requesting user ID
+
+        Returns:
+            bool: True if soft deleted successfully, False otherwise
+        """
+        # First verify the project exists and user has access
+        existing_project = self.get_project(db, project_id, user_id)
+        if not existing_project:
+            self.logger.warning(f"Attempted to soft delete non-existent project {project_id} by user {user_id}")
+            return False
+
+        self.logger.info(f"Soft deleting project {project_id} and its associated sessions for user {user_id}")
+
+        project_repository = self._get_repositories(db)
+        # Soft delete the project
+        success = project_repository.soft_delete(project_id, user_id)
+
+        if success:
+            from ..repository.session_repository import SessionRepository
+            session_repo = SessionRepository()
+            deleted_count = session_repo.soft_delete_by_project(db, project_id, user_id)
+            self.logger.info(f"Successfully soft deleted project {project_id} and {deleted_count} associated sessions")
+
+        return success

solace_agent_mesh/gateway/http_sse/services/services_llm.txt

@@ -58,7 +58,7 @@ else:
   - `cleanup_old_data() -> None` - Main orchestration method for cleaning up old data, calls cleanup methods for tasks and feedback
 
 **Constants/Variables:**
-- `MIN_RETENTION_DAYS: int` - Minimum retention period (7 days)
+- `MIN_RETENTION_DAYS: int` - Minimum retention period (1 day)
 - `MIN_CLEANUP_INTERVAL_HOURS: int` - Minimum cleanup interval (1 hour)
 - `MIN_BATCH_SIZE: int` - Minimum batch size for deletion (1)
 - `MAX_BATCH_SIZE: int` - Maximum batch size for deletion (10000)
@@ -160,16 +160,16 @@ asyncio.run(search_users())
   - `is_persistence_enabled() -> bool` - Checks if the service is configured with a persistent backend
   - `get_user_sessions(db: DbSession, user_id: UserId, pagination: PaginationParams | None = None) -> PaginatedResponse[Session]` - Retrieves paginated sessions for a user
   - `get_session_details(db: DbSession, session_id: SessionId, user_id: UserId) -> Session | None` - Gets session details for a specific session
-  - `get_session_history(db: DbSession, session_id: SessionId, user_id: UserId, pagination: PaginationInfo | None = None) -> SessionHistory | None` - Gets session with messages
   - `create_session(db: DbSession, user_id: UserId, name: str | None = None, agent_id: str | None = None, session_id: str | None = None) -> Optional[Session]` - Creates a new session
   - `update_session_name(db: DbSession, session_id: SessionId, user_id: UserId, name: str) -> Session | None` - Updates session name
   - `delete_session_with_notifications(db: DbSession, session_id: SessionId, user_id: UserId) -> bool` - Deletes session and notifies agents
-  - `add_message_to_session(db: DbSession, session_id: SessionId, user_id: UserId, message: str, sender_type: SenderType, sender_name: str, agent_id: str | None = None, message_type: MessageType = MessageType.TEXT) -> Message` - Adds a message to a session
+  - `save_task(db: DbSession, task_id: str, session_id: str, user_id: str, user_message: Optional[str], message_bubbles: str, task_metadata: Optional[str] = None) -> ChatTask` - Saves a complete task interaction
+  - `get_session_tasks(db: DbSession, session_id: str, user_id: str) -> List[ChatTask]` - Gets all tasks for a session
+  - `get_session_messages_from_tasks(db: DbSession, session_id: str, user_id: str) -> List[Dict[str, Any]]` - Gets session messages by flattening task message_bubbles for backward compatibility
 
 **Usage Examples:**
 ```python
 from solace_agent_mesh.gateway.http_sse.services.session_service import SessionService
-from solace_agent_mesh.gateway.http_sse.shared.enums import SenderType, MessageType
 from sqlalchemy.orm import Session as DbSession
 
 # Initialize with component
@@ -186,14 +186,20 @@ with your_session_factory() as db:
         agent_id="assistant-agent"
     )
 
-    # Add a message to the session
-    message = session_service.add_message_to_session(
+    # Save a task with message bubbles
+    import json
+    message_bubbles = json.dumps([
+        {"type": "user", "text": "Hello", "id": "msg1"},
+        {"type": "agent", "text": "Hi there!", "id": "msg2"}
+    ])
+    
+    task = session_service.save_task(
         db=db,
+        task_id="task-123",
         session_id=session.id,
         user_id="user123",
-        message="Hello, how can you help me?",
-        sender_type=SenderType.USER,
-        sender_name="John Doe"
+        user_message="Hello",
+        message_bubbles=message_bubbles
     )
 
     # Get user's sessions with pagination
@@ -294,4 +300,4 @@ async def cancel_task_example():
 asyncio.run(cancel_task_example())
 ```
 
-# content_hash: 12385f5117d2f5c30f0e44a0913ea91d62722aa82eb55268ae6bd317311ec5eb
+# content_hash: 09bc3008d9a6c148b0b9d7477d20b26514f7fc4ee72f36eda5348f8f7d51f2ea

solace_agent_mesh/gateway/http_sse/services/session_service.py

@@ -42,13 +42,19 @@ class SessionService:
         self,
         db: DbSession,
         user_id: UserId,
-        pagination: PaginationParams | None = None
+        pagination: PaginationParams | None = None,
+        project_id: str | None = None
     ) -> PaginatedResponse[Session]:
         """
-        Get paginated sessions for a user with full metadata.
-
+        Get paginated sessions for a user with full metadata including project names.
         Uses default pagination if none provided (page 1, size 20).
         Returns paginated response with pageNumber, pageSize, nextPage, totalPages, totalCount.
+
+        Args:
+            db: Database session
+            user_id: User ID to filter sessions by
+            pagination: Pagination parameters
+            project_id: Optional project ID to filter sessions by (for project-specific views)
         """
         if not user_id or user_id.strip() == "":
             raise ValueError("User ID cannot be empty")
@@ -56,9 +62,24 @@ class SessionService:
         pagination = get_pagination_or_default(pagination)
         session_repository = self._get_repositories(db)
 
-        # Pass pagination params directly - repository will handle offset calculation
-        sessions = session_repository.find_by_user(db, user_id, pagination)
-        total_count = session_repository.count_by_user(db, user_id)
+        # Fetch sessions with optional project filtering
+        sessions = session_repository.find_by_user(db, user_id, pagination, project_id=project_id)
+        total_count = session_repository.count_by_user(db, user_id, project_id=project_id)
+
+        # Enrich sessions with project names
+        # Collect unique project IDs
+        project_ids = [s.project_id for s in sessions if s.project_id]
+
+        if project_ids:
+            # Fetch all projects in one query
+            from ..repository.models import ProjectModel
+            projects = db.query(ProjectModel).filter(ProjectModel.id.in_(project_ids)).all()
+            project_map = {p.id: p.name for p in projects}
+
+            # Map project names to sessions
+            for session in sessions:
+                if session.project_id:
+                    session.project_name = project_map.get(session.project_id)
 
         return PaginatedResponse.create(sessions, total_count, pagination)
 
@@ -78,6 +99,7 @@ class SessionService:
         name: str | None = None,
         agent_id: str | None = None,
         session_id: str | None = None,
+        project_id: str | None = None,
     ) -> Optional[Session]:
         if not self.is_persistence_enabled():
             log.debug("Persistence is not enabled. Skipping session creation in DB.")
@@ -95,6 +117,7 @@ class SessionService:
             user_id=user_id,
             name=name,
             agent_id=agent_id,
+            project_id=project_id,
             created_time=now_ms,
             updated_time=now_ms,
         )
@@ -166,6 +189,155 @@ class SessionService:
 
         return True
 
+    def soft_delete_session(
+        self, db: DbSession, session_id: SessionId, user_id: UserId
+    ) -> bool:
+        """
+        Soft delete a session (mark as deleted without removing from database).
+        
+        Args:
+            db: Database session
+            session_id: Session ID to soft delete
+            user_id: User ID performing the deletion
+            
+        Returns:
+            bool: True if soft deleted successfully, False otherwise
+        """
+        if not self._is_valid_session_id(session_id):
+            raise ValueError("Invalid session ID")
+
+        session_repository = self._get_repositories(db)
+        session = session_repository.find_user_session(db, session_id, user_id)
+        if not session:
+            log.warning(
+                "Attempted to soft delete non-existent session %s by user %s",
+                session_id,
+                user_id,
+            )
+            return False
+
+        if not session.can_be_deleted_by_user(user_id):
+            log.warning(
+                "User %s not authorized to soft delete session %s", user_id, session_id
+            )
+            return False
+
+        deleted = session_repository.soft_delete(db, session_id, user_id)
+        if not deleted:
+            return False
+
+        log.info("Session %s soft deleted successfully by user %s", session_id, user_id)
+        return True
+
+    def move_session_to_project(
+        self, db: DbSession, session_id: SessionId, user_id: UserId, new_project_id: str | None
+    ) -> Session | None:
+        """
+        Move a session to a different project.
+        
+        Args:
+            db: Database session
+            session_id: Session ID to move
+            user_id: User ID performing the move
+            new_project_id: New project ID (or None to remove from project)
+            
+        Returns:
+            Session: Updated session if successful, None otherwise
+            
+        Raises:
+            ValueError: If session or project validation fails
+        """
+        if not self._is_valid_session_id(session_id):
+            raise ValueError("Invalid session ID")
+
+        # Validate project exists and user has access if project_id is provided
+        if new_project_id:
+            from ..repository.models import ProjectModel
+            project = db.query(ProjectModel).filter(
+                ProjectModel.id == new_project_id,
+                ProjectModel.user_id == user_id,
+                ProjectModel.deleted_at.is_(None)
+            ).first()
+            
+            if not project:
+                raise ValueError(f"Project {new_project_id} not found or access denied")
+
+        session_repository = self._get_repositories(db)
+        updated_session = session_repository.move_to_project(db, session_id, user_id, new_project_id)
+        
+        if not updated_session:
+            log.warning(
+                "Failed to move session %s to project %s for user %s",
+                session_id,
+                new_project_id,
+                user_id,
+            )
+            return None
+
+        log.info(
+            "Session %s moved to project %s by user %s",
+            session_id,
+            new_project_id or "None",
+            user_id,
+        )
+        return updated_session
+
+    def search_sessions(
+        self,
+        db: DbSession,
+        user_id: UserId,
+        query: str,
+        pagination: PaginationParams | None = None,
+        project_id: str | None = None
+    ) -> PaginatedResponse[Session]:
+        """
+        Search sessions by name or content.
+        
+        Args:
+            db: Database session
+            user_id: User ID to filter sessions by
+            query: Search query string
+            pagination: Pagination parameters
+            project_id: Optional project ID to filter sessions by
+            
+        Returns:
+            PaginatedResponse[Session]: Paginated search results
+        """
+        if not user_id or user_id.strip() == "":
+            raise ValueError("User ID cannot be empty")
+
+        if not query or query.strip() == "":
+            raise ValueError("Search query cannot be empty")
+
+        pagination = get_pagination_or_default(pagination)
+        session_repository = self._get_repositories(db)
+
+        # Search sessions
+        sessions = session_repository.search(db, user_id, query.strip(), pagination, project_id)
+        total_count = session_repository.count_search_results(db, user_id, query.strip(), project_id)
+
+        # Enrich sessions with project names
+        project_ids = [s.project_id for s in sessions if s.project_id]
+
+        if project_ids:
+            from ..repository.models import ProjectModel
+            projects = db.query(ProjectModel).filter(ProjectModel.id.in_(project_ids)).all()
+            project_map = {p.id: p.name for p in projects}
+
+            for session in sessions:
+                if session.project_id:
+                    session.project_name = project_map.get(session.project_id)
+
+        log.info(
+            "Search for '%s' by user %s returned %d results (total: %d)",
+            query,
+            user_id,
+            len(sessions),
+            total_count,
+        )
+
+        return PaginatedResponse.create(sessions, total_count, pagination)
+
     def save_task(
         self,
         db: DbSession,