solace-agent-mesh 1.4.5__py3-none-any.whl → 1.4.7__py3-none-any.whl

solace_agent_mesh/gateway/http_sse/component.py

@@ -131,7 +131,9 @@ class WebUIBackendComponent(BaseGatewayComponent):
         )
 
         self._sse_cleanup_timer_id = f"sse_cleanup_{self.gateway_id}"
-        cleanup_interval_sec = self.get_config("sse_buffer_cleanup_interval_seconds", 300)
+        cleanup_interval_sec = self.get_config(
+            "sse_buffer_cleanup_interval_seconds", 300
+        )
         self.add_timer(
             delay_ms=cleanup_interval_sec * 1000,
             timer_id=self._sse_cleanup_timer_id,
@@ -173,13 +175,14 @@ class WebUIBackendComponent(BaseGatewayComponent):
         self._visualization_locks_lock = threading.Lock()
         self._global_visualization_subscriptions: dict[str, int] = {}
         self._visualization_processor_task: asyncio.Task | None = None
-        
+
         # Initialize SAM Events service for system events
         from ...common.sam_events import SamEventService
+
         self.sam_events = SamEventService(
             namespace=self.namespace,
-            component_name=f"{self.name}_gateway", 
-            publish_func=self.publish_a2a
+            component_name=f"{self.name}_gateway",
+            publish_func=self.publish_a2a,
         )
 
         log.info("%s Web UI Backend Component initialized.", self.log_identifier)
@@ -1007,7 +1010,7 @@ class WebUIBackendComponent(BaseGatewayComponent):
             )
 
         except Exception as e:
-            log.exception(
+            log.error(
                 "%s [_start_listener] Failed to start FastAPI/Uvicorn server: %s",
                 self.log_identifier,
                 e,
@@ -1024,12 +1027,16 @@ class WebUIBackendComponent(BaseGatewayComponent):
         It's thread-safe as it uses the SAC App instance.
         """
         log.debug(f"[publish_a2a] Starting to publish message to topic: {topic}")
-        log.debug(f"[publish_a2a] Payload type: {type(payload)}, size: {len(str(payload))} chars")
+        log.debug(
+            f"[publish_a2a] Payload type: {type(payload)}, size: {len(str(payload))} chars"
+        )
         log.debug(f"[publish_a2a] User properties: {user_properties}")
-        
+
         try:
             super().publish_a2a_message(payload, topic, user_properties)
-            log.debug(f"[publish_a2a] Successfully called super().publish_a2a_message for topic: {topic}")
+            log.debug(
+                f"[publish_a2a] Successfully called super().publish_a2a_message for topic: {topic}"
+            )
         except Exception as e:
             log.error(f"[publish_a2a] Exception in publish_a2a: {e}", exc_info=True)
             raise
@@ -1143,7 +1150,7 @@ class WebUIBackendComponent(BaseGatewayComponent):
                 details["source_entity"] = payload.get("source_component", "unknown")
                 details["target_entity"] = "system"
                 return details
-                
+
             # Try to parse as a JSON-RPC response first
             if "result" in payload or "error" in payload:
                 rpc_response = JSONRPCResponse.model_validate(payload)
@@ -1264,9 +1271,9 @@ class WebUIBackendComponent(BaseGatewayComponent):
                 (summary_str[:100] + "...") if len(summary_str) > 100 else summary_str
             )
         except Exception:
-            details["payload_summary"]["params_preview"] = (
-                "[Could not serialize payload]"
-            )
+            details["payload_summary"][
+                "params_preview"
+            ] = "[Could not serialize payload]"
 
         return details
 
@@ -1669,7 +1676,9 @@ class WebUIBackendComponent(BaseGatewayComponent):
                 try:
                     session_id = external_request_context.get("a2a_session_id")
                     user_id = external_request_context.get("user_id_for_a2a")
-                    agent_name = external_request_context.get("target_agent_name", "agent")
+                    agent_name = external_request_context.get(
+                        "target_agent_name", "agent"
+                    )
 
                     message_text = ""
                     if task_data.status and task_data.status.message:
@@ -1681,10 +1690,15 @@ class WebUIBackendComponent(BaseGatewayComponent):
                                 message_text += part.text
 
                     if message_text and session_id and user_id:
-                        from .dependencies import create_session_service_with_transaction
+                        from .dependencies import (
+                            create_session_service_with_transaction,
+                        )
                         from ...gateway.http_sse.shared.enums import SenderType
 
-                        with create_session_service_with_transaction() as (session_service, db):
+                        with create_session_service_with_transaction() as (
+                            session_service,
+                            db,
+                        ):
                             session_service.add_message_to_session(
                                 session_id=session_id,
                                 user_id=user_id,

solace_agent_mesh/gateway/http_sse/main.py

@@ -310,38 +310,48 @@ def _setup_alembic_config(database_url: str) -> Config:
 
 
 def _run_community_migrations(database_url: str) -> None:
+    """
+    Run Alembic migrations for the community database schema.
+    This includes sessions, chat_messages tables and their indexes.
+    """
     try:
         from sqlalchemy import create_engine
 
+        log.info("Starting community migrations...")
         engine = create_engine(database_url)
         inspector = sa.inspect(engine)
         existing_tables = inspector.get_table_names()
 
         if not existing_tables or "sessions" not in existing_tables:
-            log.info("Running community database migrations...")
+            log.info("Running initial community database setup")
             alembic_cfg = _setup_alembic_config(database_url)
             command.upgrade(alembic_cfg, "head")
-            log.info("Community database migrations complete.")
+            log.info("Community database migrations completed")
         else:
-            log.info(
-                "Community database tables already exist, skipping community migrations."
-            )
+            log.info("Checking for community schema updates")
+            alembic_cfg = _setup_alembic_config(database_url)
+            command.upgrade(alembic_cfg, "head")
+            log.info("Community database schema is current")
     except Exception as e:
         log.warning(
-            "Community migration check failed, attempting to run migrations anyway: %s",
+            "Community migration check failed: %s - attempting to run migrations",
             e,
         )
         try:
             alembic_cfg = _setup_alembic_config(database_url)
             command.upgrade(alembic_cfg, "head")
-            log.info("Community database migrations complete.")
+            log.info("Community database migrations completed")
         except Exception as migration_error:
-            log.warning(
-                "Community migration failed but continuing: %s", 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
 
 
 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.
+    """
     try:
         from solace_agent_mesh_enterprise.webui_backend.migration_runner import (
             run_migrations,
@@ -349,19 +359,25 @@ def _run_enterprise_migrations(component: "WebUIBackendComponent", database_url:
 
         webui_app = component.get_app()
         app_config = getattr(webui_app, "app_config", {}) if webui_app else {}
-        log.info("Running enterprise migrations...")
+        log.info("Starting enterprise migrations...")
         run_migrations(database_url, app_config)
         log.info("Enterprise migrations completed")
     except (ImportError, ModuleNotFoundError):
         log.debug("Enterprise module not found - skipping enterprise migrations")
     except Exception as e:
-        log.warning("Enterprise migration failed but continuing: %s", e)
+        log.error("Enterprise migration failed: %s", e)
+        log.error("Advanced features may be unavailable")
+        raise RuntimeError(f"Enterprise database migration failed: {e}") from e
 
 
 def _setup_database(component: "WebUIBackendComponent", database_url: str) -> None:
+    """
+    Initialize database connection and run all required migrations.
+    This sets up both community and enterprise database schemas.
+    """
     dependencies.init_database(database_url)
     log.info("Persistence enabled - sessions will be stored in database")
-    log.info("Checking database migrations...")
+    log.info("Running database migrations...")
 
     _run_community_migrations(database_url)
     _run_enterprise_migrations(component, database_url)

solace_agent_mesh/gateway/http_sse/routers/sessions.py

@@ -1,8 +1,11 @@
 from fastapi import APIRouter, Body, Depends, HTTPException, status
+from fastapi import Request as FastAPIRequest
 from solace_ai_connector.common.log import log
 
-from ..dependencies import get_session_business_service
+from a2a.types import JSONRPCSuccessResponse
+from ..dependencies import get_session_business_service, get_session_manager
 from ..services.session_service import SessionService
+from ..session_manager import SessionManager
 from ..shared.auth_utils import get_current_user
 from .dto.requests.session_requests import (
     GetSessionHistoryRequest,
@@ -15,10 +18,45 @@ from .dto.responses.session_responses import (
     SessionListResponse,
     SessionResponse,
 )
+from ....common.a2a import create_generic_success_response
 
 router = APIRouter()
 
 
+@router.post("/sessions/new", response_model=JSONRPCSuccessResponse)
+async def create_new_session(
+    request: FastAPIRequest,
+    user: dict = Depends(get_current_user),
+    session_manager: SessionManager = Depends(get_session_manager),
+    session_service: SessionService = Depends(get_session_business_service),
+):
+    """Creates a new session on-demand and returns its ID."""
+    user_id = user.get("id")
+    log.info("User %s requesting new session", user_id)
+    try:
+        new_session_id = session_manager.create_new_session_id(request)
+        log.info("Created new session ID: %s for user %s", new_session_id, user_id)
+
+        # Attempt to create the session record in the DB.
+        # The service will handle the check for whether persistence is enabled.
+        session_service.create_session(
+            user_id=user_id,
+            agent_id=None,  # Agent is not known at this point
+            name=None,
+            session_id=new_session_id,
+        )
+
+        return create_generic_success_response(
+            result={"id": new_session_id}, request_id=None
+        )
+    except Exception as e:
+        log.error("Error creating new session for user %s: %s", user_id, e)
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to create a new session",
+        )
+
+
 @router.get("/sessions", response_model=SessionListResponse)
 async def get_all_sessions(
     user: dict = Depends(get_current_user),

solace_agent_mesh/gateway/http_sse/routers/tasks.py

@@ -76,28 +76,31 @@ async def _submit_task(
         )
 
         client_id = session_manager.get_a2a_client_id(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:
+        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)
+            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(
+                "%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
@@ -106,38 +109,24 @@ async def _submit_task(
         # Store message in persistence layer if available
         user_id = user_identity.get("id")
         from ....gateway.http_sse.dependencies import SessionLocal
+
         if is_streaming and SessionLocal is not None:
             try:
-                from ....gateway.http_sse.dependencies import create_session_service_with_transaction
+                from ....gateway.http_sse.dependencies import (
+                    create_session_service_with_transaction,
+                )
                 from ....gateway.http_sse.shared.enums import SenderType
-                
+
                 with create_session_service_with_transaction() as (session_service, db):
-                    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,
-                                session_id=session_id
-                            )
-                        except Exception as create_error:
-                            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:
-                                raise create_error
-                            log.info("%sSession was created by another request: %s", log_prefix, session_id)
-                    
                     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'):
+                            if hasattr(part, "text"):
                                 message_text = part.text
                                 break
-                    
-                    message_domain = session_service.add_message_to_session(
+
+                    session_service.add_message_to_session(
                         session_id=session_id,
                         user_id=user_id,
                         message=message_text or "Task submitted",
@@ -145,15 +134,16 @@ async def _submit_task(
                         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)
+                log.error(
+                    "%sFailed to store message in session service: %s", log_prefix, e
+                )
         else:
-            log.debug("%sNo persistence available or non-streaming - skipping message storage", log_prefix)
+            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)

solace_agent_mesh/gateway/http_sse/services/session_service.py

@@ -1,5 +1,5 @@
 import uuid
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Optional
 
 from solace_ai_connector.common.log import log
 
@@ -29,6 +29,12 @@ class SessionService:
         self.message_repository = message_repository
         self.component = component
 
+    def is_persistence_enabled(self) -> bool:
+        """Checks if the service is configured with a persistent backend."""
+        # The presence of a database_url on the component is the source of truth
+        # for whether SQL persistence is enabled.
+        return self.component and self.component.database_url is not None
+
     def get_user_sessions(
         self, user_id: UserId, pagination: PaginationInfo | None = None
     ) -> list[Session]:
@@ -73,7 +79,11 @@ class SessionService:
         name: str | None = None,
         agent_id: str | None = None,
         session_id: str | None = None,
-    ) -> Session:
+    ) -> Optional[Session]:
+        if not self.is_persistence_enabled():
+            log.debug("Persistence is not enabled. Skipping session creation in DB.")
+            return None
+
         if not user_id or user_id.strip() == "":
             raise ValueError("User ID cannot be empty")
 
@@ -92,9 +102,15 @@ class SessionService:
             updated_time=now_ms,
         )
 
+        if not session:
+            raise ValueError(f"Failed to create session for {session_id}")
+
         created_session = self.session_repository.save(session)
         log.info("Created new session %s for user %s", created_session.id, user_id)
 
+        if not created_session:
+            raise ValueError(f"Failed to save session for {session_id}")
+
         return created_session
 
     def update_session_name(

{solace_agent_mesh-1.4.5.dist-info → solace_agent_mesh-1.4.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: solace-agent-mesh
-Version: 1.4.5
+Version: 1.4.7
 Summary: Solace Agent Mesh is an open-source framework for building event-driven, multi-agent AI systems where specialized agents collaborate on complex tasks.
 Project-URL: Homepage, https://github.com/SolaceLabs/solace-agent-mesh
 Project-URL: Repository, https://github.com/SolaceLabs/solace-agent-mesh