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

solace_agent_mesh/gateway/http_sse/routers/tasks.py

@@ -8,30 +8,28 @@ from fastapi import (
     HTTPException,
     Request as FastAPIRequest,
     status,
-    Form,
-    File,
-    UploadFile,
 )
-from pydantic import BaseModel, Field
-from typing import List
+from typing import Union
 
 from solace_ai_connector.common.log import log
 
 from ....gateway.http_sse.session_manager import SessionManager
 from ....gateway.http_sse.services.task_service import TaskService
 
-from ....common.types import (
-    JSONRPCResponse,
-    InternalError,
-    InvalidRequestError,
+from a2a.types import (
+    CancelTaskRequest,
+    SendMessageRequest,
+    SendStreamingMessageRequest,
+    SendMessageSuccessResponse,
+    SendStreamingMessageSuccessResponse,
 )
+from ....common import a2a
 
 from ....gateway.http_sse.dependencies import (
     get_session_manager,
     get_sac_component,
     get_task_service,
 )
-from ....gateway.http_sse.routers.users import get_current_user
 
 from typing import TYPE_CHECKING
 
@@ -41,29 +39,26 @@ if TYPE_CHECKING:
 router = APIRouter()
 
 
-class CancelTaskApiPayload(BaseModel):
-    """Request body for the task cancellation endpoint."""
+async def _submit_task(
+    request: FastAPIRequest,
+    payload: Union[SendMessageRequest, SendStreamingMessageRequest],
+    session_manager: SessionManager,
+    component: "WebUIBackendComponent",
+    is_streaming: bool,
+):
+    """Helper to submit a task, handling both streaming and non-streaming cases."""
+    log_prefix = f"[POST /api/v1/message:{'stream' if is_streaming else 'send'}] "
 
-    agent_name: str = Field(
-        ..., description="The name of the agent currently handling the task."
-    )
-    task_id: str = Field(..., description="The ID of the task to cancel.")
+    agent_name = None
+    if payload.params and payload.params.message and payload.params.message.metadata:
+        agent_name = payload.params.message.metadata.get("agent_name")
 
+    if not agent_name:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="Missing 'agent_name' in request payload message metadata.",
+        )
 
-@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),
-):
-    """
-    Submits a non-streaming task request to the specified agent.
-    Accepts multipart/form-data.
-    """
-    log_prefix = "[POST /api/v1/tasks/send] "
     log.info("%sReceived request for agent: %s", log_prefix, agent_name)
 
     try:
@@ -81,213 +76,246 @@ async def send_task_to_agent(
         )
 
         client_id = session_manager.get_a2a_client_id(request)
-        session_id = session_manager.ensure_a2a_session(request)
+        
+        # Use session ID from frontend request (contextId) instead of cookie-based session
+        # Handle various falsy values: None, empty string, whitespace-only string
+        log.info("%s[DEBUG] payload.params.message: %s", log_prefix, payload.params.message)
+        log.info("%s[DEBUG] hasattr context_id: %s", log_prefix, hasattr(payload.params.message, 'context_id'))
+        if hasattr(payload.params.message, 'context_id'):
+            log.info("%s[DEBUG] context_id value: %s", log_prefix, payload.params.message.context_id)
+        
+        frontend_session_id = None
+        if hasattr(payload.params.message, 'context_id') and payload.params.message.context_id:
+            context_id = payload.params.message.context_id
+            if isinstance(context_id, str) and context_id.strip():
+                frontend_session_id = context_id.strip()
+                log.info("%s[DEBUG] Extracted frontend_session_id: %s", log_prefix, frontend_session_id)
+        
+        if frontend_session_id:
+            session_id = frontend_session_id
+            log.info("%sUsing session ID from frontend request: %s", log_prefix, session_id)
+        else:
+            # Create new session when frontend doesn't provide one (None, empty, or whitespace-only)
+            session_id = session_manager.create_new_session_id(request)
+            log.info("%sNo valid session ID from frontend, created new session: %s", log_prefix, session_id)
 
         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,
