solace-agent-mesh 1.1.0__py3-none-any.whl → 1.3.0__py3-none-any.whl

solace_agent_mesh/gateway/http_sse/api/controllers/session_controller.py

@@ -0,0 +1,355 @@
+from fastapi import APIRouter, Body, Depends, HTTPException, status
+from solace_ai_connector.common.log import log
+
+from ...application.services.session_service import SessionService
+from ...dependencies import (
+    PublishFunc,
+    get_namespace,
+    get_publish_a2a_func,
+    get_session_service,
+)
+from ...shared.auth_utils import get_current_user
+from ..dto.requests.session_requests import (
+    DeleteSessionRequest,
+    GetSessionHistoryRequest,
+    GetSessionRequest,
+    GetSessionsRequest,
+    UpdateSessionRequest,
+)
+from ..dto.responses.session_responses import (
+    MessageResponse,
+    SessionListResponse,
+    SessionResponse,
+)
+
+router = APIRouter()
+
+
+@router.get("/sessions", response_model=SessionListResponse)
+async def get_all_sessions(
+    user: dict = Depends(get_current_user),
+    session_service: SessionService = Depends(get_session_service),
+):
+    user_id = user.get("id")
+    log.info("Fetching sessions for user_id: %s", user_id)
+
+    try:
+        request_dto = GetSessionsRequest(user_id=user_id)
+
+        session_domains = session_service.get_user_sessions(
+            user_id=request_dto.user_id, pagination=request_dto.pagination
+        )
+
+        session_responses = []
+        for domain in session_domains:
+            session_response = SessionResponse(
+                id=domain.id,
+                user_id=domain.user_id,
+                name=domain.name,
+                agent_id=domain.agent_id,
+                status=domain.status,
+                created_at=domain.created_at,
+                updated_at=domain.updated_at,
+                last_activity=domain.last_activity,
+            )
+            session_responses.append(session_response)
+
+        return SessionListResponse(
+            sessions=session_responses,
+            total_count=len(session_responses),
+            pagination=request_dto.pagination,
+        )
+
+    except Exception as e:
+        log.error("Error fetching sessions for user %s: %s", user_id, e)
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to retrieve sessions",
+        )
+
+
+@router.get("/sessions/{session_id}", response_model=SessionResponse)
+async def get_session(
+    session_id: str,
+    user: dict = Depends(get_current_user),
+    session_service: SessionService = Depends(get_session_service),
+):
+    user_id = user.get("id")
+    log.info("User %s attempting to fetch session_id: %s", user_id, session_id)
+
+    try:
+        if (
+            not session_id
+            or session_id.strip() == ""
+            or session_id in ["null", "undefined"]
+        ):
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND, detail="Session not found."
+            )
+
+        request_dto = GetSessionRequest(session_id=session_id, user_id=user_id)
+
+        session_domain = session_service.get_session(
+            session_id=request_dto.session_id, user_id=request_dto.user_id
+        )
+
+        if not session_domain:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND, detail="Session not found."
+            )
+
+        log.info("User %s authorized. Fetching session_id: %s", user_id, session_id)
+
+        return SessionResponse(
+            id=session_domain.id,
+            user_id=session_domain.user_id,
+            name=session_domain.name,
+            agent_id=session_domain.agent_id,
+            status=session_domain.status,
+            created_at=session_domain.created_at,
+            updated_at=session_domain.updated_at,
+            last_activity=session_domain.last_activity,
+        )
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        log.error(
+            "Error fetching session %s for user %s: %s",
+            session_id,
+            user_id,
+            e,
+        )
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to retrieve session",
+        )
+
+
+@router.get("/sessions/{session_id}/messages")
+async def get_session_history(
+    session_id: str,
+    user: dict = Depends(get_current_user),
+    session_service: SessionService = Depends(get_session_service),
+):
+    user_id = user.get("id")
+    log.info(
+        "User %s attempting to fetch history for session_id: %s", user_id, session_id
+    )
+
+    try:
+        if (
+            not session_id
+            or session_id.strip() == ""
+            or session_id in ["null", "undefined"]
+        ):
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND, detail="Session not found."
+            )
+
+        request_dto = GetSessionHistoryRequest(session_id=session_id, user_id=user_id)
+
+        history_domain = session_service.get_session_history(
+            session_id=request_dto.session_id,
+            user_id=request_dto.user_id,
+            pagination=request_dto.pagination,
+        )
+
+        if not history_domain:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND, detail="Session not found."
+            )
+
+        log.info(
+            "User %s authorized. Fetching history for session_id: %s",
+            user_id,
+            session_id,
+        )
+
+        message_responses = []
+        for message_domain in history_domain.messages:
+            message_response = MessageResponse(
+                id=message_domain.id,
+                session_id=message_domain.session_id,
+                message=message_domain.message,
+                sender_type=message_domain.sender_type,
+                sender_name=message_domain.sender_name,
+                message_type=message_domain.message_type,
+                timestamp=message_domain.created_at,
+                created_at=message_domain.created_at,
+            )
+            message_responses.append(message_response)
+
+        return message_responses
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        log.error(
+            "Error fetching history for session %s for user %s: %s",
+            session_id,
+            user_id,
+            e,
+        )
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to retrieve session history",
+        )
+
+
+@router.patch("/sessions/{session_id}", response_model=SessionResponse)
+async def update_session_name(
+    session_id: str,
+    name: str = Body(..., embed=True),
+    user: dict = Depends(get_current_user),
+    session_service: SessionService = Depends(get_session_service),
+):
+    user_id = user.get("id")
+    log.info("User %s attempting to update session %s", user_id, session_id)
+
+    try:
+        if (
+            not session_id
+            or session_id.strip() == ""
+            or session_id in ["null", "undefined"]
+        ):
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND, detail="Session not found."
+            )
+
+        request_dto = UpdateSessionRequest(
+            session_id=session_id, user_id=user_id, name=name
+        )
+
+        updated_domain = session_service.update_session_name(
+            session_id=request_dto.session_id,
+            user_id=request_dto.user_id,
+            name=request_dto.name,
+        )
+
+        if not updated_domain:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND, detail="Session not found."
+            )
+
+        log.info("Session %s updated successfully", session_id)
+
+        return SessionResponse(
+            id=updated_domain.id,
+            user_id=updated_domain.user_id,
+            name=updated_domain.name,
+            agent_id=updated_domain.agent_id,
+            status=updated_domain.status,
+            created_at=updated_domain.created_at,
+            updated_at=updated_domain.updated_at,
+            last_activity=updated_domain.last_activity,
+        )
+
+    except HTTPException:
+        raise
+    except ValueError as e:
+        log.warning("Validation error updating session %s: %s", session_id, e)
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY, detail=str(e)
+        )
+    except Exception as e:
+        log.error(
+            "Error updating session %s for user %s: %s",
+            session_id,
+            user_id,
+            e,
+        )
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to update session",
+        )
+
+
+@router.delete("/sessions/{session_id}", status_code=status.HTTP_204_NO_CONTENT)
+async def delete_session(
+    session_id: str,
+    user: dict = Depends(get_current_user),
+    session_service: SessionService = Depends(get_session_service),
+    publish_func: PublishFunc = Depends(get_publish_a2a_func),
+    namespace: str = Depends(get_namespace),
+):
+    user_id = user.get("id")
+    log.info("User %s attempting to delete session %s", user_id, session_id)
+
+    try:
+        if (
+            not session_id
+            or session_id.strip() == ""
+            or session_id in ["null", "undefined"]
+        ):
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND, detail="Session not found."
+            )
+
+        request_dto = DeleteSessionRequest(session_id=session_id, user_id=user_id)
+
+        # Get session details before deletion to find the agent_id
+        session = session_service.get_session(session_id=session_id, user_id=user_id)
+        if not session:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND, detail="Session not found."
+            )
+
+        agent_id = session.agent_id
+
+        deleted = session_service.delete_session(
+            session_id=request_dto.session_id, user_id=request_dto.user_id
+        )
+
+        if not deleted:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND, detail="Session not found."
+            )
+
+        log.info("Session %s deleted successfully", session_id)
+
+        if agent_id:
+            try:
+                from solace_agent_mesh.common.a2a.protocol import (
+                    get_agent_request_topic,
+                )
+
+                control_message = {
+                    "control": {
+                        "action": "delete_session",
+                        "session_id": session_id,
+                        "user_id": user_id,
+                    }
+                }
+
+                target_topic = get_agent_request_topic(namespace, agent_id)
+
+                log.info(
+                    "Sending session deletion notification to agent %s for session %s",
+                    agent_id,
+                    session_id,
+                )
+
+                publish_func(target_topic, control_message, None)
+
+            except Exception as e:
+                log.warning(
+                    "Failed to notify agent %s about session %s deletion: %s",
+                    agent_id,
+                    session_id,
+                    e,
+                )
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        log.error(
+            "Error deleting session %s for user %s: %s",
+            session_id,
+            user_id,
+            e,
+        )
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to delete session",
+        )

