solace-agent-mesh 1.5.1__py3-none-any.whl → 1.6.0__py3-none-any.whl

solace_agent_mesh/gateway/http_sse/routers/artifacts.py

@@ -45,32 +45,32 @@ from ..dependencies import (
     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,
     get_artifact_info_list,
     load_artifact_content_or_metadata,
-    save_artifact_with_metadata,
+    process_artifact_upload,
 )
 
+if TYPE_CHECKING:
+    from ....gateway.http_sse.component import WebUIBackendComponent
+
 log = logging.getLogger(__name__)
 
+
 class ArtifactUploadResponse(BaseModel):
     """Response model for artifact upload with camelCase fields."""
+
     uri: str
     session_id: str = Field(..., alias="sessionId")
     filename: str
@@ -95,7 +95,11 @@ router = APIRouter()
 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"),
+    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)"
@@ -106,7 +110,9 @@ async def upload_artifact_with_session(
     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),
+    session_service: SessionService | None = Depends(
+        get_session_business_service_optional
+    ),
     db: Session | None = Depends(get_db_optional),
 ):
     """
@@ -129,7 +135,11 @@ 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)
-        log.info("%sCreated new session for file upload: %s", log_prefix, effective_session_id)
+        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:
@@ -139,17 +149,27 @@ async def upload_artifact_with_session(
                     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
+                    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)
+                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)
+                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)
+            log.debug(
+                "%sNo persistence available - using in-memory session: %s",
+                log_prefix,
+                effective_session_id,
+            )
 
     # Validate inputs
     if not filename or not filename.strip():
@@ -174,56 +194,83 @@ 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):
-        log.warning("%sSession validation failed for session: %s", log_prefix, effective_session_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)
+    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")
+        log.debug(
+            "%sProcessing file: %s (%d bytes, %s)",
+            log_prefix,
+            filename_clean,
+            len(content_bytes),
+            mime_type,
+        )
 
-        # Store the artifact using the service
-        artifact_uri = await artifact_service.store(
-            app_name=app_name,
+        # Use the common upload helper
+        upload_result = await process_artifact_upload(
+            artifact_service=artifact_service,
+            component=component,
             user_id=user_id,
             session_id=effective_session_id,
             filename=filename_clean,
             content_bytes=content_bytes,
             mime_type=mime_type,
-            metadata=metadata,
+            metadata_json=metadata_json,
+            log_prefix=log_prefix,
+        )
+
+        if upload_result["status"] != "success":
+            error_msg = upload_result.get("message", "Failed to upload artifact")
+            error_type = upload_result.get("error", "unknown")
+
+            if error_type in ["invalid_filename", "empty_file"]:
+                status_code = status.HTTP_400_BAD_REQUEST
+            else:
+                status_code = status.HTTP_500_INTERNAL_SERVER_ERROR
+
+            log.error("%s%s", log_prefix, error_msg)
+            raise HTTPException(status_code=status_code, detail=error_msg)
+
+        artifact_uri = upload_result["artifact_uri"]
+        saved_version = upload_result["version"]
+
+        log.info(
+            "%sArtifact stored successfully: %s (%d bytes), version: %s",
+            log_prefix,
+            artifact_uri,
+            len(content_bytes),
+            saved_version,
         )
 
-        log.info("%sArtifact stored successfully: %s (%d bytes)", log_prefix, artifact_uri, len(content_bytes))
+        # Get metadata from upload result (it was already parsed and validated)
+        metadata_dict = {}
+        if metadata_json and metadata_json.strip():
+            try:
+                metadata_dict = json.loads(metadata_json.strip())
+                if not isinstance(metadata_dict, dict):
+                    metadata_dict = {}
+            except json.JSONDecodeError:
+                metadata_dict = {}
 
         # Return standardized response using Pydantic model (ensures camelCase conversion)
         return ArtifactUploadResponse(
@@ -232,8 +279,10 @@ async def upload_artifact_with_session(
             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
+            metadata=metadata_dict,
+            created_at=datetime.now(
+                timezone.utc
+            ).isoformat(),  # Will be returned as "createdAt" due to alias
         )
 
     except HTTPException:
@@ -785,7 +834,6 @@ async def get_artifact_by_uri(
             version,
         )
 
-
         log.info(
             "%s User '%s' authorized to access artifact URI.",
             log_id_prefix,
@@ -828,162 +876,6 @@ async def get_artifact_by_uri(
         )
 
 
-@router.post(
-    "/{session_id}/{filename}",
-    status_code=status.HTTP_201_CREATED,
-    response_model=dict[str, Any],
-    summary="Upload Artifact (Create/Update Version with Metadata)",
-    description="Uploads file content and optional metadata to create or update an artifact version.",
-)
-async def upload_artifact(
-    session_id: str = Path(
-        ..., title="Session ID", description="The session ID to upload artifacts to"
-    ),
-    filename: str = Path(
-        ..., title="Filename", description="The name of the artifact to create/update"
-    ),
-    upload_file: UploadFile = File(..., description="The file content to upload"),
-    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"])),
-):
-    """
-    Uploads a file to create a new version of the specified artifact
-    associated with the current user and session ID. Also saves associated metadata.
-    """
-    log_prefix = (
-        f"[ArtifactRouter:Post:{filename}] User={user_id}, Session={session_id} -"
-    )
-    log.info(
-        "%s Request received. Upload filename: '%s', content type: %s",
-        log_prefix,
-        upload_file.filename,
-        upload_file.content_type,
-    )
-
-    # 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.",
-        )
-
-    if artifact_service is None:
-        log.error("%s Artifact service is not configured or available.", log_prefix)
-        raise HTTPException(
-            status_code=status.HTTP_501_NOT_IMPLEMENTED,
-            detail="Artifact service is not configured.",
-        )
-
-    try:
-        content_bytes = await upload_file.read()
-        if not content_bytes:
-            log.warning("%s Uploaded file is empty.", log_prefix)
-            raise HTTPException(
-                status_code=status.HTTP_400_BAD_REQUEST,
-                detail="Uploaded file cannot be empty.",
-            )
-
-        mime_type = upload_file.content_type or "application/octet-stream"
-
-        parsed_metadata = {}
-        if metadata_json:
-            try:
-                parsed_metadata = json.loads(metadata_json)
-                if not isinstance(parsed_metadata, dict):
-                    log.warning(
-                        "%s Metadata JSON did not parse to a dictionary. Ignoring.",
-                        log_prefix,
-                    )
-                    parsed_metadata = {}
-            except json.JSONDecodeError as json_err:
-                log.warning(
-                    "%s Failed to parse metadata_json: %s. Proceeding without it.",
-                    log_prefix,
-                    json_err,
-                )
-
-        app_name = component.get_config("name", "A2A_WebUI_App")
-        current_timestamp = datetime.now(timezone.utc)
-
-        save_result = await save_artifact_with_metadata(
-            artifact_service=artifact_service,
-            app_name=app_name,
-            user_id=user_id,
-            session_id=session_id,
-            filename=filename,
-            content_bytes=content_bytes,
-            mime_type=mime_type,
-            metadata_dict=parsed_metadata,
-            timestamp=current_timestamp,
-            schema_max_keys=component.get_config(
-                "schema_max_keys", DEFAULT_SCHEMA_MAX_KEYS
-            ),
-        )
-
-        if save_result["status"] == "success":
-            log.info(
-                "%s Artifact and metadata processing completed. Data version: %s, Metadata version: %s. Message: %s",
-                log_prefix,
-                save_result.get("data_version"),
-                save_result.get("metadata_version"),
-                save_result.get("message"),
-            )
-            saved_version = save_result.get("data_version")
-            artifact_uri = format_artifact_uri(
-                app_name=app_name,
-                user_id=user_id,
-                session_id=session_id,
-                filename=filename,
-                version=saved_version,
-            )
-            log.info(
-                "%s Successfully saved artifact. Returning URI: %s",
-                log_prefix,
-                artifact_uri,
-            )
-            return {
-                "filename": filename,
-                "data_version": saved_version,
-                "metadata_version": save_result.get("metadata_version"),
-                "mime_type": mime_type,
-                "size": len(content_bytes),
-                "message": save_result.get("message"),
-                "status": save_result["status"],
-                "uri": artifact_uri,
-            }
-        else:
-            log.error(
-                "%s Failed to save artifact and metadata: %s",
-                log_prefix,
-                save_result.get("message"),
-            )
-            raise HTTPException(
-                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-                detail=save_result.get(
-                    "message", "Failed to save artifact with metadata."
-                ),
-            )
-
-    except HTTPException:
-        raise
-    except Exception as e:
-        log.exception("%s Error saving artifact: %s", log_prefix, e)
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=f"Failed to save artifact: {str(e)}",
-        )
-    finally:
-        await upload_file.close()
-        log.debug("%s Upload file closed.", log_prefix)
-
-
 @router.delete(
     "/{session_id}/{filename}",
     status_code=status.HTTP_204_NO_CONTENT,

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

@@ -4,7 +4,8 @@ Session-related response DTOs.
 
 from pydantic import BaseModel, ConfigDict, Field
 
-from ....shared.types import PaginationInfo, SessionId, UserId
+from ....shared.pagination import PaginationMeta
+from ....shared.types import SessionId, UserId
 from .base_responses import BaseTimestampResponse
 
 
@@ -20,10 +21,10 @@ class SessionResponse(BaseTimestampResponse):
 
 
 class SessionListResponse(BaseModel):
-    """Response DTO for a list of sessions."""
+    """Response DTO for a list of sessions (legacy - use PaginatedResponse instead)."""
 
     model_config = ConfigDict(populate_by_name=True)
 
     sessions: list[SessionResponse]
-    pagination: PaginationInfo | None = None
+    pagination: PaginationMeta | None = None
     total_count: int = Field(alias="totalCount")

solace_agent_mesh/gateway/http_sse/routers/sessions.py

@@ -149,8 +149,8 @@ async def save_task(
         # Check if task already exists to determine status code
         from ..repository.chat_task_repository import ChatTaskRepository
 
-        task_repo = ChatTaskRepository(db)
-        existing_task = task_repo.find_by_id(request.task_id, user_id)
+        task_repo = ChatTaskRepository()
+        existing_task = task_repo.find_by_id(db, request.task_id, user_id)
         is_update = existing_task is not None
 
         # Save the task - pass strings directly

solace_agent_mesh/gateway/http_sse/routers/tasks.py

@@ -3,50 +3,40 @@ API Router for submitting and managing tasks to agents.
 """
 
 import logging