+        # Store message in persistence layer if available
+        user_id = user_identity.get("id")
+        if is_streaming and hasattr(component, "persistence_service") and component.persistence_service:
+            try:
+                from ....gateway.http_sse.dependencies import get_session_service
+                from ....gateway.http_sse.shared.enums import SenderType
+                
+                session_service = get_session_service(component)
+                
+                # First ensure session exists in database - create it with the SessionManager's ID
+                # Handle race condition where multiple requests might try to create the same session
+                existing_session = session_service.get_session(session_id=session_id, user_id=user_id)
+                if not existing_session:
+                    log.info("%sCreating new session in database: %s", log_prefix, session_id)
+                    try:
+                        session_service.create_session(
+                            user_id=user_id,
+                            agent_id=agent_name,
+                            name=None,  # Will be auto-generated if needed
+                            session_id=session_id  # Use the SessionManager's session ID
+                        )
+                    except Exception as create_error:
+                        # Another request may have created the session concurrently
+                        log.warning("%sSession creation failed, checking if session exists: %s", log_prefix, create_error)
+                        existing_session = session_service.get_session(session_id=session_id, user_id=user_id)
+                        if not existing_session:
+                            # If session still doesn't exist, re-raise the original error
+                            raise create_error
+                        log.info("%sSession was created by another request: %s", log_prefix, session_id)
+                
+                # Extract text content from the message for storage
+                message_text = ""
+                if payload.params and payload.params.message:
+                    parts = a2a.get_parts_from_message(payload.params.message)
+                    for part in parts:
+                        if hasattr(part, 'text'):
+                            message_text = part.text
+                            break
+                
+                # Now store the message in the existing session
+                message_domain = session_service.add_message_to_session(
+                    session_id=session_id,
+                    user_id=user_id,
+                    message=message_text or "Task submitted",
+                    sender_type=SenderType.USER,
+                    sender_name=user_id or "user",
+                    agent_id=agent_name,
+                )
+                
+                if message_domain:
+                    log.info("%sMessage stored in session %s", log_prefix, session_id)
+                else:
+                    log.warning("%sFailed to store message in session %s", log_prefix, session_id)
+            except Exception as e:
+                log.error("%sFailed to store message in session service: %s", log_prefix, e)
+                # Don't fail the request, just log the error
+        else:
+            log.debug("%sNo persistence available or non-streaming - skipping message storage", log_prefix)
+
+        # Use the helper to get the unwrapped parts from the incoming message.
+        a2a_parts = a2a.get_parts_from_message(payload.params.message)
+
+        external_req_ctx = {
+            "app_name_for_artifacts": component.gateway_id,
+            "user_id_for_artifacts": client_id,
+            "a2a_session_id": session_id,  # This may have been updated by persistence layer
+            "user_id_for_a2a": client_id,
+            "target_agent_name": agent_name,
         }
 
-        target_agent, a2a_parts, external_req_ctx = (
-            await component._translate_external_input(external_event_data)
-        )
-
         task_id = await component.submit_a2a_task(
-            target_agent_name=target_agent,
+            target_agent_name=agent_name,
             a2a_parts=a2a_parts,
             external_request_context=external_req_ctx,
             user_identity=user_identity,
-            is_streaming=False,
+            is_streaming=is_streaming,
         )
 
         log.info("%sTask 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),
+        task_object = a2a.create_initial_task(
+            task_id=task_id,
+            context_id=session_id,
+            agent_name=agent_name,
         )
+
+        if is_streaming:
+            # The task_object already contains the contextId from create_initial_task
+            return a2a.create_send_streaming_message_success_response(
+                result=task_object, request_id=payload.id
+            )
+        else:
+            return a2a.create_send_message_success_response(
+                result=task_object, request_id=payload.id
+            )
+
     except PermissionError as pe:
         log.warning("%sPermission denied: %s", log_prefix, str(pe))
         raise HTTPException(
             status_code=status.HTTP_403_FORBIDDEN,
             detail=str(pe),
         )
-    except InternalError as e:
-        log.error(
-            "%sInternal error submitting task: %s", log_prefix, e.message, exc_info=True
-        )
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=e.model_dump(exclude_none=True),
-        )
     except Exception as e:
         log.exception("%sUnexpected error submitting task: %s", log_prefix, e)
