solace-agent-mesh 1.11.2__py3-none-any.whl

solace_agent_mesh/gateway/http_sse/services/task_service.py

@@ -0,0 +1,119 @@
+"""
+Service layer for handling A2A task submissions and cancellations.
+Uses CoreA2AService for logic and a provided function for publishing.
+"""
+
+import logging
+import threading
+from typing import Callable, Dict, Optional
+
+from ....common import a2a
+from ....gateway.http_sse.sse_manager import SSEManager
+from ....core_a2a.service import CoreA2AService
+
+log = logging.getLogger(__name__)
+
+PublishFunc = Callable[[str, Dict, Optional[Dict]], None]
+
+
+class TaskService:
+    """
+    Handles the logic for submitting and cancelling tasks to A2A agents.
+    Delegates A2A message construction to CoreA2AService and publishing
+    to an injected function.
+    """
+
+    def __init__(
+        self,
+        core_a2a_service: CoreA2AService,
+        publish_func: PublishFunc,
+        namespace: str,
+        gateway_id: str,
+        sse_manager: SSEManager,
+        task_context_map: Dict[str, Dict],
+        task_context_lock: threading.Lock,
+        app_name: str,
+    ):
+        """
+        Initializes the TaskService.
+
+        Args:
+            core_a2a_service: An instance of the CoreA2AService.
+            publish_func: A callable function (provided by WebUIBackendComponent)
+                          to publish messages to the A2A messaging layer.
+                          Expected signature: publish_func(topic: str, payload: Dict, user_properties: Optional[Dict])
+            namespace: The namespace string.
+            gateway_id: The unique ID of this gateway instance.
+            sse_manager: An instance of the SSEManager.
+            task_context_map: Shared dictionary to store task context.
+            task_context_lock: Lock for accessing the task context map.
+            app_name: The name of the SAC application (used for artifact context).
+        """
+        if not isinstance(core_a2a_service, CoreA2AService):
+            raise TypeError("core_a2a_service must be an instance of CoreA2AService")
+        if not callable(publish_func):
+            raise TypeError("publish_func must be a callable function")
+        if not isinstance(sse_manager, SSEManager):
+            raise TypeError("sse_manager must be an instance of SSEManager")
+
+        self.core_a2a_service = core_a2a_service
+        self._publish_func = publish_func
+        self._namespace = namespace
+        self._gateway_id = gateway_id
+        self._sse_manager = sse_manager
+        self._task_context_map = task_context_map
+        self._task_context_lock = task_context_lock
+        self._app_name = app_name
+        log.info(
+            "[TaskService] Initialized with Gateway ID: %s, App Name: %s",
+            self._gateway_id,
+            self._app_name,
+        )
+
+    async def cancel_task(
+        self,
+        agent_name: str,
+        task_id: str,
+        client_id: str,
+        user_id: str = "web_user",
+    ):
+        """
+        Constructs and publishes an A2A CancelTaskRequest using CoreA2AService.
+
+        Args:
+            agent_name: The name of the agent that owns the task.
+            task_id: The ID of the task to cancel.
+            client_id: The ID of the client requesting cancellation (frontend).
+            user_id: An identifier for the user (optional).
+
+        Raises:
+            Exception: If constructing or publishing the message fails.
+        """
+        log_prefix = "[TaskService][Task:%s] " % task_id
+        log.info(
+            "%sRequesting cancellation for task owned by agent '%s'",
+            log_prefix,
+            agent_name,
+        )
+
+        try:
+            target_topic, payload, user_properties = self.core_a2a_service.cancel_task(
+                agent_name=agent_name,
+                task_id=task_id,
+                client_id=client_id,
+                user_id=user_id,
+            )
+
+            log.debug(
+                "%sPublishing CancelTaskRequest to topic: %s", log_prefix, target_topic
+            )
+            self._publish_func(
+                topic=target_topic, payload=payload, user_properties=user_properties
+            )
+            log.info("%sSuccessfully published task cancellation request.", log_prefix)
+
+        except Exception as e:
+            log.exception("%sFailed to publish cancellation request: %s", log_prefix, e)
+            raise a2a.create_internal_error(
+                message="Failed to publish cancellation request: %s" % e
+            ) from e

solace_agent_mesh/gateway/http_sse/session_manager.py

