solace-agent-mesh 1.4.12__py3-none-any.whl → 1.5.1__py3-none-any.whl

solace_agent_mesh/gateway/http_sse/main.py

@@ -1,3 +1,4 @@
+import logging
 import os
 from pathlib import Path
 from typing import TYPE_CHECKING
@@ -14,7 +15,6 @@ from fastapi import status
 from fastapi.exceptions import RequestValidationError
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import JSONResponse
-from solace_ai_connector.common.log import log
 from starlette.middleware.sessions import SessionMiddleware
 from starlette.staticfiles import StaticFiles
 
@@ -29,6 +29,7 @@ from ...gateway.http_sse.routers import (
     sse,
     tasks,
     visualization,
+    feedback,
 )
 from .routers.sessions import router as session_router
 from .routers.tasks import router as task_router
@@ -37,12 +38,17 @@ from .routers.users import router as user_router
 if TYPE_CHECKING:
     from gateway.http_sse.component import WebUIBackendComponent
 
+log = logging.getLogger(__name__)
+
 app = FastAPI(
     title="A2A Web UI Backend",
     version="1.0.0",  # Updated to reflect simplified architecture
     description="Backend API and SSE server for the A2A Web UI, hosted by Solace AI Connector.",
 )
 
+# Global flag to track if dependencies have been initialized
+_dependencies_initialized = False
+
 
 def _extract_access_token(request: FastAPIRequest) -> str:
     auth_header = request.headers.get("Authorization")
@@ -62,7 +68,9 @@ def _extract_access_token(request: FastAPIRequest) -> str:
     return None
 
 