-import yaml
 from datetime import datetime
-from fastapi import (
-    APIRouter,
-    Depends,
-    HTTPException,
-    Request as FastAPIRequest,
-    Response,
-    status,
-)
-from fastapi.exceptions import RequestValidationError
-from typing import List, Optional, Union
-
-
-from ....gateway.http_sse.session_manager import SessionManager
-from ....gateway.http_sse.services.task_service import TaskService
-from ....gateway.http_sse.services.session_service import SessionService
-from ....gateway.http_sse.repository.interfaces import ITaskRepository
-from ....gateway.http_sse.repository.entities import Task
-from ....gateway.http_sse.shared.types import PaginationParams, UserId
-from ..utils.stim_utils import create_stim_from_task_data
+from typing import TYPE_CHECKING
 
+import yaml
 from a2a.types import (
     CancelTaskRequest,
     SendMessageRequest,
-    SendStreamingMessageRequest,
     SendMessageSuccessResponse,
+    SendStreamingMessageRequest,
     SendStreamingMessageSuccessResponse,
 )
-from ....common import a2a
+from fastapi import APIRouter, Depends, HTTPException, Response, status
+from fastapi import Request as FastAPIRequest
+from sqlalchemy.orm import Session as DBSession
 
+from ....common import a2a
 from ....gateway.http_sse.dependencies import (
-    get_session_manager,
+    get_db,
     get_sac_component,
-    get_task_service,
     get_session_business_service,
+    get_session_manager,
     get_task_repository,
-    get_user_id,
+    get_task_service,
     get_user_config,
-    get_session_business_service,
+    get_user_id,
 )