@@ -0,0 +1,219 @@
+"""
+Manages web user sessions and mapping to A2A Client IDs.
+"""
+
+import logging
+import uuid
+from collections.abc import Callable
+from typing import Any
+
+from starlette.requests import Request
+
+log = logging.getLogger(__name__)
+
+SESSION_KEY_CLIENT_ID = "a2a_client_id"
+SESSION_KEY_SESSION_ID = "a2a_session_id"
+SESSION_KEY_ACCESS_TOKEN = "access_token"
+SESSION_KEY_REFRESH_TOKEN = "refresh_token"
+SESSION_KEY_USER_ID = "user_id"
+
+
+class SessionManager:
+    """
+    Handles web user sessions using Starlette's SessionMiddleware.
+    Generates and stores unique A2A Client IDs and manages the current A2A Session ID per web session.
+    """
+
+    def __init__(
+        self,
+        secret_key: str,
+        app_config: dict[str, Any],
+    ):
+        if not secret_key:
+            raise ValueError("Session secret key cannot be empty.")
+        self.secret_key = secret_key
+        self.force_user_identity = app_config.get("force_user_identity")
+        self.use_authorization = app_config.get("frontend_use_authorization", False)
+        self._temp_code_cache = {}
+        log.info("Initialized SessionManager")
+        if self.force_user_identity:
+            log.warning(
+                f"Forcing user identity to: {self.force_user_identity}"
+            )
+
+    def _get_or_create_client_id(self, request: Request) -> str | None:
+        """
+        Retrieves the A2A Client ID. It prioritizes the authenticated user from
+        `request.state.user` and falls back to session-based or generated IDs.
+        If authorization is enabled, it returns None if no user can be identified.
+        """
+        if self.force_user_identity:
+            return self.force_user_identity
+
+        if hasattr(request.state, "user") and request.state.user:
+            user_id = request.state.user.get("id")
+            if user_id:
+                log.debug(
+                    "Using authenticated user ID from request.state: %s",
+                    user_id,
+                )
+                return user_id
+            else:
+                log.warning(
+                    "request.state.user exists but has no 'id' field. Falling back to other methods."
+                )
+
+        user_id = self.get_user_id(request)
+        if user_id:
+            log.debug(
+                "Using authenticated user_id from session as A2A Client ID: %s",
+                user_id,
+            )
+            return user_id
+
+        client_id = request.session.get(SESSION_KEY_CLIENT_ID)
+        if client_id:
+            log.debug(
+                "Using existing A2A Client ID: %s for web session.",
+                client_id,
+            )
+            return client_id
+
+        if not self.use_authorization:
+            client_id = "sam_dev_user"
+            log.info(
+                "No authenticated user and auth is disabled, using client ID: %s for web session.",
+                client_id,
+            )
+            request.session[SESSION_KEY_CLIENT_ID] = client_id
+            return client_id
+
+        log.warning(
+            "Could not determine client ID and authorization is enabled."
+        )
+        return None
+
+    def get_a2a_client_id(self, request: Request) -> str | None:
+        """
+        FastAPI dependency callable to get the A2A Client ID for the current request.
+        Ensures a client ID exists in the session if auth is disabled.
+        """
+        return self._get_or_create_client_id(request)
+
+    def get_a2a_session_id(self, request: Request) -> str | None:
+        """
+        FastAPI dependency callable to get the current A2A Session ID for the current request.
+        Returns None if no session has been started for the current agent in this web session.
+        """
+        session_id = request.session.get(SESSION_KEY_SESSION_ID)
+        log.debug("Retrieving A2A Session ID: %s", session_id)
+        return session_id
+
+    def start_new_a2a_session(self, request: Request) -> str:
+        """
+        Generates a new A2A Session ID, stores it in the web session, and returns it.
+        This should be called when the user explicitly starts a new chat or switches agents.
+        """
+        client_id = self._get_or_create_client_id(request)
+        if not client_id:
+            # This case should ideally be prevented by middleware raising 401
+            raise RuntimeError(
+                "Cannot start a new A2A session without a client ID when authorization is enabled."
+            )
+        new_session_id = f"web-session-{uuid.uuid4().hex}"
+        request.session[SESSION_KEY_SESSION_ID] = new_session_id
+        log.info(
+            "Started new A2A Session ID: %s for Client ID: %s",
+            new_session_id,
+            client_id,
+        )
+        return new_session_id
+
+    def create_new_session_id(self, request: Request) -> str:
+        """
+        Generates a new A2A Session ID without storing it in cookies.
+        This should be used when the frontend manages session state.
+        """
+        client_id = self._get_or_create_client_id(request)
+        if not client_id:
+            # This case should ideally be prevented by middleware raising 401
+            raise RuntimeError(
+                "Cannot start a new A2A session without a client ID when authorization is enabled."
+            )
+        new_session_id = f"web-session-{uuid.uuid4().hex}"
+        log.info(
+            "Generated new A2A Session ID: %s for Client ID: %s (not stored in cookies)",
+            new_session_id,
+            client_id,
+        )
+        return new_session_id
+
+    def ensure_a2a_session(self, request: Request) -> str:
+        """
+        Ensures an A2A session ID exists, creating one if necessary.
+        Use this when an operation requires a session ID but one might not have been explicitly started yet.
+        """
+        session_id = self.get_a2a_session_id(request)
+        if not session_id:
+            session_id = self.start_new_a2a_session(request)
+            log.info(
+                "No A2A Session ID found, created new one via ensure_a2a_session: %s",
+                session_id,
+            )
+        return session_id
+
+    def store_auth_tokens(
+        self, request: Request, access_token: str, refresh_token: str | None = None
+    ):
+        """
+        Stores authentication tokens directly in the user's session.
+        """
+        request.session[SESSION_KEY_ACCESS_TOKEN] = access_token
+        if refresh_token:
+            request.session[SESSION_KEY_REFRESH_TOKEN] = refresh_token
+        log.info("Stored auth tokens directly in session.")
+
+    def get_access_token(self, request: Request) -> str | None:
+        """
+        Retrieves the access token from the web session.
+        """
+        return request.session.get(SESSION_KEY_ACCESS_TOKEN)
+
+    def get_refresh_token(self, request: Request) -> str | None:
+        """
+        Retrieves the refresh token from the web session.
+        """
+        return request.session.get(SESSION_KEY_REFRESH_TOKEN)
+
+    def clear_auth_tokens(self, request: Request) -> None:
+        """
+        Clears authentication tokens from the web session.
+        """
+        request.session.pop(SESSION_KEY_ACCESS_TOKEN, None)
+        request.session.pop(SESSION_KEY_REFRESH_TOKEN, None)
+        log.info("Cleared auth tokens from session")
+
+    def store_user_id(self, request: Request, user_id: str) -> None:
+        """
+        Stores the user ID in the web session.
+        """
+        request.session[SESSION_KEY_USER_ID] = user_id
+        log.info("Stored user ID in session: %s", user_id)
+
+    def get_user_id(self, request: Request) -> str | None:
+        """
+        Retrieves the user ID from the web session.
+        """
+        return request.session.get(SESSION_KEY_USER_ID)
+
+    def dep_get_client_id(self) -> Callable[[Request], str | None]:
+        """Returns a callable suitable for FastAPI Depends to get the client ID."""
+        return self.get_a2a_client_id
+
+    def dep_get_session_id(self) -> Callable[[Request], str | None]:
+        """Returns a callable suitable for FastAPI Depends to get the current session ID."""
+        return self.get_a2a_session_id
+
+    def dep_ensure_session_id(self) -> Callable[[Request], str]:
+        """Returns a callable suitable for FastAPI Depends to ensure a session ID exists."""
+        return self.ensure_a2a_session