solace_agent_mesh/gateway/http_sse/api/controllers/task_controller.py

@@ -0,0 +1,279 @@
+from typing import TYPE_CHECKING
+
+from fastapi import APIRouter, Depends, File, Form, HTTPException
+from fastapi import Request as FastAPIRequest
+from fastapi import UploadFile, status
+from solace_ai_connector.common.log import log
+
+from a2a.types import InternalError, InvalidRequestError, JSONRPCResponse
+from .....common import a2a
+from ...dependencies import (
+    get_sac_component,
+    get_session_manager,
+    get_user_id,
+)
+from ...session_manager import SessionManager
+from ...shared.enums import SenderType
+from ..dto.requests.task_requests import (
+    CancelTaskRequest,
+    ProcessedTaskRequest,
+    TaskFilesInfo,
+)
+
+if TYPE_CHECKING:
+    from ...component import WebUIBackendComponent
+
+router = APIRouter()
+
+
+@router.post("/send", response_model=JSONRPCResponse)
+async def send_task_to_agent(
+    request: FastAPIRequest,
+    agent_name: str = Form(...),
+    message: str = Form(...),
+    files: list[UploadFile] = File([]),
+    session_manager: SessionManager = Depends(get_session_manager),
+    component: "WebUIBackendComponent" = Depends(get_sac_component),
+    user_id: str = Depends(get_user_id),
+):
+    """
+    Submits a non-streaming task request to the specified agent.
+    This corresponds to the A2A `tasks/send` method.
+    """
+    log_prefix = "[POST /api/v1/tasks/send] "
+    log.info("%sReceived request for agent: %s", log_prefix, agent_name)
+
+    try:
+        task_files = []
+        for file in files:
+            if file.filename:
+                task_files.append(
+                    TaskFilesInfo(
+                        filename=file.filename,
+                        content_type=file.content_type or "application/octet-stream",
+                        size=0,  # We'd need to read the file to get size
+                    )
+                )
+
+        request_dto = ProcessedTaskRequest(
+            agent_name=agent_name, message=message, user_id=user_id, files=task_files
+        )
+
+        # Continue with existing logic
+        client_id = session_manager.get_a2a_client_id(request)
+        session_id = session_manager.ensure_a2a_session(request)
+
+        log.info(
+            "%sUsing ClientID: %s, SessionID: %s", log_prefix, client_id, session_id
+        )
+
+        external_event_data = {
+            "agent_name": agent_name,
+            "message": message,
+            "files": files,
+            "client_id": client_id,
+            "a2a_session_id": session_id,
+        }
+        (
+            target_agent,
+            a2a_parts,
+            external_request_context,
+        ) = await component._translate_external_input(external_event_data)
+
+        user_identity = {"id": user_id}
+        log.info(
+            "%sAuthenticated user identity: %s",
+            log_prefix,
+            user_identity.get("id", "unknown"),
+        )
+        task_id = await component.submit_a2a_task(
+            target_agent_name=target_agent,
+            a2a_parts=a2a_parts,
+            user_identity=user_identity,
+            external_request_context=external_request_context,
+            is_streaming=False,
+        )
+
+        log.info(
+            "%sNon-streaming task submitted successfully. TaskID: %s",
+            log_prefix,
+            task_id,
+        )
+
+        return JSONRPCResponse(result={"taskId": task_id})
+
+    except InvalidRequestError as e:
+        log.warning("%sInvalid request: %s", log_prefix, e.message, exc_info=True)
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=e.model_dump(exclude_none=True),
+        )
+    except Exception as e:
+        log.exception("%sUnexpected error processing task: %s", log_prefix, e)
+        error_resp = a2a.create_internal_error(message=f"Failed to process task: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=error_resp.model_dump(exclude_none=True),
+        )
+
+
+@router.post("/subscribe", response_model=JSONRPCResponse)
+async def subscribe_task_from_agent(
+    request: FastAPIRequest,
+    agent_name: str = Form(...),
+    message: str = Form(...),
+    files: list[UploadFile] = File([]),
+    session_id: str | None = Form(None),
+    session_manager: SessionManager = Depends(get_session_manager),
+    component: "WebUIBackendComponent" = Depends(get_sac_component),
+    user_id: str = Depends(get_user_id),
+):
+    """
+    Submits a streaming task request (`tasks/sendSubscribe`) to the specified agent.
+    """
+    log_prefix = "[POST /api/v1/tasks/subscribe] "
+    log.info("%sReceived streaming request for agent: %s", log_prefix, agent_name)
+
+    try:
+        task_files = []
+        for file in files:
+            if file.filename:
+                task_files.append(
+                    TaskFilesInfo(
+                        filename=file.filename,
+                        content_type=file.content_type or "application/octet-stream",
+                        size=0,
+                    )
+                )
+
+        request_dto = ProcessedTaskRequest(
+            agent_name=agent_name,
+            message=message,
+            user_id=user_id,
+            session_id=session_id,
+            files=task_files,
+        )
+
+        client_id = session_manager.get_a2a_client_id(request)
+
+        # If session_id is not provided by the client, create a new one.
+        if not session_id:
+            log.info("%sNo session_id provided, creating a new one.", log_prefix)
+            session_id = session_manager.start_new_a2a_session(request)
+
+        # Store message only if persistence is available
+        if hasattr(component, "persistence_service") and component.persistence_service:
+            try:
+                from ...dependencies import get_session_service
+                session_service = get_session_service(component)
+                message_domain = session_service.add_message_to_session(
+                    session_id=session_id,
+                    user_id=user_id,
+                    message=message,
+                    sender_type=SenderType.USER,
+                    sender_name=user_id,
+                    agent_id=agent_name,
+                )
+                # Use the actual session ID from the message (may be different if session was recreated)
+                if message_domain:
+                    session_id = message_domain.session_id
+            except ValueError as e:
+                # Handle business domain validation errors
+                log.warning("Validation error in session service: %s", e)
+                raise HTTPException(
+                    status_code=status.HTTP_422_UNPROCESSABLE_ENTITY, detail=str(e)
+                )
+            except Exception as e:
+                log.error("Failed to store message in session service: %s", e)
+                raise HTTPException(
+                    status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                    detail="Failed to store message",
+                )
+        else:
+            log.debug("%sNo persistence available - skipping message storage", log_prefix)
+
+        log.info(
+            "%sUsing ClientID: %s, SessionID: %s", log_prefix, client_id, session_id
+        )
+
+        external_event_data = {
+            "agent_name": agent_name,
+            "message": message,
+            "files": files,
+            "client_id": client_id,
+            "a2a_session_id": session_id,
+        }
+        (
+            target_agent,
+            a2a_parts,
+            external_request_context,
+        ) = await component._translate_external_input(external_event_data)
+
+        user_identity = {"id": user_id}
+        log.info(
+            "%sAuthenticated user identity: %s",
+            log_prefix,
+            user_identity.get("id", "unknown"),
+        )
+        task_id = await component.submit_a2a_task(
+            target_agent_name=target_agent,
+            a2a_parts=a2a_parts,
+            user_identity=user_identity,
+            external_request_context=external_request_context,
+            is_streaming=True,
+        )
+
+        log.info(
+            "%sStreaming task submitted successfully. TaskID: %s", log_prefix, task_id
+        )
+
+        return JSONRPCResponse(result={"taskId": task_id, "sessionId": session_id})
+
+    except InvalidRequestError as e:
+        log.warning("%sInvalid request: %s", log_prefix, e.message, exc_info=True)
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=e.model_dump(exclude_none=True),
+        )
+    except HTTPException:
+        # Re-raise HTTPExceptions (like 422 validation errors) without modification
+        raise
+    except Exception as e:
+        log.exception("%sUnexpected error processing task: %s", log_prefix, e)
+        error_resp = a2a.create_internal_error(message=f"Failed to process task: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=error_resp.model_dump(exclude_none=True),
+        )
+
+
+@router.post("/cancel", response_model=JSONRPCResponse)
+async def cancel_agent_task(
+    request: FastAPIRequest,
+    task_id: str = Form(...),
+    session_manager: SessionManager = Depends(get_session_manager),
+    component: "WebUIBackendComponent" = Depends(get_sac_component),
+    user_id: str = Depends(get_user_id),
+):
+    """
+    Sends a cancellation request for a specific task.
+    """
+    log_prefix = f"[POST /api/v1/tasks/cancel] TaskID: {task_id} "
+    log.info("%sReceived cancellation request.", log_prefix)
+
+    try:
+        request_dto = CancelTaskRequest(task_id=task_id, user_id=user_id)
+
+        client_id = session_manager.get_a2a_client_id(request)
+        await component.cancel_a2a_task(task_id, client_id)
+        log.info("%sCancellation request sent successfully.", log_prefix)
+        return JSONRPCResponse(
+            result={"message": f"Cancellation request sent for task {task_id}"}
+        )
+    except Exception as e:
+        log.exception("%sUnexpected error sending cancellation: %s", log_prefix, e)
+        error_resp = a2a.create_internal_error(message="Unexpected server error: %s" % e)
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=error_resp.model_dump(exclude_none=True),
+        )

