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

solace_agent_mesh/gateway/http_sse/routers/dto/responses/version_responses.py

@@ -0,0 +1,31 @@
+"""
+Version-related response DTOs.
+"""
+
+from typing import Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class ProductInfo(BaseModel):
+    """Information about a single installed product."""
+
+    model_config = ConfigDict(populate_by_name=True)
+
+    id: str = Field(..., description="Product identifier")
+    name: str = Field(..., description="Human-readable product name")
+    description: str = Field(..., description="Product description")
+    version: str = Field(..., description="Product version")
+    dependencies: Optional[dict[str, str]] = Field(
+        default=None, description="Optional map of dependency names to versions"
+    )
+
+
+class VersionResponse(BaseModel):
+    """Response containing version information for all installed products."""
+
+    model_config = ConfigDict(populate_by_name=True)
+
+    products: list[ProductInfo] = Field(
+        ..., description="List of installed product information"
+    )

solace_agent_mesh/gateway/http_sse/routers/feedback.py

@@ -22,8 +22,8 @@ from ..repository.entities import Feedback
 from ..repository.feedback_repository import FeedbackRepository
 from ..repository.interfaces import ITaskRepository
 from ..services.feedback_service import FeedbackService
-from ..shared.pagination import PaginationParams
-from ..shared.types import UserId
+from solace_agent_mesh.shared.api.pagination import PaginationParams
+from solace_agent_mesh.shared.utils.types import UserId
 
 router = APIRouter()
 log = logging.getLogger(__name__)

solace_agent_mesh/gateway/http_sse/routers/people.py

@@ -9,8 +9,8 @@ from fastapi import APIRouter, Depends, Query
 
 from ..dependencies import get_people_service
 from ..services.people_service import PeopleService
-from ..shared.pagination import DataResponse
-from ..shared.response_utils import create_data_response
+from solace_agent_mesh.shared.api.pagination import DataResponse
+from solace_agent_mesh.shared.api.response_utils import create_data_response
 
 log = logging.getLogger(__name__)
 

solace_agent_mesh/gateway/http_sse/routers/projects.py

@@ -1,6 +1,7 @@
 """
 Project API controller using 3-tiered architecture.
 """
+from __future__ import annotations
 
 import json
 from typing import List, Optional, Dict, Any
@@ -14,12 +15,13 @@ from fastapi import (
     File,
     UploadFile,
 )
+from fastapi.responses import StreamingResponse
 from sqlalchemy.orm import Session
 from solace_ai_connector.common.log import log
 
 from ..dependencies import get_project_service, get_sac_component, get_api_config, get_db
 from ..services.project_service import ProjectService
-from ..shared.auth_utils import get_current_user
+from solace_agent_mesh.shared.api.auth_utils import get_current_user
 from ....common.a2a.types import ArtifactInfo
 from typing import TYPE_CHECKING
 
@@ -37,6 +39,10 @@ from .dto.responses.project_responses import (
     ProjectResponse,
     ProjectListResponse,
 )
+from .dto.project_dto import (
+    ProjectImportOptions,
+    ProjectImportResponse,
+)
 
 router = APIRouter()
 
@@ -150,10 +156,17 @@ async def create_project(
         )
     
     except ValueError as e:
-        log.warning(f"Validation error creating project: {e}")
+        error_msg = str(e)
+        log.warning(f"Validation error creating project: {error_msg}")
+        # Check if this is a file size error
+        if "exceeds maximum" in error_msg.lower() and "bytes" in error_msg.lower():
+            raise HTTPException(
+                status_code=status.HTTP_413_REQUEST_ENTITY_TOO_LARGE,
+                detail=error_msg
+            )
         raise HTTPException(
             status_code=status.HTTP_400_BAD_REQUEST,
-            detail=str(e)
+            detail=error_msg
         )
     except Exception as e:
         log.error("Error creating project for user %s: %s", user_id, e)
@@ -165,6 +178,7 @@ async def create_project(
 
 @router.get("/projects", response_model=ProjectListResponse)
 async def get_user_projects(
+    include_artifact_count: bool = False,
     user: dict = Depends(get_current_user),
     project_service: ProjectService = Depends(get_project_service),
     db: Session = Depends(get_db),
@@ -172,28 +186,51 @@ async def get_user_projects(
 ):
     """
     Get all projects owned by the authenticated user.
+    
+    Args:
+        include_artifact_count: If True, includes artifact count for each project
     """
     user_id = user.get("id")
-    log.info(f"Fetching projects for user_id: {user_id}")
+    log.info(f"Fetching projects for user_id: {user_id}, include_artifact_count: {include_artifact_count}")
 
     try:
         request_dto = GetProjectsRequest(user_id=user_id)
 
-        projects = project_service.get_user_projects(db, request_dto.user_id)
-        
-        project_responses = [
-            ProjectResponse(
-                id=p.id,
-                name=p.name,
-                user_id=p.user_id,
-                description=p.description,
-                system_prompt=p.system_prompt,
-                default_agent_id=p.default_agent_id,
-                created_at=p.created_at,
-                updated_at=p.updated_at,
-            )
-            for p in projects
-        ]
+        if include_artifact_count:
+            # Fetch projects with artifact counts
+            projects_with_counts = await project_service.get_user_projects_with_counts(db, request_dto.user_id)
+            
+            project_responses = [
+                ProjectResponse(
+                    id=p.id,
+                    name=p.name,
+                    user_id=p.user_id,
+                    description=p.description,
+                    system_prompt=p.system_prompt,
+                    default_agent_id=p.default_agent_id,
+                    artifact_count=count,
+                    created_at=p.created_at,
+                    updated_at=p.updated_at,
+                )
+                for p, count in projects_with_counts
+            ]
+        else:
+            # Fetch projects without counts (faster)
+            projects = project_service.get_user_projects(db, request_dto.user_id)
+            
+            project_responses = [
+                ProjectResponse(
+                    id=p.id,
+                    name=p.name,
+                    user_id=p.user_id,
+                    description=p.description,
+                    system_prompt=p.system_prompt,
+                    default_agent_id=p.default_agent_id,
+                    created_at=p.created_at,
+                    updated_at=p.updated_at,
+                )
+                for p in projects
+            ]
         
         return ProjectListResponse(
             projects=project_responses,
@@ -346,11 +383,14 @@ async def add_project_artifacts(
         )
         return results
     except ValueError as e:
-        log.warning(f"Validation error adding artifacts to project {project_id}: {e}")
-        # Could be 404 if project not found, or 400 if other validation fails
-        if "not found" in str(e).lower():
-            raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=str(e))
-        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(e))
+        error_msg = str(e)
+        log.warning(f"Validation error adding artifacts to project {project_id}: {error_msg}")
+        # Could be 404 if project not found, 413 if file too large, or 400 if other validation fails
+        if "not found" in error_msg.lower():
+            raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=error_msg)
+        if "exceeds maximum" in error_msg.lower() and "bytes" in error_msg.lower():
+            raise HTTPException(status_code=status.HTTP_413_REQUEST_ENTITY_TOO_LARGE, detail=error_msg)
+        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=error_msg)
     except Exception as e:
         log.error(
             "Error adding artifacts to project %s for user %s: %s",
@@ -364,6 +404,56 @@ async def add_project_artifacts(
         )
 
 
+@router.patch("/projects/{project_id}/artifacts/{filename}", status_code=status.HTTP_200_OK)
+async def update_project_artifact_metadata(
+    project_id: str,
+    filename: str,
+    description: Optional[str] = Form(None),
+    user: dict = Depends(get_current_user),
+    project_service: ProjectService = Depends(get_project_service),
+    db: Session = Depends(get_db),
+    _: None = Depends(check_projects_enabled),
+):
+    """
+    Update metadata (description) for a project artifact.
+    """
+    user_id = user.get("id")
+    log.info(f"User {user_id} attempting to update metadata for artifact '{filename}' in project {project_id}")
+
+    try:
+        success = await project_service.update_artifact_metadata(
+            db=db,
+            project_id=project_id,
+            user_id=user_id,
+            filename=filename,
+            description=description,
+        )
+        if not success:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail="Project or artifact not found, or access denied."
+            )
+        
+        return {"message": "Artifact metadata updated successfully"}
+    except ValueError as e:
+        log.warning(f"Validation error updating artifact metadata in project {project_id}: {e}")
+        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(e))
+    except HTTPException:
+        raise
+    except Exception as e:
+        log.error(
+            "Error updating metadata for artifact '%s' in project %s for user %s: %s",
+            filename,
+            project_id,
+            user_id,
+            e,
+        )
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to update artifact metadata"
+        )
+
+
 @router.delete("/projects/{project_id}/artifacts/{filename}", status_code=status.HTTP_204_NO_CONTENT)
 async def delete_project_artifact(
     project_id: str,
@@ -540,3 +630,139 @@ async def delete_project(
             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
             detail="Failed to delete project"
         )
+
+
+@router.get("/projects/{project_id}/export")
+async def export_project(
+    project_id: str,
+    user: dict = Depends(get_current_user),
+    project_service: ProjectService = Depends(get_project_service),
+    db: Session = Depends(get_db),
+    _: None = Depends(check_projects_enabled),
+):
+    """
+    Export project as ZIP containing:
+    - project.json (metadata)
+    - artifacts/ (all project files)
+    
+    Excludes: chat history, sessions
+    """
+    user_id = user.get("id")
+    log.info(f"User {user_id} exporting project {project_id}")
+    
+    try:
+        # Create ZIP file
+        zip_buffer = await project_service.export_project_as_zip(
+            db=db,
+            project_id=project_id,
+            user_id=user_id
+        )
+        
+        # Get project for filename
+        project = project_service.get_project(db, project_id, user_id)
+        if not project:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail="Project not found"
+            )
+        
+        # Create safe filename
+        safe_name = project.name.replace(' ', '-').replace('/', '-')
+        filename = f"project-{safe_name}-{project_id[:8]}.zip"
+        
+        log.info(f"Project {project_id} exported successfully")
+        
+        return StreamingResponse(
+            zip_buffer,
+            media_type="application/zip",
+            headers={
+                "Content-Disposition": f'attachment; filename="{filename}"'
+            }
+        )
+    
+    except ValueError as e:
+        log.warning(f"Validation error exporting project {project_id}: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=str(e)
+        )
+    except Exception as e:
+        log.error(f"Error exporting project {project_id}: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to export project"
+        )
+
+
+@router.post("/projects/import", response_model=ProjectImportResponse)
+async def import_project(
+    file: UploadFile = File(...),
+    options: Optional[str] = Form(None),
+    user: dict = Depends(get_current_user),
+    project_service: ProjectService = Depends(get_project_service),
+    db: Session = Depends(get_db),
+    _: None = Depends(check_projects_enabled),
+):
+    """
+    Import project from ZIP file.
+    Handles name conflicts automatically.
+    """
+    user_id = user.get("id")
+    log.info(f"User {user_id} importing project from {file.filename}")
+    
+    try:
+        # Validate file type
+        if not file.filename.endswith('.zip'):
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail="File must be a ZIP archive"
+            )
+        
+        # Parse options
+        import_options = ProjectImportOptions()
+        if options:
+            try:
+                options_dict = json.loads(options)
+                import_options = ProjectImportOptions(**options_dict)
+            except (json.JSONDecodeError, ValueError) as e:
+                log.warning(f"Invalid import options: {e}")
+        
+        # Import project
+        project, artifacts_count, warnings = await project_service.import_project_from_zip(
+            db=db,
+            zip_file=file,
+            user_id=user_id,
+            preserve_name=import_options.preserve_name,
+            custom_name=import_options.custom_name,
+        )
+        
+        log.info(
+            f"Project imported successfully: {project.id} with {artifacts_count} artifacts"
+        )
+        
+        return ProjectImportResponse(
+            project_id=project.id,
+            name=project.name,
+            artifacts_imported=artifacts_count,
+            warnings=warnings,
+        )
+    
+    except ValueError as e:
+        error_msg = str(e)
+        log.warning(f"Validation error importing project: {error_msg}")
+        # Check if this is a file size error 
+        if "exceeds maximum" in error_msg.lower():
+            raise HTTPException(
+                status_code=status.HTTP_413_REQUEST_ENTITY_TOO_LARGE,
+                detail=error_msg
+            )
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=error_msg
+        )
+    except Exception as e:
+        log.error(f"Error importing project: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to import project"
+        )