-        error_resp = InternalError(message="Unexpected server error: %s" % 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),
         )
 
 
-@router.post("/subscribe", response_model=JSONRPCResponse)
-async def subscribe_task_from_agent(
+@router.post("/message:send", response_model=SendMessageSuccessResponse)
+async def send_task_to_agent(
     request: FastAPIRequest,
-    agent_name: str = Form(...),
-    message: str = Form(...),
-    files: List[UploadFile] = File([]),
+    payload: SendMessageRequest,
     session_manager: SessionManager = Depends(get_session_manager),
     component: "WebUIBackendComponent" = Depends(get_sac_component),
-    user: dict = Depends(get_current_user),
 ):
     """
-    Submits a streaming task request (`tasks/sendSubscribe`) to the specified agent.
-    Accepts multipart/form-data.
-    The client should subsequently connect to the SSE endpoint using the returned taskId.
+    Submits a non-streaming task request to the specified agent.
+    Accepts application/json.
     """
-    log_prefix = "[POST /api/v1/tasks/subscribe] "
-    log.info("%sReceived streaming request for agent: %s", log_prefix, agent_name)
-
-    try:
-        user_identity = await component.authenticate_and_enrich_user(request)
-        if user_identity is None:
-            log.warning("%sUser authentication failed. Denying request.", log_prefix)
-            raise HTTPException(
-                status_code=status.HTTP_401_UNAUTHORIZED,
-                detail="User authentication failed or identity not found.",
-            )
-        log.info(
-            "%sAuthenticated user identity: %s",
-            log_prefix,
-            user_identity.get("id", "unknown"),
-        )
-
-        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
-        )
+    return await _submit_task(
+        request=request,
+        payload=payload,
+        session_manager=session_manager,
+        component=component,
+        is_streaming=False,
+    )
 
-        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_req_ctx = (
-            await component._translate_external_input(external_event_data)
-        )
-
-        task_id = await component.submit_a2a_task(
-            target_agent_name=target_agent,
-            a2a_parts=a2a_parts,
-            external_request_context=external_req_ctx,
-            user_identity=user_identity,
-            is_streaming=True,
-        )
+@router.post("/message:stream", response_model=SendStreamingMessageSuccessResponse)
+async def subscribe_task_from_agent(
+    request: FastAPIRequest,
+    payload: SendStreamingMessageRequest,
+    session_manager: SessionManager = Depends(get_session_manager),
+    component: "WebUIBackendComponent" = Depends(get_sac_component),
+):
+    """
+    Submits a streaming task request to the specified agent.
+    Accepts application/json.
+    The client should subsequently connect to the SSE endpoint using the returned taskId.
+    """
+    return await _submit_task(
+        request=request,
+        payload=payload,
+        session_manager=session_manager,
+        component=component,
+        is_streaming=True,
+    )
 
-        log.info(
-            "%sStreaming task submitted successfully. TaskID: %s", log_prefix, task_id
-        )
 
-        return JSONRPCResponse(result={"taskId": task_id})
+@router.post("/tasks/{taskId}:cancel", status_code=status.HTTP_202_ACCEPTED)
+async def cancel_agent_task(
+    request: FastAPIRequest,
+    taskId: str,
+    payload: CancelTaskRequest,
+    session_manager: SessionManager = Depends(get_session_manager),
+    task_service: TaskService = Depends(get_task_service),
+    component: "WebUIBackendComponent" = Depends(get_sac_component),
+):
+    """
+    Sends a cancellation request for a specific task to the specified agent.
+    Returns 202 Accepted, as cancellation is asynchronous.
+    """
+    log_prefix = f"[POST /api/v1/tasks/{taskId}:cancel] "
+    log.info("%sReceived cancellation request.", log_prefix)
 
-    except InvalidRequestError as e:
-        log.warning("%sInvalid request: %s", log_prefix, e.message, exc_info=True)
+    if taskId != payload.params.id:
         raise HTTPException(
             status_code=status.HTTP_400_BAD_REQUEST,
-            detail=e.model_dump(exclude_none=True),
+            detail="Task ID in URL path does not match task ID in payload.",
         )
