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

solace_agent_mesh/gateway/http_sse/http_sse_llm.txt

@@ -1,4 +1,4 @@
-Here is the comprehensive developer guide for the `http_sse` directory.
+# DEVELOPER GUIDE for the http_sse directory
 
 ## Quick Summary
 The `http_sse` directory implements a complete HTTP/SSE (Server-Sent Events) gateway for the A2A (Agent-to-Agent) system. Its primary purpose is to serve a web-based user interface and act as a bridge between standard web protocols (HTTP, WebSockets/SSE) and the backend A2A messaging fabric.
@@ -6,26 +6,26 @@ The `http_sse` directory implements a complete HTTP/SSE (Server-Sent Events) gat
 The architecture is centered around the `WebUIBackendComponent`, a custom Solace AI Connector (SAC) component that hosts an embedded FastAPI web server. This component manages shared state and resources, such as the `SSEManager` for real-time updates, the `SessionManager` for user sessions, and the `AgentRegistry` for discovering available agents.
 
 Subdirectories organize the functionality:
--   `routers/` defines the REST API endpoints (e.g., `/tasks`, `/agents`).
--   `services/` contains the business logic that the API endpoints call.
--   `dependencies.py` uses FastAPI's dependency injection system to provide the routers and services with safe access to the shared resources managed by the main component.
--   `components/` contains specialized SAC components, for example, to forward A2A messages for real-time visualization.
+- `routers/` defines the REST API endpoints (e.g., `/tasks`, `/agents`).
+- `services/` contains the business logic that the API endpoints call.
+- `dependencies.py` uses FastAPI's dependency injection system to provide the routers and services with safe access to the shared resources managed by the main component.
+- `components/` contains specialized SAC components, for example, to forward A2A messages for real-time visualization.
 
 This design creates a clean separation of concerns, where the web layer (FastAPI) is decoupled from the core messaging and state management layer (SAC Component).
 
 ## Files and Subdirectories Overview
 - **Direct files:**
-    - `__init__.py`: Standard Python package initializer.
-    - `app.py`: Defines the main SAC `WebUIBackendApp`, which specifies configuration and launches the component.
-    - `component.py`: The core SAC component that hosts the FastAPI server and manages all shared resources and A2A logic.
-    - `dependencies.py`: Provides FastAPI dependency injectors for accessing shared resources like services and managers.
-    - `main.py`: The main FastAPI application instance, including middleware, router mounting, and exception handling.
-    - `session_manager.py`: Manages web user sessions and maps them to unique A2A client and session IDs.
-    - `sse_manager.py`: Manages Server-Sent Event (SSE) connections for streaming real-time updates to clients.
+  - `__init__.py`: Standard Python package initializer.
+  - `app.py`: Defines the main SAC `WebUIBackendApp`, which specifies configuration and launches the component.
+  - `component.py`: The core SAC component that hosts the FastAPI server and manages all shared resources and A2A logic.
+  - `dependencies.py`: Provides FastAPI dependency injectors for accessing shared resources like services and managers.
+  - `main.py`: The main FastAPI application instance, including middleware, router mounting, and exception handling.
+  - `session_manager.py`: Manages web user sessions and maps them to unique A2A client and session IDs.
+  - `sse_manager.py`: Manages Server-Sent Event (SSE) connections for streaming real-time updates to clients.
 - **Subdirectories:**
-    - `components/`: Contains specialized SAC components, such as for forwarding messages to the visualization system.
-    - `routers/`: Defines the FastAPI `APIRouter` modules for all REST API endpoints.
-    - `services/`: Encapsulates business logic for agents, tasks, and other domain-specific operations.
+  - `components/`: Contains specialized SAC components, such as for forwarding messages to the visualization system.
+  - `routers/`: Defines the FastAPI `APIRouter` modules for all REST API endpoints.
+  - `services/`: Encapsulates business logic for agents, tasks, and other domain-specific operations.
 
 ## Developer API Reference
 