-async def _validate_token(auth_service_url: str, auth_provider: str, access_token: str) -> bool:
+async def _validate_token(
+    auth_service_url: str, auth_provider: str, access_token: str
+) -> bool:
     async with httpx.AsyncClient() as client:
         validation_response = await client.post(
             f"{auth_service_url}/is_token_valid",
@@ -72,7 +80,9 @@ async def _validate_token(auth_service_url: str, auth_provider: str, access_toke
     return validation_response.status_code == 200
 
 
-async def _get_user_info(auth_service_url: str, auth_provider: str, access_token: str) -> dict:
+async def _get_user_info(
+    auth_service_url: str, auth_provider: str, access_token: str
+) -> dict:
     async with httpx.AsyncClient() as client:
         userinfo_response = await client.get(
             f"{auth_service_url}/user_info?provider={auth_provider}",
@@ -100,7 +110,9 @@ def _extract_user_identifier(user_info: dict) -> str:
     )
 
     if user_identifier and user_identifier.lower() == "unknown":
-        log.warning("AuthMiddleware: IDP returned 'Unknown' as user identifier. Using fallback.")
+        log.warning(
+            "AuthMiddleware: IDP returned 'Unknown' as user identifier. Using fallback."
+        )
         return "sam_dev_user"
 
     return user_identifier
@@ -124,7 +136,9 @@ def _extract_user_details(user_info: dict, user_identifier: str) -> tuple:
     return email_from_auth, display_name
 
 
-async def _create_user_state_without_identity_service(user_identifier: str, email_from_auth: str, display_name: str) -> dict:
+async def _create_user_state_without_identity_service(
+    user_identifier: str, email_from_auth: str, display_name: str
+) -> dict:
     final_user_id = user_identifier or email_from_auth or "sam_dev_user"
     if not final_user_id or final_user_id.lower() in ["unknown", "null", "none", ""]:
         final_user_id = "sam_dev_user"
@@ -146,7 +160,13 @@ async def _create_user_state_without_identity_service(user_identifier: str, emai
     }
 
 
-async def _create_user_state_with_identity_service(identity_service, user_identifier: str, email_from_auth: str, display_name: str, user_info: dict) -> dict:
+async def _create_user_state_with_identity_service(
+    identity_service,
+    user_identifier: str,
+    email_from_auth: str,
+    display_name: str,
+    user_info: dict,
+) -> dict:
     lookup_value = email_from_auth if "@" in email_from_auth else user_identifier
     user_profile = await identity_service.get_user_profile(
         {identity_service.lookup_key: lookup_value, "user_info": user_info}
@@ -186,24 +206,35 @@ def _create_auth_middleware(component):
                 return
 
             skip_paths = [
-                "/api/v1/config", "/api/v1/auth/callback", "/api/v1/auth/login",
-                "/api/v1/auth/refresh", "/api/v1/csrf-token", "/health",
+                "/api/v1/config",
+                "/api/v1/auth/callback",
+                "/api/v1/auth/login",
+                "/api/v1/auth/refresh",
+                "/api/v1/csrf-token",
+                "/health",
             ]
 
             if any(request.url.path.startswith(path) for path in skip_paths):
                 await self.app(scope, receive, send)
                 return
 
-            use_auth = dependencies.api_config and dependencies.api_config.get("frontend_use_authorization")
+            use_auth = dependencies.api_config and dependencies.api_config.get(
+                "frontend_use_authorization"
+            )
 
             if use_auth:
                 await self._handle_authenticated_request(request, scope, receive, send)
             else:
                 request.state.user = {
-                    "id": "sam_dev_user", "name": "Sam Dev User", "email": "sam@dev.local",
-                    "authenticated": True, "auth_method": "development",
+                    "id": "sam_dev_user",
+                    "name": "Sam Dev User",
+                    "email": "sam@dev.local",
+                    "authenticated": True,
+                    "auth_method": "development",
                 }
-                log.debug("AuthMiddleware: Set development user state with id: sam_dev_user")
+                log.debug(
+                    "AuthMiddleware: Set development user state with id: sam_dev_user"
+                )
 
             await self.app(scope, receive, send)
 
@@ -214,13 +245,18 @@ def _create_auth_middleware(component):
                 log.warning("AuthMiddleware: No access token found. Returning 401.")
                 response = JSONResponse(
                     status_code=status.HTTP_401_UNAUTHORIZED,
-                    content={"detail": "Not authenticated", "error_type": "authentication_required"},
+                    content={
+                        "detail": "Not authenticated",
+                        "error_type": "authentication_required",
+                    },
                 )
                 await response(scope, receive, send)
                 return
 
             try:
-                auth_service_url = dependencies.api_config.get("external_auth_service_url")
+                auth_service_url = dependencies.api_config.get(
+                    "external_auth_service_url"
+                )
                 auth_provider = dependencies.api_config.get("external_auth_provider")
 
                 if not auth_service_url:
@@ -232,47 +268,85 @@ def _create_auth_middleware(component):
                     await response(scope, receive, send)
                     return
 
-                if not await _validate_token(auth_service_url, auth_provider, access_token):
+                if not await _validate_token(
+                    auth_service_url, auth_provider, access_token
+                ):
                     log.warning("AuthMiddleware: Token validation failed")
                     response = JSONResponse(
                         status_code=status.HTTP_401_UNAUTHORIZED,
-                        content={"detail": "Invalid token", "error_type": "invalid_token"},
+                        content={
+                            "detail": "Invalid token",
+                            "error_type": "invalid_token",
+                        },
                     )
                     await response(scope, receive, send)
                     return
 
-                user_info = await _get_user_info(auth_service_url, auth_provider, access_token)
+                user_info = await _get_user_info(
+                    auth_service_url, auth_provider, access_token
+                )
                 if not user_info:
-                    log.warning("AuthMiddleware: Failed to get user info from external auth service")
+                    log.warning(
+                        "AuthMiddleware: Failed to get user info from external auth service"
+                    )
                     response = JSONResponse(
                         status_code=status.HTTP_401_UNAUTHORIZED,
-                        content={"detail": "Could not retrieve user info from auth provider", "error_type": "user_info_failed"},
+                        content={
+                            "detail": "Could not retrieve user info from auth provider",
+                            "error_type": "user_info_failed",
+                        },
                     )
                     await response(scope, receive, send)
                     return
 
                 user_identifier = _extract_user_identifier(user_info)
-                if not user_identifier or user_identifier.lower() in ["null", "none", ""]:
-                    log.error("AuthMiddleware: No valid user identifier from OAuth provider")
+                if not user_identifier or user_identifier.lower() in [
+                    "null",
+                    "none",
+                    "",
+                ]:
+                    log.error(
+                        "AuthMiddleware: No valid user identifier from OAuth provider"
+                    )
                     response = JSONResponse(
                         status_code=status.HTTP_401_UNAUTHORIZED,
-                        content={"detail": "OAuth provider returned no valid user identifier", "error_type": "invalid_user_identifier_from_provider"},
+                        content={
+                            "detail": "OAuth provider returned no valid user identifier",
+                            "error_type": "invalid_user_identifier_from_provider",
+                        },
                     )
                     await response(scope, receive, send)
                     return
 
-                email_from_auth, display_name = _extract_user_details(user_info, user_identifier)
+                email_from_auth, display_name = _extract_user_details(
+                    user_info, user_identifier
+                )
 
                 identity_service = self.component.identity_service
                 if not identity_service:
-                    request.state.user = await _create_user_state_without_identity_service(user_identifier, email_from_auth, display_name)
+                    request.state.user = (
+                        await _create_user_state_without_identity_service(
+                            user_identifier, email_from_auth, display_name
+                        )
+                    )
                 else:
-                    user_state = await _create_user_state_with_identity_service(identity_service, user_identifier, email_from_auth, display_name, user_info)
+                    user_state = await _create_user_state_with_identity_service(
+                        identity_service,
+                        user_identifier,
+                        email_from_auth,
+                        display_name,
+                        user_info,
+                    )
                     if not user_state:
-                        log.error("AuthMiddleware: User authenticated but not found in internal IdentityService")
+                        log.error(
+                            "AuthMiddleware: User authenticated but not found in internal IdentityService"
+                        )
                         response = JSONResponse(
                             status_code=status.HTTP_403_FORBIDDEN,
-                            content={"detail": "User not authorized for this application", "error_type": "not_authorized"},
+                            content={
+                                "detail": "User not authorized for this application",
+                                "error_type": "not_authorized",
+                            },
                         )
                         await response(scope, receive, send)
                         return
@@ -287,10 +361,14 @@ def _create_auth_middleware(component):
                 await response(scope, receive, send)
                 return
             except Exception as exc:
-                log.error("An unexpected error occurred during token validation: %s", exc)
+                log.error(
+                    "An unexpected error occurred during token validation: %s", exc
+                )
                 response = JSONResponse(
                     status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-                    content={"detail": "An internal error occurred during authentication"},
+                    content={
+                        "detail": "An internal error occurred during authentication"
+                    },
                 )
                 await response(scope, receive, send)
                 return
@@ -343,10 +421,14 @@ def _run_community_migrations(database_url: str) -> None:
         except Exception as migration_error:
             log.error("Community migration failed: %s", migration_error)
             log.error("Check database connectivity and permissions")
-            raise RuntimeError(f"Community database migration failed: {migration_error}") from migration_error
+            raise RuntimeError(
+                f"Community database migration failed: {migration_error}"
+            ) from migration_error
 
 
-def _run_enterprise_migrations(component: "WebUIBackendComponent", database_url: str) -> None:
+def _run_enterprise_migrations(
+    component: "WebUIBackendComponent", database_url: str
+) -> None:
     """
     Run migrations for enterprise features like advanced analytics, audit logs, etc.
     This is optional and only runs if the enterprise package is available.
@@ -420,7 +502,15 @@ def setup_dependencies(component: "WebUIBackendComponent", database_url: str = N
     backward compatibility with existing API contracts.
 
     If database_url is None, runs in compatibility mode with in-memory sessions.
+
+    This function is idempotent and safe to call multiple times.
     """
+    global _dependencies_initialized
+
+    if _dependencies_initialized:
+        log.debug("[setup_dependencies] Dependencies already initialized, skipping")
+        return
+
     dependencies.set_component_instance(component)
 
     if database_url:
@@ -441,6 +531,9 @@ def setup_dependencies(component: "WebUIBackendComponent", database_url: str = N
     _setup_routers()
     _setup_static_files()
 
+    _dependencies_initialized = True
+    log.info("[setup_dependencies] Dependencies initialization complete")
+
 
 def _setup_middleware(component: "WebUIBackendComponent") -> None:
     allowed_origins = component.get_cors_origins()
@@ -467,39 +560,50 @@ def _setup_routers() -> None:
 
     app.include_router(session_router, prefix=api_prefix, tags=["Sessions"])
     app.include_router(user_router, prefix=f"{api_prefix}/users", tags=["Users"])
-    app.include_router(task_router, prefix=f"{api_prefix}/tasks", tags=["Tasks"])
     app.include_router(config.router, prefix=api_prefix, tags=["Config"])
     app.include_router(agent_cards.router, prefix=api_prefix, tags=["Agent Cards"])
-    app.include_router(tasks.router, prefix=api_prefix, tags=["A2A Messages"])
+    app.include_router(tasks.router, prefix=api_prefix, tags=["Tasks"])
     app.include_router(sse.router, prefix=f"{api_prefix}/sse", tags=["SSE"])
-    app.include_router(artifacts.router, prefix=f"{api_prefix}/artifacts", tags=["Artifacts"])
-    app.include_router(visualization.router, prefix=f"{api_prefix}/visualization", tags=["Visualization"])
+    app.include_router(
+        artifacts.router, prefix=f"{api_prefix}/artifacts", tags=["Artifacts"]
+    )
+    app.include_router(
+        visualization.router,
+        prefix=f"{api_prefix}/visualization",
+        tags=["Visualization"],
+    )
     app.include_router(people.router, prefix=api_prefix, tags=["People"])
     app.include_router(auth.router, prefix=api_prefix, tags=["Auth"])
+    app.include_router(feedback.router, prefix=api_prefix, tags=["Feedback"])
     log.info("Legacy routers mounted for endpoints not yet migrated")
 
     # Register shared exception handlers from community repo
     from .shared.exception_handlers import register_exception_handlers
+
     register_exception_handlers(app)
     log.info("Registered shared exception handlers from community repo")
 
     # Mount enterprise routers if available
     try:
-        from solace_agent_mesh_enterprise.webui_backend.routers import get_enterprise_routers
+        from solace_agent_mesh_enterprise.webui_backend.routers import (
+            get_enterprise_routers,
+        )
 
         enterprise_routers = get_enterprise_routers()
         for router_config in enterprise_routers:
             app.include_router(
                 router_config["router"],
                 prefix=router_config["prefix"],
-                tags=router_config["tags"]
+                tags=router_config["tags"],
             )
         log.info("Mounted %d enterprise routers", len(enterprise_routers))
 
     except ImportError:
         log.debug("No enterprise package detected - skipping enterprise routers")
     except ModuleNotFoundError:
-        log.debug("Enterprise module not found - skipping enterprise routers and exception handlers")
+        log.debug(
+            "Enterprise module not found - skipping enterprise routers and exception handlers"
+        )
     except Exception as e:
         log.warning("Failed to load enterprise routers and exception handlers: %s", e)
 
@@ -535,7 +639,7 @@ async def http_exception_handler(request: FastAPIRequest, exc: HTTPException):
     Returns JSON-RPC format for tasks/SSE endpoints, REST format for others.
     """
     log.warning(
-        "HTTP Exception: Status=%s, Detail=%s, Request: %s %s",
+        "HTTP Exception Handler triggered: Status=%s, Detail=%s, Request: %s %s",
         exc.status_code,
         exc.detail,
         request.method,
@@ -594,7 +698,7 @@ async def validation_exception_handler(
     Handles Pydantic validation errors with format detection.
     """
     log.warning(
-        "Request Validation Error: %s, Request: %s %s",
+        "Validation Exception Handler triggered: %s, Request: %s %s",
         exc.errors(),
         request.method,
         request.url,
@@ -603,7 +707,7 @@ async def validation_exception_handler(
         message="Invalid request parameters", data=exc.errors(), request_id=None
     )
     return JSONResponse(
-        status_code=status.HTTP_400_BAD_REQUEST,
+        status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
         content=response.model_dump(exclude_none=True),
     )
 
@@ -614,7 +718,10 @@ async def generic_exception_handler(request: FastAPIRequest, exc: Exception):
     Handles any other unexpected exceptions with format detection.
     """
     log.exception(
-        "Unhandled Exception: %s, Request: %s %s", exc, request.method, request.url
+        "Generic Exception Handler triggered: %s, Request: %s %s",
+        exc,
+        request.method,
+        request.url,
     )
     error_obj = a2a.create_internal_error(
         message="An unexpected server error occurred: %s" % type(exc).__name__

solace_agent_mesh/gateway/http_sse/repository/__init__.py

@@ -3,35 +3,26 @@ Repository layer containing all data access logic organized by entity type.
 """
 
 # Interfaces
-from .interfaces import IMessageRepository, ISessionRepository
+from .interfaces import ISessionRepository
 
 # Implementations
-from .message_repository import MessageRepository
 from .session_repository import SessionRepository
 
 # Entities (re-exported for convenience)
 from .entities.session import Session
-from .entities.message import Message
-from .entities.session_history import SessionHistory
 
 # Models (re-exported for convenience)
 from .models.base import Base
 from .models.session_model import SessionModel
-from .models.message_model import MessageModel
 
 __all__ = [
     # Interfaces
-    "IMessageRepository",
     "ISessionRepository",
     # Implementations
-    "MessageRepository", 
     "SessionRepository",
     # Entities
-    "Message",
-    "Session", 
-    "SessionHistory",
+    "Session",
     # Models
     "Base",
-    "MessageModel",
     "SessionModel",
-]
+]

solace_agent_mesh/gateway/http_sse/repository/chat_task_repository.py

@@ -0,0 +1,103 @@
+"""
+ChatTask repository implementation using SQLAlchemy.
+"""
+
+from typing import List, Optional
+
+from sqlalchemy.orm import Session as DBSession
+
+from ..shared import now_epoch_ms
+from ..shared.types import SessionId, UserId
+from .entities import ChatTask
+from .interfaces import IChatTaskRepository
+from .models import ChatTaskModel
+
+
+class ChatTaskRepository(IChatTaskRepository):
+    """SQLAlchemy implementation of chat task repository."""
+
+    def __init__(self, db: DBSession):
+        self.db = db
+
+    def save(self, task: ChatTask) -> ChatTask:
+        """Save or update a chat task (upsert)."""
+        existing = self.db.query(ChatTaskModel).filter(
+            ChatTaskModel.id == task.id
+        ).first()
+
+        if existing:
+            # Update existing task - store strings directly
+            existing.user_message = task.user_message
+            existing.message_bubbles = task.message_bubbles  # Already a string
+            existing.task_metadata = task.task_metadata      # Already a string
+            existing.updated_time = now_epoch_ms()
+        else:
+            # Create new task - store strings directly
+            model = ChatTaskModel(
+                id=task.id,
+                session_id=task.session_id,
+                user_id=task.user_id,
+                user_message=task.user_message,
+                message_bubbles=task.message_bubbles,  # Already a string
+                task_metadata=task.task_metadata,      # Already a string
+                created_time=task.created_time,
+                updated_time=task.updated_time
+            )
+            self.db.add(model)
+
+        self.db.commit()
+
+        # Reload to get updated values
+        model = self.db.query(ChatTaskModel).filter(
+            ChatTaskModel.id == task.id
+        ).first()
+
+        return self._model_to_entity(model)
+
+    def find_by_session(
+        self,
+        session_id: SessionId,
+        user_id: UserId
+    ) -> List[ChatTask]:
+        """Find all tasks for a session."""
+        models = self.db.query(ChatTaskModel).filter(
+            ChatTaskModel.session_id == session_id,
+            ChatTaskModel.user_id == user_id
+        ).order_by(ChatTaskModel.created_time.asc()).all()
+
+        return [self._model_to_entity(m) for m in models]
+
+    def find_by_id(
+        self,
+        task_id: str,
+        user_id: UserId
+    ) -> Optional[ChatTask]:
+        """Find a specific task."""
+        model = self.db.query(ChatTaskModel).filter(
+            ChatTaskModel.id == task_id,
+            ChatTaskModel.user_id == user_id
+        ).first()
+
+        return self._model_to_entity(model) if model else None
+
+    def delete_by_session(self, session_id: SessionId) -> bool:
+        """Delete all tasks for a session."""
+        result = self.db.query(ChatTaskModel).filter(
+            ChatTaskModel.session_id == session_id
+        ).delete()
+        self.db.commit()
+        return result > 0
+
+    def _model_to_entity(self, model: ChatTaskModel) -> ChatTask:
+        """Convert SQLAlchemy model to domain entity."""
+        # No deserialization - just pass strings through
+        return ChatTask(
+            id=model.id,
+            session_id=model.session_id,
+            user_id=model.user_id,
+            user_message=model.user_message,
+            message_bubbles=model.message_bubbles,  # String (opaque)
+            task_metadata=model.task_metadata,      # String (opaque)
+            created_time=model.created_time,
+            updated_time=model.updated_time
+        )

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

@@ -2,8 +2,10 @@
 Domain entities for the repository layer.
 """
 
-from .message import Message
+from .chat_task import ChatTask
+from .feedback import Feedback
 from .session import Session
-from .session_history import SessionHistory
+from .task import Task
+from .task_event import TaskEvent
 
-__all__ = ["Message", "Session", "SessionHistory"]
+__all__ = ["ChatTask", "Feedback", "Session", "Task", "TaskEvent"]

solace_agent_mesh/gateway/http_sse/repository/entities/chat_task.py

@@ -0,0 +1,75 @@
+"""
+ChatTask domain entity.
+"""
+
+import json
+from typing import Any, Dict, Optional
+
+from pydantic import BaseModel, ConfigDict, field_validator
+
+
+class ChatTask(BaseModel):
+    """ChatTask domain entity with business logic."""
+
+    model_config = ConfigDict(from_attributes=True)
+
+    id: str
+    session_id: str
+    user_id: str
+    user_message: Optional[str] = None
+    message_bubbles: str  # JSON string (opaque to backend)
+    task_metadata: Optional[str] = None  # JSON string (opaque to backend)
+    created_time: int
+    updated_time: Optional[int] = None
+
+    @field_validator("message_bubbles")
+    @classmethod
+    def validate_message_bubbles(cls, v: str) -> str:
+        """Validate that message_bubbles is a non-empty JSON string."""
+        if not v or not v.strip():
+            raise ValueError("message_bubbles cannot be empty")
+        
+        # Validate it's valid JSON (but don't validate structure)
+        try:
+            parsed = json.loads(v)
+            if not isinstance(parsed, list) or len(parsed) == 0:
+                raise ValueError("message_bubbles must be a non-empty JSON array")
+        except json.JSONDecodeError as e:
+            raise ValueError(f"message_bubbles must be valid JSON: {e}")
+        
+        return v
+
+    @field_validator("task_metadata")
+    @classmethod
+    def validate_task_metadata(cls, v: Optional[str]) -> Optional[str]:
+        """Validate that task_metadata is valid JSON if provided."""
+        if v is None or not v.strip():
+            return None
+        
+        # Validate it's valid JSON (but don't validate structure)
+        try:
+            json.loads(v)
+        except json.JSONDecodeError as e:
+            raise ValueError(f"task_metadata must be valid JSON: {e}")
+        
+        return v
+
+    def add_feedback(self, feedback_type: str, feedback_text: Optional[str] = None) -> None:
+        """Add or update feedback for this task."""
+        # Parse metadata, update, re-serialize
+        metadata = json.loads(self.task_metadata) if self.task_metadata else {}
+        
+        metadata["feedback"] = {
+            "type": feedback_type,
+            "text": feedback_text,
+            "submitted": True
+        }
+        
+        self.task_metadata = json.dumps(metadata)
+
+    def get_feedback(self) -> Optional[Dict[str, Any]]:
+        """Get feedback for this task."""
+        if self.task_metadata:
+            metadata = json.loads(self.task_metadata)
+            return metadata.get("feedback")
+        return None