-    except PermissionError as pe:
-        log.warning("%sPermission denied: %s", log_prefix, str(pe))
+
+    context = component.task_context_manager.get_context(taskId)
+    if not context:
         raise HTTPException(
-            status_code=status.HTTP_403_FORBIDDEN,
-            detail=str(pe),
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"No active task context found for task ID: {taskId}",
         )
-    except InternalError as e:
+
+    agent_name = context.get("target_agent_name")
+    if not agent_name:
         log.error(
-            "%sInternal error submitting streaming task: %s",
+            "%sCould not determine target agent for task %s. Context is missing 'target_agent_name'.",
             log_prefix,
-            e.message,
-            exc_info=True,
-        )
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=e.model_dump(exclude_none=True),
+            taskId,
         )
-    except Exception as e:
-        log.exception("%sUnexpected error submitting streaming task: %s", log_prefix, e)
-        error_resp = InternalError(message="Unexpected server error: %s" % e)
         raise HTTPException(
             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=error_resp.model_dump(exclude_none=True),
+            detail="Could not determine target agent for the task.",
         )
 
-
-@router.post("/cancel", status_code=status.HTTP_202_ACCEPTED)
-async def cancel_agent_task(
-    request: FastAPIRequest,
-    payload: CancelTaskApiPayload,
-    session_manager: SessionManager = Depends(get_session_manager),
-    task_service: TaskService = Depends(get_task_service),
-):
-    """
-    Sends a cancellation request for a specific task to the specified agent.
-    Returns 202 Accepted, as cancellation is asynchronous.
-    """
-    log_prefix = "[POST /api/v1/tasks/cancel][Task:%s] " % payload.task_id
-    log.info(
-        "%sReceived cancellation request for agent: %s", log_prefix, payload.agent_name
-    )
+    log.info("%sTarget agent for cancellation is '%s'", log_prefix, agent_name)
 
     try:
         client_id = session_manager.get_a2a_client_id(request)
 
         log.info("%sUsing ClientID: %s", log_prefix, client_id)
 
-        await task_service.cancel_task(
-            payload.agent_name, payload.task_id, client_id, client_id
-        )
+        await task_service.cancel_task(agent_name, taskId, client_id, client_id)
 
         log.info("%sCancellation request published successfully.", log_prefix)
 
         return {"message": "Cancellation request sent"}
 
-    except InvalidRequestError as e:
-        log.warning(
-            "%sInvalid cancellation 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 InternalError as e:
-        log.error(
-            "%sInternal error sending cancellation: %s",
-            log_prefix,
-            e.message,
-            exc_info=True,
-        )
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=e.model_dump(exclude_none=True),
-        )
     except Exception as e:
         log.exception("%sUnexpected error sending cancellation: %s", log_prefix, e)
-        error_resp = InternalError(message="Unexpected server error: %s" % 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/routers/visualization.py

@@ -212,19 +212,19 @@ def _resolve_user_identity_for_authorization(
         return user_identity
 
     if not user_identity:
-        default_user_identity = component.get_config("default_user_identity")
-        if default_user_identity:
-            user_identity = default_user_identity
+        use_authorization = component.get_config("frontend_use_authorization", False)
+        if not use_authorization:
+            user_identity = "sam_dev_user"
             log.info(
-                "%s No user_identity provided, using configured default_user_identity: '%s' for visualization",
+                "%s No user_identity provided and auth is disabled, using sam_dev_user for visualization",
                 log_id_prefix,
-                user_identity,
             )
         else:
-            log.warning(
-                "%s No user_identity and no default_user_identity configured for visualization",
+            log.error(
+                "%s No user_identity provided but authorization is enabled. This should not happen.",
                 log_id_prefix,
             )
+            raise ValueError("No user identity available when authorization is required")
 
     return user_identity
 

solace_agent_mesh/gateway/http_sse/services/agent_service.py

@@ -8,7 +8,7 @@ from typing import List, Optional
 from solace_ai_connector.common.log import log
 
 from ....common.agent_registry import AgentRegistry
-from ....common.types import AgentCard
+from a2a.types import AgentCard
 
 
 class AgentService: