solace-agent-mesh 1.3.1__py3-none-any.whl → 1.3.3__py3-none-any.whl

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

@@ -1,279 +0,0 @@
-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/dto/requests/__init__.py

@@ -1,37 +0,0 @@
-"""
-Request DTOs for API endpoints.
-"""
-
-from .session_requests import (
-    GetSessionsRequest,
-    GetSessionRequest,
-    GetSessionHistoryRequest,
-    UpdateSessionRequest,
-    DeleteSessionRequest,
-    CreateSessionRequest,
-)
-from .task_requests import (
-    SendTaskRequest,
-    SubscribeTaskRequest,
-    CancelTaskRequest,
-    GetTaskStatusRequest,
-    TaskFilesInfo,
-    ProcessedTaskRequest,
-)
-
-__all__ = [
-    # Session requests
-    "GetSessionsRequest",
-    "GetSessionRequest", 
-    "GetSessionHistoryRequest",
-    "UpdateSessionRequest",
-    "DeleteSessionRequest",
-    "CreateSessionRequest",
-    # Task requests
-    "SendTaskRequest",
-    "SubscribeTaskRequest",
-    "CancelTaskRequest",
-    "GetTaskStatusRequest",
-    "TaskFilesInfo",
-    "ProcessedTaskRequest",
-]

solace_agent_mesh/gateway/http_sse/api/dto/requests/task_requests.py

@@ -1,66 +0,0 @@
-"""
-Task-related request DTOs.
-"""
-
-from typing import List, Optional, Dict, Any
-from pydantic import BaseModel, Field
-from fastapi import UploadFile
-
-from ....shared.types import TaskId, UserId, SessionId, AgentId
-
-
-class SendTaskRequest(BaseModel):
-    """Request DTO for sending a non-streaming task."""
-    agent_name: str = Field(..., description="The name of the target A2A agent")
-    message: str = Field(..., description="The user's message or prompt")
-    user_id: UserId
-    client_id: Optional[str] = None
-    session_id: Optional[SessionId] = None
-    
-    class Config:
-        # UploadFile cannot be included in Pydantic models directly
-        # Files will be handled separately in the controller
-        arbitrary_types_allowed = True
-
-
-class SubscribeTaskRequest(BaseModel):
-    """Request DTO for sending a streaming task."""
-    agent_name: str = Field(..., description="The name of the target A2A agent")
-    message: str = Field(..., description="The user's message or prompt")
-    user_id: UserId
-    session_id: Optional[SessionId] = None
-    client_id: Optional[str] = None
-    
-    class Config:
-        arbitrary_types_allowed = True
-
-
-class CancelTaskRequest(BaseModel):
-    """Request DTO for cancelling a task."""
-    task_id: TaskId = Field(..., description="The ID of the task to cancel")
-    client_id: Optional[str] = None
-    user_id: UserId
-
-
-class GetTaskStatusRequest(BaseModel):
-    """Request DTO for getting task status."""
-    task_id: TaskId
-    user_id: UserId
-
-
-class TaskFilesInfo(BaseModel):
-    """Information about uploaded files for a task."""
-    filename: str
-    content_type: str
-    size: int
-    
-    
-class ProcessedTaskRequest(BaseModel):
-    """Internal DTO for processed task request with file information."""
-    agent_name: str
-    message: str
-    user_id: UserId
-    session_id: Optional[SessionId] = None
-    client_id: Optional[str] = None
-    files: List[TaskFilesInfo] = []
-    metadata: Optional[Dict[str, Any]] = None

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

