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

solace_agent_mesh/gateway/http_sse/routers/artifacts.py

@@ -2,6 +2,7 @@
 FastAPI router for managing session-specific artifacts via REST endpoints.
 """
 
+import logging
 from collections.abc import Callable
 from typing import TYPE_CHECKING, Any
 
@@ -32,8 +33,6 @@ import json
 from datetime import datetime, timezone
 from urllib.parse import parse_qs, quote, urlparse
 
-from solace_ai_connector.common.log import log
-
 from ....common.a2a.types import ArtifactInfo
 from ....common.utils.embeds import (
     LATE_EMBED_TYPES,
@@ -46,31 +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/auth.py

@@ -2,6 +2,7 @@
 Router for handling authentication-related endpoints.
 """
 
+import logging
 from fastapi import (
     APIRouter,
     Request as FastAPIRequest,
@@ -15,7 +16,8 @@ import secrets
 from urllib.parse import urlencode
 
 from ...http_sse.dependencies import get_sac_component, get_api_config
-from solace_ai_connector.common.log import log
+
+log = logging.getLogger(__name__)
 
 router = APIRouter()
 

solace_agent_mesh/gateway/http_sse/routers/config.py

@@ -2,17 +2,18 @@
 API Router for providing frontend configuration.
 """
 
+import logging
 from fastapi import APIRouter, Depends, HTTPException, status
 from typing import Dict, Any
 
-from solace_ai_connector.common.log import log
-
 from ....gateway.http_sse.dependencies import get_sac_component, get_api_config
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
     from gateway.http_sse.component import WebUIBackendComponent
 
+log = logging.getLogger(__name__)
+
 router = APIRouter()
 
 

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/people.py

@@ -2,16 +2,18 @@
 API endpoints for people-related features, such as user search for autocomplete.
 """
 
+import logging
 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
 from ..shared.pagination import DataResponse
 from ..shared.response_utils import create_data_response
 
+log = logging.getLogger(__name__)
+
 router = APIRouter()
 
 

solace_agent_mesh/gateway/http_sse/routers/sessions.py

@@ -1,5 +1,5 @@
+import logging
 from fastapi import APIRouter, Body, Depends, HTTPException, Query, status
-from solace_ai_connector.common.log import log
 from sqlalchemy.orm import Session
 
 from ..dependencies import get_session_business_service, get_db
@@ -15,6 +15,8 @@ from .dto.requests.task_requests import SaveTaskRequest
 from .dto.responses.session_responses import SessionResponse
 from .dto.responses.task_responses import TaskResponse, TaskListResponse
 
+log = logging.getLogger(__name__)
+
 router = APIRouter()
 
 SESSION_NOT_FOUND_MSG = "Session not found."
@@ -147,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/sse.py

@@ -2,17 +2,18 @@
 API Router for Server-Sent Events (SSE) subscriptions.
 """
 
+import logging
 import asyncio
 import json
 from fastapi import APIRouter, Depends, Request as FastAPIRequest, HTTPException, status
 
-from solace_ai_connector.common.log import log
-
 from sse_starlette.sse import EventSourceResponse
 
 from ....gateway.http_sse.sse_manager import SSEManager
 from ....gateway.http_sse.dependencies import get_sse_manager
 
+log = logging.getLogger(__name__)
+
 router = APIRouter()