@@ -33,31 +33,267 @@ This design creates a clean separation of concerns, where the web layer (FastAPI
 
 #### app.py
 **Purpose:** This file defines the `WebUIBackendApp`, a custom SAC (Solace AI Connector) App class. It is responsible for defining the configuration schema for the entire HTTP/SSE gateway and programmatically creating the `WebUIBackendComponent`.
-**Import:** `from gateway.http_sse.app import WebUIBackendApp`
+**Import:** `from solace_agent_mesh.gateway.http_sse.app import WebUIBackendApp`
 
 **Classes/Functions/Constants:**
--   **`WebUIBackendApp(BaseGatewayApp)`**: The main application class. It extends `BaseGatewayApp` and adds a list of WebUI-specific configuration parameters to the application schema.
--   **`SPECIFIC_APP_SCHEMA_PARAMS: List[Dict[str, Any]]`**: A constant list defining the configuration parameters specific to the HTTP/SSE gateway, such as `session_secret_key`, `fastapi_host`, `fastapi_port`, and various frontend-related settings.
+- **`WebUIBackendApp(BaseGatewayApp)`**: The main application class. It extends `BaseGatewayApp` and adds a list of WebUI-specific configuration parameters to the application schema.
+- **`SPECIFIC_APP_SCHEMA_PARAMS: List[Dict[str, Any]]`**: A constant list defining the configuration parameters specific to the HTTP/SSE gateway, such as `session_secret_key`, `fastapi_host`, `fastapi_port`, and various frontend-related settings.
 
 #### component.py
 **Purpose:** This is the core component of the gateway. It hosts the FastAPI server, manages all shared state (like the SSE and Session managers), handles the lifecycle of the web server, and implements the logic for translating between external HTTP requests and internal A2A messages.
-**Import:** `from gateway.http_sse.component import WebUIBackendComponent`
+**Import:** `from solace_agent_mesh.gateway.http_sse.component import WebUIBackendComponent`
 
 **Classes/Functions/Constants:**
--   **`WebUIBackendComponent(BaseGatewayComponent)`**: The main component class. Developers will primarily interact with its instances via the dependency injection system.
-    -   **Public Accessor Methods (for Dependencies):**
-        -   `get_sse_manager() -> SSEManager`: Returns the shared `SSEManager` instance.
-        -   `get_session_manager() -> SessionManager`: Returns the shared `SessionManager` instance.
-        -   `get_agent_registry() -> AgentRegistry`: Returns the shared `AgentRegistry` instance.
-        -   `get_core_a2a_service() -> CoreA2AService`: Returns the core service for creating A2A messages.
-        -   `get_shared_artifact_service() -> Optional[BaseArtifactService]`: Returns the service for artifact storage.
-        -   `get_namespace() -> str`: Returns the configured namespace.
-        -   `get_gateway_id() -> str`: Returns the unique ID of this gateway.
-    -   **Core Logic Methods:**
-        -   `publish_a2a(topic: str, payload: Dict, user_properties: Optional[Dict] = None)`: Publishes a message onto the A2A messaging fabric. This is the primary method for sending data to agents.
-    -   **Gateway-Development-Kit (GDK) Hooks:** These methods implement the `BaseGatewayComponent` abstract interface.
-        -   `_start_listener()`: Starts the FastAPI/Uvicorn server.
-        -   `_stop_listener()`: Stops the FastAPI/Uvicorn server.
-        -   `_translate_external_input(...)`: Translates an incoming HTTP request (e.g., form data with files) into a structured A2A message (`List[A2APart]`).
-        -   `_send_update_to_external(...)`: Sends an intermediate status update from an agent back to the client via SSE.
-        -
+- **`WebUIBackendComponent(BaseGatewayComponent)`**: The main component class. Developers will primarily interact with its instances via the dependency injection system.
+  - **Public Accessor Methods (for Dependencies):**
+    - `get_sse_manager() -> SSEManager`: Returns the shared `SSEManager` instance.
+    - `get_session_manager() -> SessionManager`: Returns the shared `SessionManager` instance.
+    - `get_agent_registry() -> AgentRegistry`: Returns the shared `AgentRegistry` instance.
+    - `get_core_a2a_service() -> CoreA2AService`: Returns the core service for creating A2A messages.
+    - `get_shared_artifact_service() -> Optional[BaseArtifactService]`: Returns the service for artifact storage.
+    - `get_namespace() -> str`: Returns the configured A2A namespace.
+    - `get_gateway_id() -> str`: Returns the unique ID of this gateway.
+  - **Core Logic Methods:**
+    - `publish_a2a(topic: str, payload: Dict, user_properties: Optional[Dict] = None)`: Publishes a message onto the A2A messaging fabric. This is the primary method for sending data to agents.
+  - **Gateway-Development-Kit (GDK) Hooks:** These methods implement the `BaseGatewayComponent` abstract interface.
+    - `_start_listener()`: Starts the FastAPI/Uvicorn server.
+    - `_stop_listener()`: Stops the FastAPI/Uvicorn server.
+    - `_translate_external_input(...)`: Translates an incoming HTTP request (e.g., form data with files) into a structured A2A message (`List[ContentPart]`).
+    - `_send_update_to_external(...)`: Sends an intermediate status update from an agent back to the client via SSE.
+    - `_send_final_response_to_external(...)`: Sends the final A2A Task result to the client via SSE.
+    - `_send_error_to_external(...)`: Sends an error notification to the client via SSE.
+
+#### dependencies.py
+**Purpose:** Defines FastAPI dependency injectors to access shared resources managed by the WebUIBackendComponent.
+**Import:** `from solace_agent_mesh.gateway.http_sse.dependencies import *`
+
+**Functions:**
+- `get_sac_component() -> WebUIBackendComponent`: Returns the main component instance.
+- `get_agent_registry() -> AgentRegistry`: Returns the shared agent registry.
+- `get_sse_manager() -> SSEManager`: Returns the SSE manager for real-time updates.
+- `get_session_manager() -> SessionManager`: Returns the session manager.
+- `get_user_id(request: Request) -> str`: Returns the current user's identity.
+- `get_publish_a2a_func() -> PublishFunc`: Returns the function for publishing A2A messages.
+- `get_core_a2a_service() -> CoreA2AService`: Returns the core A2A service.
+- `get_shared_artifact_service() -> Optional[BaseArtifactService]`: Returns the artifact service.
+
+#### main.py
+**Purpose:** Defines the FastAPI application instance, mounts routers, and configures middleware.
+**Import:** `from solace_agent_mesh.gateway.http_sse.main import app, setup_dependencies`
+
+**Classes/Functions/Constants:**
+- **`app: FastAPI`**: The main FastAPI application instance.
+- **`setup_dependencies(component: WebUIBackendComponent)`**: Configures middleware, routers, and dependency injection based on the component instance.
+
+#### session_manager.py
+**Purpose:** Manages web user sessions and mapping to A2A Client IDs.
+**Import:** `from solace_agent_mesh.gateway.http_sse.session_manager import SessionManager`
+
+**Classes/Functions/Constants:**
+- **`SessionManager(secret_key: str, app_config: Dict[str, Any])`**: Manages user sessions and A2A identity mapping.
+  - `get_a2a_client_id(request: Request) -> str`: Returns the A2A client ID for the current request.
+  - `start_new_a2a_session(request: Request) -> str`: Creates a new A2A session ID.
+  - `ensure_a2a_session(request: Request) -> str`: Ensures a session ID exists, creating one if necessary.
+  - `store_auth_tokens(request: Request, access_token: str, refresh_token: Optional[str])`: Stores authentication tokens.
+  - `get_access_token(request: Request) -> Optional[str]`: Retrieves stored access token.
+
+#### sse_manager.py
+**Purpose:** Manages Server-Sent Event (SSE) connections for streaming task updates.
+**Import:** `from solace_agent_mesh.gateway.http_sse.sse_manager import SSEManager`
+
+**Classes/Functions/Constants:**
+- **`SSEManager(max_queue_size: int = 200)`**: Manages active SSE connections and distributes events.
+  - `create_sse_connection(task_id: str) -> asyncio.Queue`: Creates a new SSE connection queue for a task.
+  - `send_event(task_id: str, event_data: Dict[str, Any], event_type: str)`: Sends an event to all connections for a task.
+  - `close_all_for_task(task_id: str)`: Closes all SSE connections for a specific task.
+  - `close_all()`: Closes all active SSE connections.
+
+### Subdirectory APIs
+
+#### components/
+**Purpose:** Contains specialized SAC components for message forwarding and visualization
+**Key Exports:** `VisualizationForwarderComponent`
+**Import Examples:**
+```python
+from solace_agent_mesh.gateway.http_sse.components import VisualizationForwarderComponent
+```
+
+#### routers/
+**Purpose:** Defines FastAPI APIRouter modules for all REST API endpoints
+**Key Exports:** Router instances for agents, tasks, SSE, artifacts, auth, config, sessions, people, users, visualization
+**Import Examples:**
+```python
+from solace_agent_mesh.gateway.http_sse.routers import agents, tasks, sse, artifacts
+from solace_agent_mesh.gateway.http_sse.routers.tasks import CancelTaskApiPayload
+```
+
+#### services/
+**Purpose:** Encapsulates business logic for domain-specific operations
+**Key Exports:** `AgentService`, `TaskService`, `PeopleService`
+**Import Examples:**
+```python
+from solace_agent_mesh.gateway.http_sse.services.agent_service import AgentService
+from solace_agent_mesh.gateway.http_sse.services.task_service import TaskService
+from solace_agent_mesh.gateway.http_sse.services.people_service import PeopleService
+```
+
+## Complete Usage Guide
+
+### 1. Setting Up the Gateway Application
+
+```python
+from solace_agent_mesh.gateway.http_sse.app import WebUIBackendApp
+
+# Create the gateway app with configuration
+app_config = {
+    "name": "my-webui-gateway",
+    "session_secret_key": "your-secret-key-here",
+    "fastapi_host": "0.0.0.0",
+    "fastapi_port": 8000,
+    "namespace": "/my-namespace",
+    "gateway_id": "webui-gateway-01",
+    "cors_allowed_origins": ["http://localhost:3000"],
+    "frontend_welcome_message": "Welcome to my A2A system!",
+    "frontend_bot_name": "My Assistant",
+    # ... other configuration parameters
+}
+
+# Initialize the app
+webui_app = WebUIBackendApp(app_info=app_config)
+
+# Run the app (this starts the FastAPI server)
+webui_app.run()
+```
+
+### 2. Using Dependencies in Custom Routers
+
+```python
+from fastapi import APIRouter, Depends
+from solace_agent_mesh.gateway.http_sse.dependencies import (
+    get_agent_registry,
+    get_user_id,
+    get_publish_a2a_func,
+    get_core_a2a_service
+)
+from solace_agent_mesh.common.agent_registry import AgentRegistry
+
+router = APIRouter()
+
+@router.get("/my-custom-endpoint")
+async def my_custom_endpoint(
+    user_id: str = Depends(get_user_id),
+    agent_registry: AgentRegistry = Depends(get_agent_registry),
+    publish_func = Depends(get_publish_a2a_func)
+):
+    # Access discovered agents
+    agents = agent_registry.get_all_agents()
+    
+    # Publish a message to the A2A fabric
+    publish_func(
+        topic=f"/my-namespace/a2a/v1/agent/request/some-agent",
+        payload={"method": "custom/request", "params": {"user": user_id}},
+        user_properties={"clientId": user_id}
+    )
+    
+    return {"agents_count": len(agents), "user_id": user_id}
+```
+
+### 3. Managing SSE Connections
+
+```python
+from fastapi import APIRouter, Depends
+from fastapi.responses import StreamingResponse
+from solace_agent_mesh.gateway.http_sse.dependencies import get_sse_manager
+from solace_agent_mesh.gateway.http_sse.sse_manager import SSEManager
+import asyncio
+import json
+
+router = APIRouter()
+
+@router.get("/my-sse-endpoint/{task_id}")
+async def my_sse_endpoint(
+    task_id: str,
+    sse_manager: SSEManager = Depends(get_sse_manager)
+):
+    # Create SSE connection for the task
+    connection_queue = await sse_manager.create_sse_connection(task_id)
+    
+    async def event_generator():
+        try:
+            while True:
+                # Wait for events from the queue
+                event = await connection_queue.get()
+                if event is None:  # Close signal
+                    break
+                
+                # Format as SSE
+                yield f"event: {event['event']}\n"
+                yield f"data: {event['data']}\n\n"
+                
+        except asyncio.CancelledError:
+            pass
+        finally:
+            # Clean up connection
+            await sse_manager.remove_sse_connection(task_id, connection_queue)
+    
+    return StreamingResponse(
+        event_generator(),
+        media_type="text/event-stream",
+        headers={
+            "Cache-Control": "no-cache",
+            "Connection": "keep-alive",
+        }
+    )
+
+# Send events to SSE connections
+async def send_custom_event(sse_manager: SSEManager, task_id: str):
+    await sse_manager.send_event(
+        task_id=task_id,
+        event_data={"message": "Custom event", "timestamp": "2024-01-01T00:00:00Z"},
+        event_type="custom_event"
+    )
+```
+
+### 4. Working with Sessions and User Identity
+
+```python
+from fastapi import APIRouter, Depends, Request
+from solace_agent_mesh.gateway.http_sse.dependencies import (
+    get_session_manager,
+    get_user_id,
+    ensure_session_id
+)
+from solace_agent_mesh.gateway.http_sse.session_manager import SessionManager
+
+router = APIRouter()
+
+@router.post("/start-conversation")
+async def start_conversation(
+    request: Request,
+    user_id: str = Depends(get_user_id),
+    session_id: str = Depends(ensure_session_id),
+    session_manager: SessionManager = Depends(get_session_manager)
+):
+    # Start a new A2A session for this conversation
+    new_session_id = session_manager.start_new_a2a_session(request)
+    
+    return {
+        "user_id": user_id,
+        "old_session_id": session_id,
+        "new_session_id": new_session_id,
+        "message": "New conversation started"
+    }
+```
+
+### 5. Using Services for Business Logic
+
+```python
+from fastapi import APIRouter, Depends
+from solace_agent_mesh.gateway.http_sse.dependencies import (
+    get_agent_service,
+    get_task_service,
+    get_people_service
+)
+from solace_agent_mesh.gateway.http_sse.services.agent_service import AgentService
+
+# content_hash: 765fb33c6a30298c67ac7c1525df5787791b2b37e0d69b046e405aec85287feb

solace_agent_mesh/gateway/http_sse/infrastructure/__init__.py

@@ -0,0 +1,4 @@
+from .persistence.database_service import DatabaseService
+from .repositories.session_repository import SessionRepository, MessageRepository
+
+__all__ = ["DatabaseService", "SessionRepository", "MessageRepository"]

solace_agent_mesh/gateway/http_sse/infrastructure/dependency_injection/__init__.py

@@ -0,0 +1,3 @@
+from .container import ApplicationContainer, get_container, initialize_container
+
+__all__ = ["ApplicationContainer", "initialize_container", "get_container"]

solace_agent_mesh/gateway/http_sse/infrastructure/dependency_injection/container.py

@@ -0,0 +1,123 @@
+from collections.abc import Callable
+from typing import Any, TypeVar
+
+from ...application.services.session_service import SessionService
+from ...domain.repositories.session_repository import (
+    IMessageRepository,
+    ISessionRepository,
+)
+from ...infrastructure.persistence import database_service as db_service_module
+from ...infrastructure.persistence.database_service import DatabaseService
+from ...infrastructure.repositories.session_repository import (
+    MessageRepository,
+    SessionRepository,
+)
+
+T = TypeVar("T")
+
+
+class DIContainer:
+    """Dependency injection container."""
+
+    def __init__(self):
+        self._services: dict[str, Any] = {}
+        self._factories: dict[str, Callable] = {}
+        self._singletons: dict[str, Any] = {}
+
+    def register_singleton(self, service_type: type, instance: Any) -> None:
+        self._singletons[service_type.__name__] = instance
+
+    def register_factory(self, service_type: type, factory: Callable) -> None:
+        self._factories[service_type.__name__] = factory
+
+    def register_transient(self, service_type: type, implementation: type) -> None:
+        """Register a transient service (new instance each time)."""
+        self._services[service_type.__name__] = implementation
+
+    def get(self, service_type: type) -> Any:
+        """Get an instance of the requested service."""
+        service_name = service_type.__name__
+
+        # Check singletons first
+        if service_name in self._singletons:
+            return self._singletons[service_name]
+
+        # Check factories
+        if service_name in self._factories:
+            return self._factories[service_name]()
+
+        # Check transient services
+        if service_name in self._services:
+            implementation = self._services[service_name]
+            return self._create_instance(implementation)
+
+        raise ValueError(f"Service {service_name} is not registered")
+
+    def _create_instance(self, implementation: type) -> Any:
+        """Create an instance with dependency injection."""
+        # This is a simplified implementation
+        # In a production system, you'd use a more sophisticated approach
+        # like inspecting constructor parameters and resolving them automatically
+        return implementation()
+
+
+class ApplicationContainer:
+    """Application-specific dependency injection container."""
+
+    def __init__(self, database_url: str | None = None):
+        self.container = DIContainer()
+        self.database_url = database_url
+        self.has_database = database_url is not None
+        self._setup_dependencies()
+
+    def _setup_dependencies(self) -> None:
+        if self.has_database:
+            database_service = DatabaseService(self.database_url)
+            self.container.register_singleton(DatabaseService, database_service)
+            db_service_module.database_service = database_service
+
+            session_repository = SessionRepository(database_service)
+            message_repository = MessageRepository(database_service)
+
+            self.container.register_singleton(ISessionRepository, session_repository)
+            self.container.register_singleton(IMessageRepository, message_repository)
+
+            def session_service_factory():
+                return SessionService(session_repository, message_repository)
+
+            self.container.register_factory(SessionService, session_service_factory)
+
+    def get_database_service(self) -> DatabaseService | None:
+        if not self.has_database:
+            return None
+        return self.container.get(DatabaseService)
+
+    def get_session_service(self) -> SessionService | None:
+        if not self.has_database:
+            return None
+        return self.container.get(SessionService)
+
+
+# Global container instance
+_container: ApplicationContainer | None = None
+
+
+def initialize_container(database_url: str | None = None) -> ApplicationContainer:
+    global _container
+    _container = ApplicationContainer(database_url)
+
+    # Only create tables if database is available
+    if _container.has_database:
+        database_service = _container.get_database_service()
+        if database_service:
+            database_service.create_tables()
+
+    return _container
+
+
+def get_container() -> ApplicationContainer:
+    if _container is None:
+        raise RuntimeError(
+            "Container not initialized. Call initialize_container() first."
+        )
+    return _container

solace_agent_mesh/gateway/http_sse/infrastructure/persistence/__init__.py

@@ -0,0 +1,4 @@
+from .database_service import DatabaseService
+from .models import Base, SessionModel, MessageModel
+
+__all__ = ["DatabaseService", "Base", "SessionModel", "MessageModel"]

solace_agent_mesh/gateway/http_sse/infrastructure/persistence/database_persistence_service.py

@@ -0,0 +1,16 @@
+from sqlalchemy.orm import sessionmaker
+
+from .database_service import DatabaseService
+
+
+class DatabasePersistenceService:
+    def __init__(self, db_url: str):
+        self.db_service = DatabaseService(db_url)
+        self._session_factory = sessionmaker(bind=self.db_service.engine)
+
+    def Session(self):
+        return self._session_factory()
+
+    @property
+    def engine(self):
+        return self.db_service.engine

solace_agent_mesh/gateway/http_sse/infrastructure/persistence/database_service.py

@@ -0,0 +1,119 @@
+import logging
+from collections.abc import Generator
+from contextlib import contextmanager
+
+from sqlalchemy import create_engine, event
+from sqlalchemy.orm import Session, sessionmaker
+
+from .models import Base
+
+
+def get_database_type(database_url: str) -> str:
+    """Get the database type from a database URL."""
+    if database_url.startswith("sqlite"):
+        return "sqlite"
+    elif database_url.startswith("postgresql"):
+        return "postgresql"
+    else:
+        return "unknown"
+
+
+class DatabaseService:
+    def __init__(self, database_url: str):
+        self.database_url = database_url
+        self.logger = logging.getLogger(__name__)
+
+        if database_url.startswith("sqlite"):
+            self._setup_sqlite_engine(database_url)
+        elif database_url.startswith("postgresql"):
+            self._setup_postgresql_engine(database_url)
+        else:
+            # Fallback for other databases
+            self._setup_generic_engine(database_url)
+
+        self.SessionLocal = sessionmaker(
+            autocommit=False, autoflush=False, bind=self.engine
+        )
+
+    def _setup_sqlite_engine(self, database_url: str):
+        """Configure SQLite-specific engine settings."""
+        self.engine = create_engine(
+            database_url,
+            echo=False,
+            connect_args={
+                "check_same_thread": False,
+            },
+        )
+
+        @event.listens_for(self.engine, "connect")
+        def set_sqlite_pragma(dbapi_connection, connection_record):
+            cursor = dbapi_connection.cursor()
+            cursor.execute("PRAGMA foreign_keys=ON")
+            cursor.close()
+
+    def _setup_postgresql_engine(self, database_url: str):
+        """Configure PostgreSQL-specific engine settings."""
+        try:
+            import psycopg2
+        except ImportError:
+            raise ImportError(
+                "PostgreSQL support requires psycopg2. Install with: "
+                "pip install 'solace-agent-mesh[postgresql]'"
+            )
+
+        self.engine = create_engine(
+            database_url,
+            pool_size=10,
+            max_overflow=20,
+            pool_timeout=30,
+            pool_recycle=3600,
+            pool_pre_ping=True,
+            echo=False,
+        )
+
+    def _setup_generic_engine(self, database_url: str):
+        """Configure generic database engine settings."""
+        self.engine = create_engine(
+            database_url,
+            pool_size=10,
+            max_overflow=20,
+            pool_timeout=30,
+            pool_recycle=3600,
+            pool_pre_ping=True,
+            echo=False,
+        )
+
+    def create_tables(self):
+        Base.metadata.create_all(bind=self.engine)
+
+    @contextmanager
+    def session_scope(self) -> Generator[Session, None, None]:
+        session = self.SessionLocal()
+        try:
+            yield session
+            session.commit()
+        except Exception as e:
+            session.rollback()
+            self.logger.error(f"Database transaction failed: {e}")
+            raise
+        finally:
+            session.close()
+
+    @contextmanager
+    def read_only_session(self) -> Generator[Session, None, None]:
+        session = self.SessionLocal()
+        try:
+            yield session
+        except Exception as e:
+            session.rollback()
+            self.logger.error(f"Database read operation failed: {e}")
+            raise
+        finally:
+            session.close()
+
+
+database_service: DatabaseService = None
+
+
+def get_database_service() -> DatabaseService:
+    return database_service

solace_agent_mesh/gateway/http_sse/infrastructure/persistence/models.py

@@ -0,0 +1,31 @@
+from sqlalchemy import Column, DateTime, ForeignKey, String, Text
+from sqlalchemy.orm import declarative_base, relationship
+from sqlalchemy.sql import func
+
+Base = declarative_base()
+
+
+class SessionModel(Base):
+    __tablename__ = "sessions"
+    id = Column(String, primary_key=True)
+    name = Column(String, nullable=True)
+    user_id = Column(String, nullable=False)
+    agent_id = Column(String, nullable=True)
+    created_at = Column(DateTime, default=func.now())
+    updated_at = Column(DateTime, default=func.now(), onupdate=func.now())
+    messages = relationship(
+        "MessageModel", back_populates="session", cascade="all, delete-orphan"
+    )
+
+
+class MessageModel(Base):
+    __tablename__ = "chat_messages"
+    id = Column(String, primary_key=True)
+    session_id = Column(
+        String, ForeignKey("sessions.id", ondelete="CASCADE"), nullable=False
+    )
+    message = Column(Text, nullable=False)
+    created_at = Column(DateTime, default=func.now())
+    sender_type = Column(String(50))
+    sender_name = Column(String(255))
+    session = relationship("SessionModel", back_populates="messages")

solace_agent_mesh/gateway/http_sse/infrastructure/persistence_service.py

@@ -0,0 +1,12 @@
+from .dependency_injection.container import ApplicationContainer
+from .persistence.database_service import DatabaseService
+
+
+class PersistenceService:
+    def __init__(self, database_url: str):
+        self.db_service = DatabaseService(database_url)
+        self.container = ApplicationContainer(database_url)
+
+    @property
+    def engine(self):
+        return self.db_service.engine

solace_agent_mesh/gateway/http_sse/infrastructure/repositories/__init__.py

@@ -0,0 +1,3 @@
+from .session_repository import SessionRepository, MessageRepository
+
+__all__ = ["SessionRepository", "MessageRepository"]