@@ -1,43 +0,0 @@
-"""
-Response DTOs for API endpoints.
-"""
-
-from .session_responses import (
-    MessageResponse,
-    SessionResponse,
-    SessionListResponse,
-    SessionHistoryResponse,
-    SessionCreatedResponse,
-    SessionUpdatedResponse,
-    SessionDeletedResponse,
-)
-from .task_responses import (
-    TaskResponse,
-    SendTaskResponse,
-    SubscribeTaskResponse,
-    CancelTaskResponse,
-    TaskStatusResponse,
-    TaskListResponse,
-    TaskErrorResponse,
-    JSONRPCTaskResponse,
-)
-
-__all__ = [
-    # Session responses
-    "MessageResponse",
-    "SessionResponse",
-    "SessionListResponse",
-    "SessionHistoryResponse",
-    "SessionCreatedResponse",
-    "SessionUpdatedResponse",
-    "SessionDeletedResponse",
-    # Task responses
-    "TaskResponse",
-    "SendTaskResponse",
-    "SubscribeTaskResponse",
-    "CancelTaskResponse",
-    "TaskStatusResponse",
-    "TaskListResponse",
-    "TaskErrorResponse",
-    "JSONRPCTaskResponse",
-]

solace_agent_mesh/gateway/http_sse/api/dto/responses/task_responses.py

@@ -1,74 +0,0 @@
-"""
-Task-related response DTOs.
-"""
-
-from typing import Optional, Dict, Any, List
-from datetime import datetime
-from pydantic import BaseModel, Field
-
-from ....shared.types import TaskId, UserId, SessionId, AgentId
-from ....shared.enums import TaskStatus
-
-
-class TaskResponse(BaseModel):
-    """Response DTO for task information."""
-    task_id: TaskId
-    agent_name: str
-    status: TaskStatus
-    user_id: UserId
-    session_id: Optional[SessionId] = None
-    created_at: datetime
-    updated_at: Optional[datetime] = None
-    completed_at: Optional[datetime] = None
-    error_message: Optional[str] = None
-    metadata: Optional[Dict[str, Any]] = None
-
-
-class SendTaskResponse(BaseModel):
-    """Response DTO for send task endpoint."""
-    task_id: TaskId
-    message: str = "Task submitted successfully"
-    status: TaskStatus = TaskStatus.PENDING
-
-
-class SubscribeTaskResponse(BaseModel):
-    """Response DTO for subscribe task endpoint."""
-    task_id: TaskId
-    session_id: SessionId
-    message: str = "Streaming task submitted successfully"
-    status: TaskStatus = TaskStatus.PENDING
-
-
-class CancelTaskResponse(BaseModel):
-    """Response DTO for cancel task endpoint."""
-    task_id: TaskId
-    message: str = "Cancellation request sent successfully"
-    cancelled_at: datetime
-
-
-class TaskStatusResponse(BaseModel):
-    """Response DTO for task status."""
-    task: TaskResponse
-
-
-class TaskListResponse(BaseModel):
-    """Response DTO for listing tasks."""
-    tasks: List[TaskResponse]
-    total_count: int
-
-
-class TaskErrorResponse(BaseModel):
-    """Response DTO for task errors."""
-    task_id: TaskId
-    error_type: str
-    error_message: str
-    error_details: Optional[Dict[str, Any]] = None
-    occurred_at: datetime
-
-
-class JSONRPCTaskResponse(BaseModel):
-    """Response DTO matching the existing JSONRPC format."""
-    result: Dict[str, Any]
-    error: Optional[Dict[str, Any]] = None
-    id: Optional[str] = None
-    jsonrpc: str = "2.0"

solace_agent_mesh/gateway/http_sse/application/__init__.py

@@ -1,3 +0,0 @@
-from .services.session_service import SessionService
-
-__all__ = ["SessionService"]

solace_agent_mesh/gateway/http_sse/application/services/__init__.py

@@ -1,3 +0,0 @@
-from .session_service import SessionService
-
-__all__ = ["SessionService"]

solace_agent_mesh/gateway/http_sse/application/services/session_service.py

