solace-agent-mesh 1.3.1__py3-none-any.whl → 1.3.2__py3-none-any.whl

solace_agent_mesh/client/webui/frontend/static/index.html

@@ -5,7 +5,7 @@
     <link rel="icon" type="image/svg+xml" href="/assets/favicon-BLgzUch9.ico" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>Solace Agent Mesh</title>
-    <script type="module" crossorigin src="/assets/main-C1k9E0aC.js"></script>
+    <script type="module" crossorigin src="/assets/main-DjoMeldu.js"></script>
     <link rel="modulepreload" crossorigin href="/assets/vendor-B0BEKoAR.js">
     <link rel="modulepreload" crossorigin href="/assets/client-DXU9SPI5.js">
     <link rel="stylesheet" crossorigin href="/assets/main-C03yrETa.css">

solace_agent_mesh/common/a2a/__init__.py

@@ -81,6 +81,8 @@ from .protocol import (
     get_message_from_send_request,
     get_peer_agent_status_topic,
     get_request_id,
+    get_sam_events_topic,
+    get_sam_events_subscription_topic,
     get_request_method,
     get_response_error,
     get_error_code,
@@ -184,6 +186,8 @@ __all__ = [
     "get_message_from_send_request",
     "get_peer_agent_status_topic",
     "get_request_id",
+    "get_sam_events_topic",
+    "get_sam_events_subscription_topic",
     "get_request_method",
     "get_response_error",
     "get_error_code",

solace_agent_mesh/common/a2a/protocol.py

@@ -176,6 +176,26 @@ def get_client_status_subscription_topic(namespace: str, client_id: str) -> str:
     return f"{get_a2a_base_topic(namespace)}/client/status/{client_id}/>"
 
 
+def get_sam_events_topic(namespace: str, category: str, action: str) -> str:
+    """Returns SAM system events topic."""
+    if not namespace:
+        raise ValueError("Namespace cannot be empty.")
+    if not category:
+        raise ValueError("Category cannot be empty.")
+    if not action:
+        raise ValueError("Action cannot be empty.")
+    return f"{namespace.rstrip('/')}/sam/events/{category}/{action}"
+
+
+def get_sam_events_subscription_topic(namespace: str, category: str) -> str:
+    """Returns SAM system events subscription topic."""
+    if not namespace:
+        raise ValueError("Namespace cannot be empty.")
+    if not category:
+        raise ValueError("Category cannot be empty.")
+    return f"{namespace.rstrip('/')}/sam/events/{category}/>"
+
+
 def subscription_to_regex(subscription: str) -> str:
     """Converts a Solace topic subscription string to a regex pattern."""
     # Escape regex special characters except for Solace wildcards

solace_agent_mesh/common/sac/sam_component_base.py

@@ -2,16 +2,16 @@
 Base Component class for SAM implementations in the Solace AI Connector.
 """
 
+import abc
 import asyncio
 import threading
-import abc
-from typing import Any, Dict, Optional
+from typing import Any
 
-from solace_ai_connector.components.component_base import ComponentBase
 from solace_ai_connector.common.log import log
+from solace_ai_connector.components.component_base import ComponentBase
 
-from ..utils.message_utils import validate_message_size
 from ..exceptions import MessageSizeExceededError
+from ..utils.message_utils import validate_message_size
 
 
 class SamComponentBase(ComponentBase, abc.ABC):
@@ -23,7 +23,7 @@ class SamComponentBase(ComponentBase, abc.ABC):
     - Publishing A2A messages with built-in size validation.
     """
 
-    def __init__(self, info: Dict[str, Any], **kwargs: Any):
+    def __init__(self, info: dict[str, Any], **kwargs: Any):
         super().__init__(info, **kwargs)
         log.info("%s Initializing SamComponentBase...", self.log_identifier)
 
@@ -51,15 +51,19 @@ class SamComponentBase(ComponentBase, abc.ABC):
             )
             raise ValueError(f"Configuration retrieval error: {e}") from e
 
-        self._async_loop: Optional[asyncio.AbstractEventLoop] = None
-        self._async_thread: Optional[threading.Thread] = None
+        self._async_loop: asyncio.AbstractEventLoop | None = None
+        self._async_thread: threading.Thread | None = None
         log.info("%s SamComponentBase initialized successfully.", self.log_identifier)
 
     def publish_a2a_message(
-        self, payload: Dict, topic: str, user_properties: Optional[Dict] = None
+        self, payload: dict, topic: str, user_properties: dict | None = None
     ):
         """Helper to publish A2A messages via the SAC App with size validation."""
         try:
+            log.debug(
+                f"{self.log_identifier} [publish_a2a_message] Starting - topic: {topic}, payload keys: {list(payload.keys()) if isinstance(payload, dict) else 'not_dict'}"
+            )
+
             # Validate message size
             is_valid, actual_size = validate_message_size(
                 payload, self.max_message_size_bytes, self.log_identifier
@@ -85,6 +89,10 @@ class SamComponentBase(ComponentBase, abc.ABC):
 
             app = self.get_app()
             if app:
+                log.debug(
+                    f"{self.log_identifier} [publish_a2a_message] Got app instance, about to call app.send_message"
+                )
+
                 # Conditionally log to invocation monitor if it exists (i.e., on an agent)
                 if hasattr(self, "invocation_monitor") and self.invocation_monitor:
                     self.invocation_monitor.log_message_event(
@@ -93,9 +101,21 @@ class SamComponentBase(ComponentBase, abc.ABC):
                         payload=payload,
                         component_identifier=self.log_identifier,
                     )
+
+                log.debug(
+                    f"{self.log_identifier} [publish_a2a_message] About to call app.send_message with payload: {payload}"
+                )
+                log.debug(
+                    f"{self.log_identifier} [publish_a2a_message] App send_message params - topic: {topic}, user_properties: {user_properties}"
+                )
+
                 app.send_message(
                     payload=payload, topic=topic, user_properties=user_properties
                 )
+
+                log.debug(
+                    f"{self.log_identifier} [publish_a2a_message] Successfully called app.send_message"
+                )
             else:
                 log.error(
                     "%s Cannot publish message: Not running within a SAC App context.",
@@ -231,7 +251,7 @@ class SamComponentBase(ComponentBase, abc.ABC):
         super().cleanup()
         log.info("%s SamComponentBase cleanup finished.", self.log_identifier)
 
-    def get_async_loop(self) -> Optional[asyncio.AbstractEventLoop]:
+    def get_async_loop(self) -> asyncio.AbstractEventLoop | None:
         """Returns the dedicated asyncio event loop for this component's async tasks."""
         return self._async_loop
 

solace_agent_mesh/common/sam_events/__init__.py

@@ -0,0 +1,9 @@
+"""
+SAM Events - System-level event messaging for Solace Agent Mesh.
+
+Provides clean separation between A2A task communication and system events.
+"""
+
+from .event_service import SamEventService, SamEvent, SessionDeletedEvent
+
+__all__ = ["SamEventService", "SamEvent", "SessionDeletedEvent"]

solace_agent_mesh/common/sam_events/event_service.py

@@ -0,0 +1,207 @@
+"""
+SAM Events Service - Clean system-level event messaging.
+
+Provides event publishing and subscription for system events like session lifecycle,
+agent health, configuration changes, etc.
+"""
+
+import uuid
+from datetime import datetime, timezone
+from dataclasses import dataclass, asdict
+from typing import Any, Dict, Optional, Callable, List
+
+from solace_ai_connector.common.log import log
+from ..a2a.protocol import get_sam_events_topic
+
+
+@dataclass
+class SamEvent:
+    """Base class for all SAM system events."""
+    event_type: str
+    event_id: str
+    timestamp: str
+    source_component: str
+    namespace: str
+    data: Dict[str, Any]
+
+    @classmethod
+    def create(cls, event_type: str, source_component: str, namespace: str, data: Dict[str, Any]) -> "SamEvent":
+        """Create a new SAM event with auto-generated ID and timestamp."""
+        return cls(
+            event_type=event_type,
+            event_id=uuid.uuid4().hex,
+            timestamp=datetime.now(timezone.utc).isoformat(),
+            source_component=source_component,
+            namespace=namespace,
+            data=data
+        )
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert event to dictionary for messaging."""
+        return asdict(self)
+
+
+@dataclass
+class SessionDeletedEvent(SamEvent):
+    """System event for session deletion."""
+    
+    @classmethod
+    def create(cls, namespace: str, source_component: str, session_id: str, 
+               user_id: str, agent_id: str, gateway_id: str) -> "SessionDeletedEvent":
+        """Create a session deleted event."""
+        data = {
+            "session_id": session_id,
+            "user_id": user_id,
+            "agent_id": agent_id,
+            "gateway_id": gateway_id
+        }
+        return super().create("session.deleted", source_component, namespace, data)
+
+
+class SamEventService:
+    """Service for publishing and subscribing to SAM system events."""
+    
+    def __init__(self, namespace: str, component_name: str, publish_func: Callable[[str, Dict, Optional[Dict]], None]):
+        """
+        Initialize the SAM event service.
+        
+        Args:
+            namespace: The SAM namespace
+            component_name: Name of the component using this service
+            publish_func: Function to publish messages (from WebUIBackendComponent.publish_a2a)
+        """
+        self.namespace = namespace
+        self.component_name = component_name
+        self.publish_func = publish_func
+        self._subscribers: Dict[str, List[Callable]] = {}
+        
+        log.info(f"[SamEventService] Initialized for component {component_name} in namespace {namespace}")
+
+    def publish_event(self, event: SamEvent) -> bool:
+        """
+        Publish a SAM system event.
+        
+        Args:
+            event: The system event to publish
+            
+        Returns:
+            bool: True if published successfully, False otherwise
+        """
+        try:
+            # Extract category and action from event_type (e.g., "session.deleted" -> "session", "deleted")
+            parts = event.event_type.split(".", 1)
+            if len(parts) != 2:
+                raise ValueError(f"Invalid event_type format: {event.event_type}. Expected 'category.action'")
+                
+            category, action = parts
+            topic = get_sam_events_topic(self.namespace, category, action)
+            payload = event.to_dict()
+            
+            log.info(f"[SamEventService] Publishing {event.event_type} event (ID: {event.event_id}) to topic {topic}")
+            
+            # Use the component's publish function (which goes through proper A2A infrastructure)
+            self.publish_func(topic, payload, {"eventType": event.event_type, "eventId": event.event_id})
+            
+            log.info(f"[SamEventService] Successfully published event {event.event_id}")
+            return True
+            
+        except Exception as e:
+            log.error(f"[SamEventService] Failed to publish event {event.event_id}: {e}")
+            return False
+
+    def publish_session_deleted(self, session_id: str, user_id: str, agent_id: str, gateway_id: str) -> bool:
+        """
+        Convenience method to publish session deleted event.
+        
+        Args:
+            session_id: The deleted session ID
+            user_id: The user who owned the session
+            agent_id: The agent that was handling the session
+            gateway_id: The gateway that deleted the session
+            
+        Returns:
+            bool: True if published successfully
+        """
+        event = SessionDeletedEvent.create(
+            namespace=self.namespace,
+            source_component=self.component_name,
+            session_id=session_id,
+            user_id=user_id,
+            agent_id=agent_id,
+            gateway_id=gateway_id
+        )
+        return self.publish_event(event)
+
+    def subscribe_to_events(self, event_type: str, handler: Callable[[SamEvent], None]) -> bool:
+        """
+        Subscribe to system events of a specific type.
+        
+        Args:
+            event_type: The type of events to subscribe to (e.g., "session.deleted")
+            handler: Function to call when event is received
+            
+        Returns:
+            bool: True if subscription was successful
+        """
+        try:
+            if event_type not in self._subscribers:
+                self._subscribers[event_type] = []
+                
+            self._subscribers[event_type].append(handler)
+            
+            log.info(f"[SamEventService] Subscribed to {event_type} events")
+            return True
+            
+        except Exception as e:
+            log.error(f"[SamEventService] Failed to subscribe to {event_type} events: {e}")
+            return False
+
+    def handle_incoming_event(self, topic: str, payload: Dict[str, Any]) -> None:
+        """
+        Handle incoming SAM event from messaging system.
+        
+        Args:
+            topic: The topic the event was received on
+            payload: Event payload
+        """
+        try:
+            event_type = payload.get("event_type")
+            
+            if not event_type:
+                log.warning(f"[SamEventService] Received event without event_type on topic {topic}")
+                return
+                
+            # Create event object
+            event = SamEvent(**payload)
+            
+            # Call registered handlers
+            handlers = self._subscribers.get(event_type, [])
+            for handler in handlers:
+                try:
+                    handler(event)
+                except Exception as e:
+                    log.error(f"[SamEventService] Error in event handler for {event_type}: {e}")
+                    
+            log.debug(f"[SamEventService] Processed event {event.event_id} with {len(handlers)} handlers")
+            
+        except Exception as e:
+            log.error(f"[SamEventService] Error handling event from topic {topic}: {e}")
+
+    @staticmethod
+    def get_event_topic(namespace: str, event_type: str) -> str:
+        """
+        Get the topic for a specific event type.
+        
+        Args:
+            namespace: The SAM namespace  
+            event_type: Event type in format "category.action"
+            
+        Returns:
+            str: The topic for the event
+        """
+        parts = event_type.split(".", 1)
+        if len(parts) != 2:
+            raise ValueError(f"Invalid event_type format: {event_type}. Expected 'category.action'")
+            
+        category, action = parts
+        return get_sam_events_topic(namespace, category, action)

solace_agent_mesh/gateway/http_sse/alembic/env.py

@@ -14,7 +14,7 @@ if config.config_file_name is not None:
 
 # add your model's MetaData object here
 # for 'autogenerate' support
-from solace_agent_mesh.gateway.http_sse.infrastructure.persistence.models import Base
+from solace_agent_mesh.gateway.http_sse.repository import Base
 
 target_metadata = Base.metadata
 

solace_agent_mesh/gateway/http_sse/component.py

@@ -24,7 +24,6 @@ from ...gateway.base.component import BaseGatewayComponent
 from ...gateway.http_sse.session_manager import SessionManager
 from ...gateway.http_sse.sse_manager import SSEManager
 from .components import VisualizationForwarderComponent
-from .infrastructure.persistence_service import PersistenceService
 
 try:
     from google.adk.artifacts import BaseArtifactService
@@ -131,10 +130,10 @@ class WebUIBackendComponent(BaseGatewayComponent):
                     f"{self.log_identifier} Session service type is 'sql' but no database_url provided. "
                     "Please provide a database_url in the session_service configuration or use type 'memory'."
                 )
-            self.persistence_service = PersistenceService(database_url)
+            self.database_url = database_url
         else:
             # Memory storage or no explicit configuration - no persistence service needed
-            self.persistence_service = None
+            self.database_url = None
 
         component_config = self.get_config("component_config", {})
         app_config = component_config.get("app_config", {})
@@ -142,7 +141,6 @@ class WebUIBackendComponent(BaseGatewayComponent):
         self.session_manager = SessionManager(
             secret_key=self.session_secret_key,
             app_config=app_config,
-            persistence_service=self.persistence_service,
         )
 
         self.fastapi_app: FastAPI | None = None
@@ -158,6 +156,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
+        )
 
         log.info("%s Web UI Backend Component initialized.", self.log_identifier)
 
@@ -881,7 +887,7 @@ class WebUIBackendComponent(BaseGatewayComponent):
 
             self.fastapi_app = fastapi_app_instance
 
-            setup_dependencies(self, self.persistence_service)
+            setup_dependencies(self, self.database_url)
 
             port = (
                 self.fastapi_https_port
@@ -991,7 +997,16 @@ class WebUIBackendComponent(BaseGatewayComponent):
         This method can be called from FastAPI handlers (via dependency injection).
         It's thread-safe as it uses the SAC App instance.
         """
-        super().publish_a2a_message(topic, payload, user_properties)
+        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] 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}")
+        except Exception as e:
+            log.error(f"[publish_a2a] Exception in publish_a2a: {e}", exc_info=True)
+            raise
 
     def _cleanup_visualization_locks(self):
         """Remove locks for closed event loops to prevent memory leaks."""
@@ -1063,6 +1078,16 @@ class WebUIBackendComponent(BaseGatewayComponent):
 
         # --- Phase 1: Parse the payload to extract core info ---
         try:
+            # Handle SAM Events (system events)
+            event_type = payload.get("event_type")
+            if event_type:
+                details["direction"] = "system_event"
+                details["debug_type"] = "sam_event"
+                details["payload_summary"]["method"] = event_type
+                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)
@@ -1613,15 +1638,12 @@ class WebUIBackendComponent(BaseGatewayComponent):
             )
 
             # Store final agent response in persistence layer if available