+from ....gateway.http_sse.repository.entities import Task
+from ....gateway.http_sse.repository.interfaces import ITaskRepository
 from ....gateway.http_sse.services.session_service import SessionService
-
-from typing import TYPE_CHECKING
+from ....gateway.http_sse.services.task_service import TaskService
+from ....gateway.http_sse.session_manager import SessionManager
+from ....gateway.http_sse.shared.pagination import PaginationParams
+from ....gateway.http_sse.shared.types import UserId
+from ..utils.stim_utils import create_stim_from_task_data
 
 if TYPE_CHECKING:
     from ....gateway.http_sse.component import WebUIBackendComponent
@@ -55,9 +45,10 @@ router = APIRouter()
 
 log = logging.getLogger(__name__)
 
+
 async def _submit_task(
     request: FastAPIRequest,
-    payload: Union[SendMessageRequest, SendStreamingMessageRequest],
+    payload: SendMessageRequest | SendStreamingMessageRequest,
     session_manager: SessionManager,
     component: "WebUIBackendComponent",
     is_streaming: bool,
@@ -203,25 +194,25 @@ async def _submit_task(
         )
 
 
-@router.get("/tasks", response_model=List[Task], tags=["Tasks"])
+@router.get("/tasks", response_model=list[Task], tags=["Tasks"])
 async def search_tasks(
     request: FastAPIRequest,
-    start_date: Optional[str] = None,
-    end_date: Optional[str] = None,
-    search: Optional[str] = None,
+    start_date: str | None = None,
+    end_date: str | None = None,
     page: int = 1,
     page_size: int = 20,
-    query_user_id: Optional[str] = None,
+    query_user_id: str | None = None,
+    db: DBSession = Depends(get_db),
     user_id: UserId = Depends(get_user_id),
     user_config: dict = Depends(get_user_config),
     repo: ITaskRepository = Depends(get_task_repository),
 ):
     """
-    Lists and searches for historical tasks.
-    - Regular users can only search their own tasks.
-    - Users with the 'tasks:read:all' scope can search for any user's tasks by providing `query_user_id`.
+    Lists and filters historical tasks by date.
+    - Regular users can only view their own tasks.
+    - Users with the 'tasks:read:all' scope can view any user's tasks by providing `query_user_id`.
     """
-    log_prefix = f"[GET /api/v1/tasks] "
+    log_prefix = "[GET /api/v1/tasks] "
     log.info("%sRequest from user %s", log_prefix, user_id)
 
     target_user_id = user_id
@@ -265,14 +256,14 @@ async def search_tasks(
                 detail="Invalid end_date format. Use ISO 8601 format.",
             )
 
-    pagination = PaginationParams(page=page, page_size=page_size)
+    pagination = PaginationParams(page_number=page, page_size=page_size)
 
     try:
         tasks = repo.search(
+            db,
             user_id=target_user_id,
             start_date=start_time_ms,
             end_date=end_time_ms,
-            search_query=search,
             pagination=pagination,
         )
         return tasks
@@ -288,6 +279,7 @@ async def search_tasks(
 async def get_task_as_stim_file(
     task_id: str,
     request: FastAPIRequest,
+    db: DBSession = Depends(get_db),
     user_id: UserId = Depends(get_user_id),
     user_config: dict = Depends(get_user_config),
     repo: ITaskRepository = Depends(get_task_repository),
@@ -299,7 +291,7 @@ async def get_task_as_stim_file(
     log.info("%sRequest from user %s", log_prefix, user_id)
 
     try:
-        result = repo.find_by_id_with_events(task_id)
+        result = repo.find_by_id_with_events(db, task_id)
         if not result:
             raise HTTPException(
                 status_code=status.HTTP_404_NOT_FOUND,

solace_agent_mesh/gateway/http_sse/routers/visualization.py

@@ -134,26 +134,32 @@ from sse_starlette.sse import EventSourceResponse
 
 def _generate_sse_url(fastapi_request: FastAPIRequest, stream_id: str) -> str:
     """
-    Generate SSE endpoint URL with proper scheme detection for reverse proxy scenarios.
+    Generate SSE endpoint URL with proper scheme and host detection for reverse proxy scenarios.
 
     Args:
         fastapi_request: The FastAPI request object
         stream_id: The stream ID for the SSE endpoint
 
     Returns:
-        Complete SSE URL with correct scheme (http/https)
+        Complete SSE URL with correct scheme (http/https) and host.
     """
+    base_url = fastapi_request.url_for(
+        "get_visualization_stream_events", stream_id=stream_id
+    )
+
     forwarded_proto = fastapi_request.headers.get("x-forwarded-proto")
-    if forwarded_proto and forwarded_proto.lower() == "https":
-        scheme = "https"
+    forwarded_host = fastapi_request.headers.get("x-forwarded-host")
+
+    if forwarded_proto and forwarded_host:
+        # In a reverse proxy environment like GitHub Codespaces, reconstruct the URL
+        # using the forwarded headers to ensure it's publicly accessible.
+        return str(base_url.replace(scheme=forwarded_proto, netloc=forwarded_host))
+    elif forwarded_proto:
+        # Handle cases with only a forwarded protocol (standard reverse proxy)
+        return str(base_url.replace(scheme=forwarded_proto))
     else:
-        scheme = fastapi_request.url.scheme
-
-    return str(
-        fastapi_request.url_for(
-            "get_visualization_stream_events", stream_id=stream_id
-        ).replace(scheme=scheme)
-    )
+        # Default behavior when not behind a reverse proxy
+        return str(base_url)
 
 
 def _translate_target_to_solace_topics(

solace_agent_mesh/gateway/http_sse/services/data_retention_service.py

@@ -188,8 +188,8 @@ class DataRetentionService:
 
         db = self.session_factory()
         try:
-            repo = TaskRepository(db)
-            total_deleted = repo.delete_tasks_older_than(cutoff_time_ms, batch_size)
+            repo = TaskRepository()
+            total_deleted = repo.delete_tasks_older_than(db, cutoff_time_ms, batch_size)
 
             if total_deleted == 0:
                 log.info(
@@ -241,8 +241,8 @@ class DataRetentionService:
 
         db = self.session_factory()
         try:
-            repo = FeedbackRepository(db)
-            total_deleted = repo.delete_feedback_older_than(cutoff_time_ms, batch_size)
+            repo = FeedbackRepository()
+            total_deleted = repo.delete_feedback_older_than(db, cutoff_time_ms, batch_size)
 
             if total_deleted == 0:
                 log.info(