@@ -1,135 +0,0 @@
-import uuid
-from datetime import datetime, timezone
-
-from solace_ai_connector.common.log import log
-
-from ...domain.entities.session import Message, Session, SessionHistory
-from ...domain.repositories.session_repository import (
-    IMessageRepository,
-    ISessionRepository,
-)
-from ...shared.enums import MessageType, SenderType, SessionStatus
-from ...shared.types import PaginationInfo, SessionId, UserId
-
-
-class SessionService:
-    def __init__(
-        self,
-        session_repository: ISessionRepository,
-        message_repository: IMessageRepository,
-    ):
-        self.session_repository = session_repository
-        self.message_repository = message_repository
-
-    def get_user_sessions(
-        self, user_id: UserId, pagination: PaginationInfo | None = None
-    ) -> list[Session]:
-        return self.session_repository.get_by_user_id(user_id, pagination)
-
-    def get_session(self, session_id: SessionId, user_id: UserId) -> Session | None:
-        return self.session_repository.get_user_session(session_id, user_id)
-
-    def get_session_history(
-        self,
-        session_id: SessionId,
-        user_id: UserId,
-        pagination: PaginationInfo | None = None,
-    ) -> SessionHistory | None:
-        session = self.session_repository.get_user_session(session_id, user_id)
-        if not session:
-            return None
-
-        messages = self.message_repository.get_by_session_id(session_id, pagination)
-
-        return SessionHistory(
-            session=session,
-            messages=messages,
-            total_message_count=len(messages),
-        )
-
-    def create_session(
-        self,
-        user_id: UserId,
-        name: str | None = None,
-        agent_id: str | None = None,
-        session_id: str | None = None,
-    ) -> Session:
-        if not user_id or user_id.strip() == "":
-            raise ValueError(f"user_id cannot be None or empty. Received: {user_id}")
-
-        if not session_id:
-            session_id = str(uuid.uuid4())
-
-        now = datetime.now(timezone.utc)
-        session = Session(
-            id=session_id,
-            user_id=user_id,
-            name=name,
-            agent_id=agent_id,
-            status=SessionStatus.ACTIVE,
-            created_at=now,
-            updated_at=now,
-            last_activity=now,
-        )
-
-        return self.session_repository.create(session)
-
-    def update_session_name(
-        self, session_id: SessionId, user_id: UserId, name: str
-    ) -> Session | None:
-        session = self.session_repository.get_user_session(session_id, user_id)
-        if not session:
-            return None
-
-        session.update_name(name)
-        return self.session_repository.update(session)
-
-    def delete_session(self, session_id: SessionId, user_id: UserId) -> bool:
-        session = self.session_repository.get_user_session(session_id, user_id)
-        if not session:
-            return False
-
-        if not session.can_be_deleted_by_user(user_id):
-            return False
-
-        self.message_repository.delete_by_session_id(session_id)
-        return self.session_repository.delete(session_id, user_id)
-
-    def add_message_to_session(
-        self,
-        session_id: SessionId,
-        user_id: UserId,
-        message: str,
-        sender_type: SenderType,
-        sender_name: str,
-        agent_id: str | None = None,
-    ) -> Message | None:
-        if not user_id or user_id.strip() == "":
-            raise ValueError(f"user_id cannot be None or empty. Received: {user_id}")
-
-        session = self.session_repository.get_user_session(session_id, user_id)
-        if not session:
-            log.error(f"Session {session_id} not found for user {user_id}")
-            return None
-
-        if agent_id and not session.agent_id:
-            session.agent_id = agent_id
-            self.session_repository.update(session)
-            log.info(f"Updated session {session_id} with agent_id: {agent_id}")
-
-        message_entity = Message(
-            id=str(uuid.uuid4()),
-            session_id=session_id,
-            message=message,
-            sender_type=sender_type,
-            sender_name=sender_name,
-            message_type=MessageType.TEXT,
-            created_at=datetime.now(timezone.utc),
-        )
-
-        message_entity.validate_message_content()
-
-        session.mark_activity()
-        self.session_repository.update(session)
-
-        return self.message_repository.create(message_entity)

solace_agent_mesh/gateway/http_sse/domain/entities/__init__.py

@@ -1,3 +0,0 @@
-from .session import Message, Session, SessionHistory
-
-__all__ = ["Session", "Message", "SessionHistory"]