solace_agent_mesh/gateway/http_sse/shared/__init__.py

@@ -0,0 +1,146 @@
+"""
+Shared Utilities and Constants
+
+Contains common utilities, constants, enums, types, and exception handling
+used across layers.
+"""
+
+from .auth_utils import get_current_user
+from .timestamp_utils import (
+    datetime_to_epoch_ms,
+    epoch_ms_to_datetime,
+    epoch_ms_to_iso8601,
+    iso8601_to_epoch_ms,
+    now_epoch_ms,
+    validate_epoch_ms,
+)
+
+# Exception handling exports
+from .exceptions import (
+    WebUIBackendException,
+    ValidationError,
+    EntityNotFoundError,
+    EntityAlreadyExistsError,
+    BusinessRuleViolationError,
+    ConfigurationError,
+    DataIntegrityError,
+    ExternalServiceError,
+    EntityOperation,
+    ValidationErrorBuilder,
+)
+from .error_dto import EventErrorDTO
+from .exception_handlers import (
+    register_exception_handlers,
+    create_error_response,
+    validation_error_handler,
+    entity_not_found_handler,
+    entity_already_exists_handler,
+    business_rule_violation_handler,
+    configuration_error_handler,
+    data_integrity_error_handler,
+    external_service_error_handler,
+    webui_backend_exception_handler,
+)
+
+# Repository base classes
+from .base_repository import (
+    BaseRepository,
+    PaginatedRepository,
+    ValidationMixin,
+)
+
+# Pagination utilities
+from .pagination import (
+    PaginationParams,
+    PaginatedResponse,
+    DataResponse,
+)
+
+# Database utilities
+from .database_exceptions import (
+    DatabaseExceptionHandler,
+    DatabaseErrorDecorator,
+    handle_database_errors,
+)
+# Database helpers (SimpleJSON type only - transaction management removed)
+from .database_helpers import SimpleJSON
+
+# Generic utilities
+from .utils import generate_uuid, to_snake_case, to_pascal_case
+
+# Response utilities
+from .response_utils import (
+    create_data_response,
+    create_paginated_response,
+    create_empty_data_response,
+    create_success_response,
+    create_list_response,
+    StandardResponseMixin,
+)
+
+__all__ = [
+    # Utilities
+    "get_current_user",
+    "now_epoch_ms",
+    "epoch_ms_to_iso8601",
+    "iso8601_to_epoch_ms",
+    "datetime_to_epoch_ms",
+    "epoch_ms_to_datetime",
+    "validate_epoch_ms",
+
+    # Exception classes
+    "WebUIBackendException",
+    "ValidationError",
+    "EntityNotFoundError",
+    "EntityAlreadyExistsError",
+    "BusinessRuleViolationError",
+    "ConfigurationError",
+    "DataIntegrityError",
+    "ExternalServiceError",
+    "EntityOperation",
+    "ValidationErrorBuilder",
+
+    # Error response DTO
+    "EventErrorDTO",
+
+    # Exception handlers
+    "register_exception_handlers",
+    "create_error_response",
+    "validation_error_handler",
+    "entity_not_found_handler",
+    "entity_already_exists_handler",
+    "business_rule_violation_handler",
+    "configuration_error_handler",
+    "data_integrity_error_handler",
+    "external_service_error_handler",
+    "webui_backend_exception_handler",
+
+    # Repository base classes
+    "BaseRepository",
+    "PaginatedRepository",
+    "ValidationMixin",
+
+    # Pagination utilities
+    "PaginationParams",
+    "PaginatedResponse",
+    "DataResponse",
+
+    # Database utilities
+    "DatabaseExceptionHandler",
+    "DatabaseErrorDecorator",
+    "handle_database_errors",
+    # Database transaction functions removed - use FastAPI dependency injection
+
+    # Generic utilities
+    "generate_uuid",
+    "to_snake_case",
+    "to_pascal_case",
+
+    # Response utilities
+    "create_data_response",
+    "create_paginated_response",
+    "create_empty_data_response",
+    "create_success_response",
+    "create_list_response",
+    "StandardResponseMixin",
+]

solace_agent_mesh/gateway/http_sse/shared/auth_utils.py

@@ -0,0 +1,29 @@
+"""
+Authentication utilities for the FastAPI application.
+
+This module provides common authentication functions used across controllers.
+"""
+
+from fastapi import Depends, Request as FastAPIRequest
+
+
+async def get_current_user(request: FastAPIRequest) -> dict:
+    """
+    Extracts the current user from the request state.
+    
+    This function is used as a FastAPI dependency to get the authenticated user
+    information that was set by the AuthMiddleware.
+    
+    Args:
+        request: The FastAPI request object with user state
+        
+    Returns:
+        dict: User information dictionary containing id, name, email, etc.
+    """
+    return getattr(request.state, "user", {
+        "id": "anonymous",
+        "name": "Anonymous User",
+        "email": "anonymous@localhost",
+        "authenticated": False,
+        "auth_method": "none"
+    })