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

solace_agent_mesh/gateway/http_sse/routers/artifacts.py

@@ -1,10 +1,11 @@
 """
 FastAPI router for managing session-specific artifacts via REST endpoints.
 """
+from __future__ import annotations
 
 import logging
 from collections.abc import Callable
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, Optional
 
 from fastapi import (
     APIRouter,
@@ -13,6 +14,7 @@ from fastapi import (
     Form,
     HTTPException,
     Path,
+    Query,
     UploadFile,
     status,
     Request as FastAPIRequest,
@@ -39,8 +41,11 @@ from ....common.utils.embeds import (
     evaluate_embed,
     resolve_embeds_recursively_in_string,
 )
+from ....common.utils.embeds.types import ResolutionMode
 from ....common.utils.mime_helpers import is_text_based_mime_type
+from ....common.utils.templates import resolve_template_blocks_in_string
 from ..dependencies import (
+    get_project_service_optional,
     ValidatedUserConfig,
     get_sac_component,
     get_session_validator,
@@ -50,6 +55,7 @@ from ..dependencies import (
     get_session_business_service_optional,
     get_db_optional,
 )
+from ..services.project_service import ProjectService
 
 
 from ..session_manager import SessionManager
@@ -67,6 +73,7 @@ if TYPE_CHECKING:
 
 log = logging.getLogger(__name__)
 
+LOAD_FILE_CHUNK_SIZE = 1024 * 1024  # 1MB chunks
 
 class ArtifactUploadResponse(BaseModel):
     """Response model for artifact upload with camelCase fields."""
@@ -85,6 +92,80 @@ class ArtifactUploadResponse(BaseModel):
 router = APIRouter()
 
 
+def _resolve_storage_context(
+    session_id: str,
+    project_id: str | None,
+    user_id: str,
+    validate_session: Callable[[str, str], bool],
+    project_service: ProjectService | None,
+    log_prefix: str
+) -> tuple[str, str, str]:
+    """
+    Resolve storage context from session or project parameters.
+
+    Returns:
+        tuple: (storage_user_id, storage_session_id, context_type)
+
+    Raises:
+        HTTPException: If no valid context found
+    """
+    # Priority 1: Session context
+    if session_id and session_id.strip() and session_id not in ["null", "undefined"]:
+        if not validate_session(session_id, user_id):
+            log.warning("%s Session validation failed", log_prefix)
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail="Session not found or access denied.",
+            )
+        return user_id, session_id, "session"
+
+    # Priority 2: Project context (only if persistence is enabled)
+    elif project_id and project_id.strip() and project_id not in ["null", "undefined"]:
+        if project_service is None:
+            log.warning("%s Project context requested but persistence not enabled", log_prefix)
+            raise HTTPException(
+                status_code=status.HTTP_501_NOT_IMPLEMENTED,
+                detail="Project context requires database configuration.",
+            )
+
+        from ....gateway.http_sse.dependencies import SessionLocal
+
+        if SessionLocal is None:
+            log.warning("%s Project context requested but database not configured", log_prefix)
+            raise HTTPException(
+                status_code=status.HTTP_501_NOT_IMPLEMENTED,
+                detail="Project context requires database configuration.",
+            )
+
+        db = SessionLocal()
+        try:
+            project = project_service.get_project(db, project_id, user_id)
+            if not project:
+                log.warning("%s Project not found or access denied", log_prefix)
+                raise HTTPException(
+                    status_code=status.HTTP_404_NOT_FOUND,
+                    detail="Project not found or access denied.",
+                )
+            return project.user_id, f"project-{project_id}", "project"
+        except HTTPException:
+            raise
+        except Exception as e:
+            log.error("%s Error resolving project context: %s", log_prefix, e)
+            raise HTTPException(
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                detail="Failed to resolve project context"
+            )
+        finally:
+            db.close()
+
+    # No valid context
+    log.warning("%s No valid context found", log_prefix)
+    raise HTTPException(
+        status_code=status.HTTP_404_NOT_FOUND,
+        detail="No valid context provided.",
+    )
+
+
 @router.post(
     "/upload",
     status_code=status.HTTP_201_CREATED,
@@ -127,6 +208,7 @@ async def upload_artifact_with_session(
 
     # Handle session creation logic (matching chat API pattern)
     effective_session_id = None
+    is_new_session = False  # Track if we created a new session
 
     # Use session ID from request body (matching sessionId pattern in session APIs)
     if sessionId and sessionId.strip():
@@ -135,6 +217,7 @@ async def upload_artifact_with_session(
     else:
         # Create new session when no sessionId provided (like chat does for new conversations)
         effective_session_id = session_manager.create_new_session_id(request)
+        is_new_session = True  # Mark that we created this session
         log.info(
             "%sCreated new session for file upload: %s",
             log_prefix,
@@ -193,7 +276,8 @@ async def upload_artifact_with_session(
         )
 
     # Validate session (now that we have an effective_session_id)
-    if not validate_session(effective_session_id, user_id):
+    # Skip validation if we just created the session to avoid race conditions
+    if not is_new_session and not validate_session(effective_session_id, user_id):
         log.warning(
             "%sSession validation failed for session: %s",
             log_prefix,
@@ -212,8 +296,78 @@ async def upload_artifact_with_session(
     )
 
     try:
-        # Read and validate file content
-        content_bytes = await upload_file.read()
+        # ===== VALIDATE FILE SIZE BEFORE READING =====
+        max_upload_size = component.get_config("gateway_max_upload_size_bytes")
+        
+        # Check Content-Length header first (if available)
+        content_length = request.headers.get("content-length")
+        if content_length:
+            try:
+                file_size = int(content_length)
+                
+                if file_size > max_upload_size:
+                    error_msg = (
+                        f"File upload rejected: size {file_size:,} bytes "
+                        f"exceeds maximum {max_upload_size:,} bytes "
+                        f"({file_size / (1024*1024):.2f} MB > {max_upload_size / (1024*1024):.2f} MB)"
+                    )
+                    log.warning("%s %s", log_prefix, error_msg)
+                    
+                    raise HTTPException(
+                        status_code=status.HTTP_413_REQUEST_ENTITY_TOO_LARGE,
+                        detail=error_msg  # Use string instead of dict
+                    )
+            except ValueError:
+                log.warning("%s Invalid Content-Length header: %s", log_prefix, content_length)
+        
+        # Validate file size by streaming through WITHOUT accumulating chunks in memory
+        chunk_size = LOAD_FILE_CHUNK_SIZE
+        total_bytes_read = 0
+
+        try:
+            # Step 1: Validate size by reading chunks (discard data, just count bytes)
+            while True:
+                chunk = await upload_file.read(chunk_size)
+                if not chunk:
+                    break  # End of file
+
+                total_bytes_read += len(chunk)
+
+                # Validate size during reading (fail fast)
+                if total_bytes_read > max_upload_size:
+                    error_msg = (
+                        f"File '{upload_file.filename}' rejected: size exceeds maximum {max_upload_size:,} bytes "
+                        f"(read {total_bytes_read:,} bytes so far, "
+                        f"{total_bytes_read / (1024*1024):.2f} MB > {max_upload_size / (1024*1024):.2f} MB)"
+                    )
+                    log.warning("%s %s", log_prefix, error_msg)
+
+                    raise HTTPException(
+                        status_code=status.HTTP_413_REQUEST_ENTITY_TOO_LARGE,
+                        detail=error_msg
+                    )
+
+            # Step 2: Size is valid - reset to beginning
+            await upload_file.seek(0)
+
+            # Step 3: Read all content at once
+            content_bytes = await upload_file.read()
+
+            log.debug(
+                "%s File validated (%d bytes) and loaded into memory",
+                log_prefix,
+                total_bytes_read
+            )
+            
+        except HTTPException:
+            # Re-raise HTTP exceptions (size limit exceeded)
+            raise
+        except Exception as read_error:
+            log.exception("%s Error reading uploaded file: %s", log_prefix, read_error)
+            raise HTTPException(
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                detail="Failed to read uploaded file"
+            )
 
         mime_type = upload_file.content_type or "application/octet-stream"
         filename_clean = filename.strip()
@@ -245,6 +399,8 @@ async def upload_artifact_with_session(
 
             if error_type in ["invalid_filename", "empty_file"]:
                 status_code = status.HTTP_400_BAD_REQUEST
+            elif error_type == "file_too_large":
+                status_code = status.HTTP_413_REQUEST_ENTITY_TOO_LARGE
             else:
                 status_code = status.HTTP_500_INTERNAL_SERVER_ERROR
 
@@ -310,33 +466,32 @@ async def upload_artifact_with_session(
 )
 async def list_artifact_versions(
     session_id: str = Path(
-        ..., title="Session ID", description="The session ID to get artifacts from"
+        ..., title="Session ID", description="The session ID to get artifacts from (or 'null' for project context)"
     ),
     filename: str = Path(..., title="Filename", description="The name of the artifact"),
+    project_id: Optional[str] = Query(None, description="Project ID for project context"),
     artifact_service: BaseArtifactService = Depends(get_shared_artifact_service),
     user_id: str = Depends(get_user_id),
     validate_session: Callable[[str, str], bool] = Depends(get_session_validator),
     component: "WebUIBackendComponent" = Depends(get_sac_component),
+    project_service: ProjectService | None = Depends(get_project_service_optional),
     user_config: dict = Depends(ValidatedUserConfig(["tool:artifact:list"])),
 ):
     """
     Lists the available integer versions for a given artifact filename
-    associated with the current user and session ID.
+    associated with the specified context (session or project).
     """
 
     log_prefix = f"[ArtifactRouter:ListVersions:{filename}] User={user_id}, Session={session_id} -"
     log.info("%s Request received.", log_prefix)
 
-    # Validate session exists and belongs to user
-    if not validate_session(session_id, user_id):
-        log.warning("%s Session validation failed or access denied.", log_prefix)
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail="Session not found or access denied.",
-        )
+    # Resolve storage context
+    storage_user_id, storage_session_id, context_type = _resolve_storage_context(
+        session_id, project_id, user_id, validate_session, project_service, log_prefix
+    )
 
     if artifact_service is None:
-        log.error("%s Artifact service is not configured or available.", log_prefix)
+        log.error("%s Artifact service not available.", log_prefix)
         raise HTTPException(
             status_code=status.HTTP_501_NOT_IMPLEMENTED,
             detail="Artifact service is not configured.",
@@ -356,10 +511,13 @@ async def list_artifact_versions(
     try:
         app_name = component.get_config("name", "A2A_WebUI_App")
 
+        log.info("%s Using %s context: storage_user_id=%s, storage_session_id=%s", 
+                log_prefix, context_type, storage_user_id, storage_session_id)
+
         versions = await artifact_service.list_versions(
             app_name=app_name,
-            user_id=user_id,
-            session_id=session_id,
+            user_id=storage_user_id,
+            session_id=storage_session_id,
             filename=filename,
         )
         log.info("%s Found versions: %s", log_prefix, versions)
@@ -368,7 +526,7 @@ async def list_artifact_versions(
         log.warning("%s Artifact not found.", log_prefix)
         raise HTTPException(
             status_code=status.HTTP_404_NOT_FOUND,
-            detail=f"Artifact '{filename}' not found for this session.",
+            detail=f"Artifact '{filename}' not found.",
         )
     except Exception as e:
         log.exception("%s Error listing artifact versions: %s", log_prefix, e)
@@ -392,35 +550,33 @@ async def list_artifact_versions(
 )
 async def list_artifacts(
     session_id: str = Path(
-        ..., title="Session ID", description="The session ID to list artifacts for"
+        ..., title="Session ID", description="The session ID to list artifacts for (or 'null' for project context)"
     ),
+    project_id: Optional[str] = Query(None, description="Project ID for project context"),
     artifact_service: BaseArtifactService = Depends(get_shared_artifact_service),
     user_id: str = Depends(get_user_id),
     validate_session: Callable[[str, str], bool] = Depends(get_session_validator),
     component: "WebUIBackendComponent" = Depends(get_sac_component),
+    project_service: ProjectService | None = Depends(get_project_service_optional),
     user_config: dict = Depends(ValidatedUserConfig(["tool:artifact:list"])),
 ):
     """
     Lists detailed information (filename, size, type, modified date, uri)
-    for all artifacts associated with the specified user and session ID
-    by calling the artifact helper function.
+    for all artifacts associated with the specified context (session or project).
     """
 
     log_prefix = f"[ArtifactRouter:ListInfo] User={user_id}, Session={session_id} -"
     log.info("%s Request received.", log_prefix)
 
-    # Validate session exists and belongs to user
-    if not validate_session(session_id, user_id):
-        log.warning(
-            "%s Session validation failed for session_id=%s, user_id=%s",
-            log_prefix,
-            session_id,
-            user_id,
-        )
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail="Session not found or access denied.",
+    # Resolve storage context (projects vs sessions). This allows for project artiacts
+    # to be listed before a session is created.
+    try:
+        storage_user_id, storage_session_id, context_type = _resolve_storage_context(
+            session_id, project_id, user_id, validate_session, project_service, log_prefix
         )
+    except HTTPException:
+        log.info("%s No valid context found, returning empty list", log_prefix)
+        return []
 
     if artifact_service is None:
         log.error("%s Artifact service is not configured or available.", log_prefix)
@@ -432,22 +588,21 @@ async def list_artifacts(
     try:
         app_name = component.get_config("name", "A2A_WebUI_App")
 
+        log.info("%s Using %s context: storage_user_id=%s, storage_session_id=%s", 
+                log_prefix, context_type, storage_user_id, storage_session_id)
+
         artifact_info_list = await get_artifact_info_list(
             artifact_service=artifact_service,
             app_name=app_name,
-            user_id=user_id,
-            session_id=session_id,
+            user_id=storage_user_id,
+            session_id=storage_session_id,
         )
 
-        log.info(
-            "%s Returning %d artifact details.", log_prefix, len(artifact_info_list)
-        )
+        log.info("%s Returning %d artifact details.", log_prefix, len(artifact_info_list))
         return artifact_info_list
 
     except Exception as e:
-        log.exception(
-            "%s Error retrieving artifact details via helper: %s", log_prefix, e
-        )
+        log.exception("%s Error retrieving artifact details: %s", log_prefix, e)
         raise HTTPException(
             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
             detail=f"Failed to retrieve artifact details: {str(e)}",
@@ -461,24 +616,31 @@ async def list_artifacts(
 )
 async def get_latest_artifact(
     session_id: str = Path(
-        ..., title="Session ID", description="The session ID to get artifacts from"
+        ..., title="Session ID", description="The session ID to get artifacts from (or 'null' for project context)"
     ),
     filename: str = Path(..., title="Filename", description="The name of the artifact"),
+    project_id: Optional[str] = Query(None, description="Project ID for project context"),
     artifact_service: BaseArtifactService = Depends(get_shared_artifact_service),
     user_id: str = Depends(get_user_id),
     validate_session: Callable[[str, str], bool] = Depends(get_session_validator),
     component: "WebUIBackendComponent" = Depends(get_sac_component),
+    project_service: ProjectService | None = Depends(get_project_service_optional),
     user_config: dict = Depends(ValidatedUserConfig(["tool:artifact:load"])),
 ):
     """
     Retrieves the content of the latest version of the specified artifact
-    associated with the current user and session ID.
+    associated with the specified context (session or project).
     """
     log_prefix = (
         f"[ArtifactRouter:GetLatest:{filename}] User={user_id}, Session={session_id} -"
     )
     log.info("%s Request received.", log_prefix)
 
+    # Resolve storage context
+    storage_user_id, storage_session_id, context_type = _resolve_storage_context(
+        session_id, project_id, user_id, validate_session, project_service, log_prefix
+    )
+
     if artifact_service is None:
         log.error("%s Artifact service is not configured or available.", log_prefix)
         raise HTTPException(
@@ -488,10 +650,14 @@ async def get_latest_artifact(
 
     try:
         app_name = component.get_config("name", "A2A_WebUI_App")
+
+        log.info("%s Using %s context: storage_user_id=%s, storage_session_id=%s", 
+                log_prefix, context_type, storage_user_id, storage_session_id)
+
         artifact_part = await artifact_service.load_artifact(
             app_name=app_name,
-            user_id=user_id,
-            session_id=session_id,
+            user_id=storage_user_id,
+            session_id=storage_session_id,
             filename=filename,
         )
 
@@ -537,17 +703,32 @@ async def get_latest_artifact(
                     context=context_for_resolver,
                     resolver_func=evaluate_embed,
                     types_to_resolve=LATE_EMBED_TYPES,
+                    resolution_mode=ResolutionMode.RECURSIVE_ARTIFACT_CONTENT,
                     log_identifier=f"{log_prefix}[RecursiveResolve]",
                     config=config_for_resolver,
                     max_depth=component.gateway_recursive_embed_depth,
                     max_total_size=component.gateway_max_artifact_resolve_size_bytes,
                 )
-                data_bytes = resolved_content_string.encode("utf-8")
                 log.info(
                     "%s Recursive embed resolution complete. New size: %d bytes.",
                     log_prefix,
-                    len(data_bytes),
+                    len(resolved_content_string),
                 )
+
+                # Also resolve any template blocks in the artifact
+                resolved_content_string = await resolve_template_blocks_in_string(
+                    text=resolved_content_string,
+                    artifact_service=artifact_service,
+                    session_context=context_for_resolver["session_context"],
+                    log_identifier=f"{log_prefix}[TemplateResolve]",
+                )
+                log.info(
+                    "%s Template block resolution complete. Final size: %d bytes.",
+                    log_prefix,
+                    len(resolved_content_string),
+                )
+
+                data_bytes = resolved_content_string.encode("utf-8")
             except UnicodeDecodeError as ude:
                 log.warning(
                     "%s Failed to decode artifact for recursive resolution: %s. Serving original content.",
@@ -596,7 +777,7 @@ async def get_latest_artifact(
 )
 async def get_specific_artifact_version(
     session_id: str = Path(
-        ..., title="Session ID", description="The session ID to get artifacts from"
+        ..., title="Session ID", description="The session ID to get artifacts from (or 'null' for project context)"
     ),
     filename: str = Path(..., title="Filename", description="The name of the artifact"),
     version: int | str = Path(
@@ -604,26 +785,25 @@ async def get_specific_artifact_version(
         title="Version",
         description="The specific version number to retrieve, or 'latest'",
     ),
+    project_id: Optional[str] = Query(None, description="Project ID for project context"),
     artifact_service: BaseArtifactService = Depends(get_shared_artifact_service),
     user_id: str = Depends(get_user_id),
     validate_session: Callable[[str, str], bool] = Depends(get_session_validator),
     component: "WebUIBackendComponent" = Depends(get_sac_component),
+    project_service: ProjectService | None = Depends(get_project_service_optional),
     user_config: dict = Depends(ValidatedUserConfig(["tool:artifact:load"])),
 ):
     """
     Retrieves the content of a specific version of the specified artifact
-    associated with the current user and session ID.
+    associated with the specified context (session or project).
     """
     log_prefix = f"[ArtifactRouter:GetVersion:{filename} v{version}] User={user_id}, Session={session_id} -"
     log.info("%s Request received.", log_prefix)
 
-    # Validate session exists and belongs to user
-    if not validate_session(session_id, user_id):
-        log.warning("%s Session validation failed or access denied.", log_prefix)
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail="Session not found or access denied.",
-        )
+    # Resolve storage context
+    storage_user_id, storage_session_id, context_type = _resolve_storage_context(
+        session_id, project_id, user_id, validate_session, project_service, log_prefix
+    )
 
     if artifact_service is None:
         log.error("%s Artifact service is not configured or available.", log_prefix)
@@ -635,11 +815,14 @@ async def get_specific_artifact_version(
     try:
         app_name = component.get_config("name", "A2A_WebUI_App")
 
+        log.info("%s Using %s context: storage_user_id=%s, storage_session_id=%s", 
+                log_prefix, context_type, storage_user_id, storage_session_id)
+
         load_result = await load_artifact_content_or_metadata(
             artifact_service=artifact_service,
             app_name=app_name,
-            user_id=user_id,
-            session_id=session_id,
+            user_id=storage_user_id,
+            session_id=storage_session_id,
             filename=filename,
             version=version,
             load_metadata_only=False,
@@ -715,17 +898,32 @@ async def get_specific_artifact_version(
                     context=context_for_resolver,
                     resolver_func=evaluate_embed,
                     types_to_resolve=LATE_EMBED_TYPES,
+                    resolution_mode=ResolutionMode.RECURSIVE_ARTIFACT_CONTENT,
                     log_identifier=f"{log_prefix}[RecursiveResolve]",
                     config=config_for_resolver,
                     max_depth=component.gateway_recursive_embed_depth,
                     max_total_size=component.gateway_max_artifact_resolve_size_bytes,
                 )
-                data_bytes = resolved_content_string.encode("utf-8")
                 log.info(
                     "%s Recursive embed resolution complete. New size: %d bytes.",
                     log_prefix,
-                    len(data_bytes),
+                    len(resolved_content_string),
+                )
+
+                # Also resolve any template blocks in the artifact
+                resolved_content_string = await resolve_template_blocks_in_string(
+                    text=resolved_content_string,
+                    artifact_service=artifact_service,
+                    session_context=context_for_resolver["session_context"],
+                    log_identifier=f"{log_prefix}[TemplateResolve]",
+                )
+                log.info(
+                    "%s Template block resolution complete. Final size: %d bytes.",
+                    log_prefix,
+                    len(resolved_content_string),
                 )
+
+                data_bytes = resolved_content_string.encode("utf-8")
             except UnicodeDecodeError as ude:
                 log.warning(
                     "%s Failed to decode artifact for recursive resolution: %s. Serving original content.",