solace-agent-mesh 1.4.7__py3-none-any.whl → 1.4.9__py3-none-any.whl

solace_agent_mesh/gateway/http_sse/routers/artifacts.py

@@ -14,7 +14,9 @@ from fastapi import (
     Path,
     UploadFile,
     status,
+    Request as FastAPIRequest,
 )
+from pydantic import BaseModel, Field
 from fastapi.responses import Response, StreamingResponse
 
 try:
@@ -33,7 +35,6 @@ from urllib.parse import parse_qs, quote, urlparse
 from solace_ai_connector.common.log import log
 
 from ....common.a2a.types import ArtifactInfo
-from ....common.middleware import ConfigResolver
 from ....common.utils.embeds import (
     LATE_EMBED_TYPES,
     evaluate_embed,
@@ -41,17 +42,24 @@ from ....common.utils.embeds import (
 )
 from ....common.utils.mime_helpers import is_text_based_mime_type
 from ..dependencies import (
-    get_config_resolver,
+    ValidatedUserConfig,
     get_sac_component,
     get_session_validator,
     get_shared_artifact_service,
     get_user_config,
     get_user_id,
+    get_session_manager,
+    get_session_business_service_optional,
+    get_db_optional,
 )
 
 if TYPE_CHECKING:
     from ....gateway.http_sse.component import WebUIBackendComponent
 
+from ..session_manager import SessionManager
+from ..services.session_service import SessionService
+from sqlalchemy.orm import Session
+
 from ....agent.utils.artifact_helpers import (
     DEFAULT_SCHEMA_MAX_KEYS,
     format_artifact_uri,
@@ -60,9 +68,191 @@ from ....agent.utils.artifact_helpers import (
     save_artifact_with_metadata,
 )
 
+
+class ArtifactUploadResponse(BaseModel):
+    """Response model for artifact upload with camelCase fields."""
+    uri: str
+    session_id: str = Field(..., alias="sessionId")
+    filename: str
+    size: int
+    mime_type: str = Field(..., alias="mimeType")
+    metadata: dict[str, Any]
+    created_at: str = Field(..., alias="createdAt")
+
+    model_config = {"populate_by_name": True}
+
+
 router = APIRouter()
 
 
+@router.post(
+    "/upload",
+    status_code=status.HTTP_201_CREATED,
+    response_model=ArtifactUploadResponse,
+    summary="Upload Artifact (Body-Based Session Management)",
+    description="Uploads file with sessionId and filename in request body. Creates session if sessionId is null/empty.",
+)
+async def upload_artifact_with_session(
+    request: FastAPIRequest,
+    upload_file: UploadFile = File(..., description="The file content to upload"),
+    sessionId: str | None = Form(None, description="Session ID (null/empty to create new session)", alias="sessionId"),
+    filename: str = Form(..., description="The name of the artifact to create/update"),
+    metadata_json: str | None = Form(
+        None, description="JSON string of artifact metadata (e.g., description, source)"
+    ),
+    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),
+    user_config: dict = Depends(ValidatedUserConfig(["tool:artifact:create"])),
+    session_manager: SessionManager = Depends(get_session_manager),
+    session_service: SessionService | None = Depends(get_session_business_service_optional),
+    db: Session | None = Depends(get_db_optional),
+):
+    """
+    Uploads a file to create a new version of the specified artifact.
+
+    Key features:
+    - Session ID and filename provided in request body (not URL)
+    - Automatically creates new session if session_id is null/empty
+    - Consistent with chat API patterns
+    """
+    log_prefix = f"[POST /artifacts/upload] User {user_id}: "
+
+    # Handle session creation logic (matching chat API pattern)
+    effective_session_id = None
+
+    # Use session ID from request body (matching sessionId pattern in session APIs)
+    if sessionId and sessionId.strip():
+        effective_session_id = sessionId.strip()
+        log.info("%sUsing existing session: %s", log_prefix, effective_session_id)
+    else:
+        # Create new session when no sessionId provided (like chat does for new conversations)
+        effective_session_id = session_manager.create_new_session_id(request)
+        log.info("%sCreated new session for file upload: %s", log_prefix, effective_session_id)
+
+        # Persist session in database if persistence is available (matching chat pattern)
+        if session_service and db:
+            try:
+                session_service.create_session(
+                    db=db,
+                    user_id=user_id,
+                    session_id=effective_session_id,
+                    agent_id=None,  # Will be determined when first message is sent
+                    name=None,      # Will be set when first message is sent
+                )
+                db.commit()
+                log.info("%sSession created and committed to database: %s", log_prefix, effective_session_id)
+            except Exception as session_error:
+                db.rollback()
+                log.warning("%sSession persistence failed, continuing with in-memory session: %s",
+                           log_prefix, session_error)
+        else:
+            log.debug("%sNo persistence available - using in-memory session: %s",
+                     log_prefix, effective_session_id)
+
+    # Validate inputs
+    if not filename or not filename.strip():
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="Filename is required.",
+        )
+
+    if not upload_file.filename:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="File upload is required.",
+        )
+
+    # Validate artifact service availability
+    if not artifact_service:
+        log.error("%sArtifact service is not configured.", log_prefix)
+        raise HTTPException(
+            status_code=status.HTTP_501_NOT_IMPLEMENTED,
+            detail="Artifact service is not configured.",
+        )
+
+    # Validate session (now that we have an effective_session_id)
+    if not validate_session(effective_session_id, user_id):
+        log.warning("%sSession validation failed for session: %s", log_prefix, effective_session_id)
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="Invalid session or insufficient permissions.",
+        )
+
+    log.info("%sUploading file '%s' to session '%s'", log_prefix, filename.strip(), effective_session_id)
+
+    try:
+        # Read and validate file content
+        content_bytes = await upload_file.read()
+        if not content_bytes:
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail="File is empty.",
+            )
+
+        mime_type = upload_file.content_type or "application/octet-stream"
+        filename_clean = filename.strip()
+
+        log.debug("%sProcessing file: %s (%d bytes, %s)", log_prefix, filename_clean, len(content_bytes), mime_type)
+
+        # Parse and validate metadata
+        metadata = {}
+        if metadata_json and metadata_json.strip():
+            try:
+                metadata = json.loads(metadata_json.strip())
+                if not isinstance(metadata, dict):
+                    raise ValueError("Metadata must be a JSON object")
+            except (json.JSONDecodeError, ValueError) as e:
+                log.warning("%sInvalid metadata JSON: %s", log_prefix, e)
+                raise HTTPException(
+                    status_code=status.HTTP_400_BAD_REQUEST,
+                    detail=f"Invalid JSON in metadata field: {str(e)}",
+                )
+
+        app_name = component.get_config("name", "A2A_WebUI_App")
+
+        # Store the artifact using the service
+        artifact_uri = await artifact_service.store(
+            app_name=app_name,
+            user_id=user_id,
+            session_id=effective_session_id,
+            filename=filename_clean,
+            content_bytes=content_bytes,
+            mime_type=mime_type,
+            metadata=metadata,
+        )
+
+        log.info("%sArtifact stored successfully: %s (%d bytes)", log_prefix, artifact_uri, len(content_bytes))
+
+        # Return standardized response using Pydantic model (ensures camelCase conversion)
+        return ArtifactUploadResponse(
+            uri=artifact_uri,
+            session_id=effective_session_id,  # Will be returned as "sessionId" due to alias
+            filename=filename_clean,
+            size=len(content_bytes),
+            mime_type=mime_type,  # Will be returned as "mimeType" due to alias
+            metadata=metadata,
+            created_at=datetime.now(timezone.utc).isoformat(),  # Will be returned as "createdAt" due to alias
+        )
+
+    except HTTPException:
+        # Re-raise HTTP exceptions as-is
+        raise
+    except Exception as e:
+        log.exception("%sUnexpected error storing artifact: %s", log_prefix, e)
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to store artifact due to an internal error.",
+        )
+    finally:
+        # Ensure file is properly closed
+        try:
+            await upload_file.close()
+        except Exception as close_error:
+            log.warning("%sError closing upload file: %s", log_prefix, close_error)
+
+
 @router.get(
     "/{session_id}/{filename}/versions",
     response_model=list[int],
@@ -78,19 +268,12 @@ async def list_artifact_versions(
     user_id: str = Depends(get_user_id),
     validate_session: Callable[[str, str], bool] = Depends(get_session_validator),
     component: "WebUIBackendComponent" = Depends(get_sac_component),
-    config_resolver: ConfigResolver = Depends(get_config_resolver),
-    user_config: dict = Depends(get_user_config),
+    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.
     """
-    if not config_resolver.is_feature_enabled(
-        user_config, {"required_scopes": ["tool:artifact:list"]}, {}
-    ):
-        raise HTTPException(
-            status_code=403, detail="Not authorized to list artifact versions"
-        )
 
     log_prefix = f"[ArtifactRouter:ListVersions:{filename}] User={user_id}, Session={session_id} -"
     log.info("%s Request received.", log_prefix)
@@ -166,18 +349,13 @@ async def list_artifacts(
     user_id: str = Depends(get_user_id),
     validate_session: Callable[[str, str], bool] = Depends(get_session_validator),
     component: "WebUIBackendComponent" = Depends(get_sac_component),
-    config_resolver: ConfigResolver = Depends(get_config_resolver),
-    user_config: dict = Depends(get_user_config),
+    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.
     """
-    if not config_resolver.is_feature_enabled(
-        user_config, {"required_scopes": ["tool:artifact:list"]}, {}
-    ):
-        raise HTTPException(status_code=403, detail="Not authorized to list artifacts")
 
     log_prefix = f"[ArtifactRouter:ListInfo] User={user_id}, Session={session_id} -"
     log.info("%s Request received.", log_prefix)
@@ -241,17 +419,12 @@ async def get_latest_artifact(
     user_id: str = Depends(get_user_id),
     validate_session: Callable[[str, str], bool] = Depends(get_session_validator),
     component: "WebUIBackendComponent" = Depends(get_sac_component),
-    config_resolver: ConfigResolver = Depends(get_config_resolver),
-    user_config: dict = Depends(get_user_config),
+    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.
     """
-    if not config_resolver.is_feature_enabled(
-        user_config, {"required_scopes": ["tool:artifact:load"]}, {}
-    ):
-        raise HTTPException(status_code=403, detail="Not authorized to load artifact")
     log_prefix = (
         f"[ArtifactRouter:GetLatest:{filename}] User={user_id}, Session={session_id} -"
     )
@@ -386,19 +559,12 @@ async def get_specific_artifact_version(
     user_id: str = Depends(get_user_id),
     validate_session: Callable[[str, str], bool] = Depends(get_session_validator),
     component: "WebUIBackendComponent" = Depends(get_sac_component),
-    config_resolver: ConfigResolver = Depends(get_config_resolver),
-    user_config: dict = Depends(get_user_config),
+    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.
     """
-    if not config_resolver.is_feature_enabled(
-        user_config, {"required_scopes": ["tool:artifact:load"]}, {}
-    ):
-        raise HTTPException(
-            status_code=403, detail="Not authorized to load artifact version"
-        )
     log_prefix = f"[ArtifactRouter:GetVersion:{filename} v{version}] User={user_id}, Session={session_id} -"
     log.info("%s Request received.", log_prefix)
 
@@ -568,8 +734,7 @@ async def get_artifact_by_uri(
     uri: str,
     requesting_user_id: str = Depends(get_user_id),
     component: "WebUIBackendComponent" = Depends(get_sac_component),
-    config_resolver: ConfigResolver = Depends(get_config_resolver),
-    user_config: dict = Depends(get_user_config),
+    user_config: dict = Depends(ValidatedUserConfig(["tool:artifact:load"])),
 ):
     """
     Resolves an artifact:// URI and streams its content.
@@ -620,21 +785,6 @@ async def get_artifact_by_uri(
             version,
         )
 
-        if not config_resolver.is_feature_enabled(
-            user_config, {"required_scopes": ["tool:artifact:load"]}, {}
-        ):
-            raise HTTPException(
-                status_code=403, detail="Not authorized to load artifact by URI"
-            )
-            log.warning(
-                "%s Authorization denied for user '%s' to access artifact URI '%s'",
-                log_id_prefix,
-                requesting_user_id,
-                uri,
-            )
-            raise HTTPException(
-                status_code=403, detail="Permission denied to access this artifact."
-            )
 
         log.info(
             "%s User '%s' authorized to access artifact URI.",
@@ -700,17 +850,12 @@ async def upload_artifact(
     user_id: str = Depends(get_user_id),
     validate_session: Callable[[str, str], bool] = Depends(get_session_validator),
     component: "WebUIBackendComponent" = Depends(get_sac_component),
-    config_resolver: ConfigResolver = Depends(get_config_resolver),
-    user_config: dict = Depends(get_user_config),
+    user_config: dict = Depends(ValidatedUserConfig(["tool:artifact:create"])),
 ):
     """
     Uploads a file to create a new version of the specified artifact
     associated with the current user and session ID. Also saves associated metadata.
     """
-    if not config_resolver.is_feature_enabled(
-        user_config, {"required_scopes": ["tool:artifact:create"]}, {}
-    ):
-        raise HTTPException(status_code=403, detail="Not authorized to upload artifact")
     log_prefix = (
         f"[ArtifactRouter:Post:{filename}] User={user_id}, Session={session_id} -"
     )
@@ -856,17 +1001,12 @@ async def delete_artifact(
     user_id: str = Depends(get_user_id),
     validate_session: Callable[[str, str], bool] = Depends(get_session_validator),
     component: "WebUIBackendComponent" = Depends(get_sac_component),
-    config_resolver: ConfigResolver = Depends(get_config_resolver),
-    user_config: dict = Depends(get_user_config),
+    user_config: dict = Depends(ValidatedUserConfig(["tool:artifact:delete"])),
 ):
     """
     Deletes the specified artifact (including all its versions)
     associated with the current user and session ID.
     """
-    if not config_resolver.is_feature_enabled(
-        user_config, {"required_scopes": ["tool:artifact:delete"]}, {}
-    ):
-        raise HTTPException(status_code=403, detail="Not authorized to delete artifact")
     log_prefix = (
         f"[ArtifactRouter:Delete:{filename}] User={user_id}, Session={session_id} -"
     )

solace_agent_mesh/gateway/http_sse/routers/dto/requests/__init__.py

@@ -3,18 +3,13 @@ Request DTOs for API endpoints.
 """
 
 from .session_requests import (
-    GetSessionsRequest,
     GetSessionRequest,
     GetSessionHistoryRequest,
     UpdateSessionRequest,
-    DeleteSessionRequest,
 )
 
 __all__ = [
-    # Session requests
-    "GetSessionsRequest",
-    "GetSessionRequest", 
+    "GetSessionRequest",
     "GetSessionHistoryRequest",
     "UpdateSessionRequest",
-    "DeleteSessionRequest",
 ]

solace_agent_mesh/gateway/http_sse/routers/dto/requests/session_requests.py

@@ -2,18 +2,10 @@
 Session-related request DTOs.
 """
 
-from typing import Optional, List
+from typing import Optional
 from pydantic import BaseModel, Field
 
-from ....shared.types import SessionId, UserId, SortInfo, FilterInfo, PaginationInfo
-
-
-class GetSessionsRequest(BaseModel):
-    """Request DTO for retrieving sessions."""
-    user_id: UserId
-    pagination: Optional[PaginationInfo] = None
-    sort: Optional[SortInfo] = None
-    filters: Optional[List[FilterInfo]] = None
+from ....shared.types import SessionId, UserId, PaginationInfo
 
 
 class GetSessionRequest(BaseModel):
@@ -33,10 +25,4 @@ class UpdateSessionRequest(BaseModel):
     """Request DTO for updating session details."""
     session_id: SessionId
     user_id: UserId
-    name: str = Field(..., min_length=1, max_length=255, description="New session name")
-
-
-class DeleteSessionRequest(BaseModel):
-    """Request DTO for deleting a session."""
-    session_id: SessionId
-    user_id: UserId
+    name: str = Field(..., min_length=1, max_length=255, description="New session name")

solace_agent_mesh/gateway/http_sse/routers/people.py

@@ -9,11 +9,13 @@ from solace_ai_connector.common.log import log
 
 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
 
 router = APIRouter()
 
 
-@router.get("/people/search", response_model=List[Dict[str, Any]])
+@router.get("/people/search", response_model=DataResponse[List[Dict[str, Any]]])
 async def search_people(
     q: str = Query(
         ...,
@@ -31,39 +33,4 @@ async def search_people(
     """
     log.debug("Endpoint /people/search called with query: '%s'", q)
     results = await people_service.search_for_users(query=q, limit=limit)
-    return results
-
-
-"""
-API endpoints for people-related features, such as user search for autocomplete.
-"""
-
-from typing import Any, Dict, List
-
-from fastapi import APIRouter, Depends, Query
-from solace_ai_connector.common.log import log
-from ..dependencies import get_people_service
-from ..services.people_service import PeopleService
-
-router = APIRouter()
-
-
-@router.get("/people/search", response_model=List[Dict[str, Any]])
-async def search_people(
-    q: str = Query(
-        ...,
-        min_length=2,
-        max_length=50,
-        description="Search query for user name/email.",
-    ),
-    limit: int = Query(
-        10, ge=1, le=25, description="Maximum number of results to return."
-    ),
-    people_service: PeopleService = Depends(get_people_service),
-):
-    """
-    Searches for users to populate frontend autocomplete suggestions (e.g., for @mentions).
-    """
-    log.debug("Endpoint /people/search called with query: '%s'", q)
-    results = await people_service.search_for_users(query=q, limit=limit)
-    return results
+    return create_data_response(results)