solace_agent_mesh/gateway/http_sse/api/controllers/user_controller.py

@@ -0,0 +1,35 @@
+"""
+Router for user-related endpoints.
+Maintains backward compatibility with original API format.
+"""
+
+from typing import Any
+
+from fastapi import APIRouter, Depends
+from solace_ai_connector.common.log import log
+
+from ...shared.auth_utils import get_current_user
+
+router = APIRouter()
+
+
+@router.get("/me", response_model=dict[str, Any])
+async def get_current_user_endpoint(
+    user: dict = Depends(get_current_user),
+):
+    log.info("[GET /api/v1/users/me] Request received.")
+
+    # Get the user ID with proper priority
+    username = (
+        user.get("id")  # Primary ID from AuthMiddleware
+        or user.get("user_id")
+        or user.get("username")
+        or user.get("email")
+        or "anonymous"
+    )
+
+    return {
+        "username": username,
+        "authenticated": user.get("authenticated", False),
+        "auth_method": user.get("auth_method", "none"),
+    }

solace_agent_mesh/gateway/http_sse/api/dto/__init__.py

@@ -0,0 +1,10 @@
+"""
+Data Transfer Objects (DTOs)
+
+Contains request and response DTOs for API contract definition and validation.
+"""
+
+from . import requests
+from . import responses
+
+__all__ = ["requests", "responses"]