-            if hasattr(self, "persistence_service") and self.persistence_service:
+            if hasattr(self, "database_url") and self.database_url:
                 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")
 
-                    # Extract message content from the task status
                     message_text = ""
                     if task_data.status and task_data.status.message:
                         parts = a2a.get_parts_from_message(task_data.status.message)
@@ -1631,30 +1653,19 @@ class WebUIBackendComponent(BaseGatewayComponent):
                                     message_text += "\n"
                                 message_text += part.text
 
-                    log.info(
-                        "%s Final agent response storage debug - session_id: %s, user_id: %s, message_text: '%s', parts_count: %s",
-                        log_id_prefix,
-                        session_id,
-                        user_id,
-                        message_text[:100] if message_text else None,
-                        len(a2a.get_parts_from_message(task_data.status.message))
-                        if task_data.status and task_data.status.message
-                        else 0,
-                    )
-
                     if message_text and session_id and user_id:
-                        from .dependencies import get_session_service
-                        from .shared.enums import SenderType
-
-                        session_service = get_session_service(self)
-                        session_service.add_message_to_session(
-                            session_id=session_id,
-                            user_id=user_id,
-                            message=message_text,
-                            sender_type=SenderType.AGENT,
-                            sender_name=agent_name,
-                            agent_id=agent_name,
-                        )
+                        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):
+                            session_service.add_message_to_session(
+                                session_id=session_id,
+                                user_id=user_id,
+                                message=message_text,
+                                sender_type=SenderType.AGENT,
+                                sender_name=agent_name,
+                                agent_id=agent_name,
+                            )
                         log.info(
                             "%s Final agent response stored in session %s",
                             log_id_prefix,
@@ -1666,7 +1677,6 @@ class WebUIBackendComponent(BaseGatewayComponent):
                         log_id_prefix,
                         storage_error,
                     )
-                    # Don't fail the SSE send if storage fails
 
         except Exception as e:
             log.exception(