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

solace_agent_mesh/gateway/http_sse/services/{agent_service.py → agent_card_service.py}

@@ -11,14 +11,14 @@ from ....common.agent_registry import AgentRegistry
 from a2a.types import AgentCard
 
 
-class AgentService:
+class AgentCardService:
     """
-    Provides methods for accessing information about discovered A2A agents.
+    Provides methods for accessing information about discovered A2A agents' cards.
     """
 
     def __init__(self, agent_registry: AgentRegistry):
         """
-        Initializes the AgentService.
+        Initializes the AgentCardService.
 
         Args:
             agent_registry: An instance of the shared AgentRegistry.
@@ -26,33 +26,33 @@ class AgentService:
         if not isinstance(agent_registry, AgentRegistry):
             raise TypeError("agent_registry must be an instance of AgentRegistry")
         self._agent_registry = agent_registry
-        log.info("[AgentService] Initialized.")
+        log.info("[AgentCardService] Initialized.")
 
-    def get_all_agents(self) -> List[AgentCard]:
+    def get_all_agent_cards(self) -> List[AgentCard]:
         """
         Retrieves all currently discovered and registered agent cards.
 
         Returns:
             A list of AgentCard objects.
         """
-        log_prefix = "[AgentService.get_all_agents] "
-        log.info("%sRetrieving all agents.", log_prefix)
+        log_prefix = "[AgentCardService.get_all_agent_cards] "
+        log.info("%sRetrieving all agent cards.", log_prefix)
         agent_names = self._agent_registry.get_agent_names()
-        agents = []
+        agent_cards = []
         for name in agent_names:
-            agent = self._agent_registry.get_agent(name)
-            if agent:
-                agents.append(agent)
+            agent_card = self._agent_registry.get_agent(name)
+            if agent_card:
+                agent_cards.append(agent_card)
             else:
                 log.warning(
                     "%sAgent name '%s' found in list but not retrievable from registry.",
                     log_prefix,
                     name,
                 )
-        log.info("%sRetrieved %d agent cards.", log_prefix, len(agents))
-        return agents
+        log.info("%sRetrieved %d agent cards.", log_prefix, len(agent_cards))
+        return agent_cards
 
-    def get_agent_by_name(self, agent_name: str) -> Optional[AgentCard]:
+    def get_agent_card_by_name(self, agent_name: str) -> Optional[AgentCard]:
         """
         Retrieves a specific agent card by its name.
 
@@ -62,8 +62,8 @@ class AgentService:
         Returns:
             The AgentCard object if found, otherwise None.
         """
-        log_prefix = "[AgentService.get_agent_by_name] "
-        log.info("%sRetrieving agent by name '%s'.", log_prefix, agent_name)
-        agent = self._agent_registry.get_agent(agent_name)
-        log.info("%sFound: %s", log_prefix, agent is not None)
-        return agent
+        log_prefix = "[AgentCardService.get_agent_card_by_name] "
+        log.info("%sRetrieving agent card by name '%s'.", log_prefix, agent_name)
+        agent_card = self._agent_registry.get_agent(agent_name)
+        log.info("%sFound: %s", log_prefix, agent_card is not None)
+        return agent_card

solace_agent_mesh/gateway/http_sse/services/session_service.py

@@ -0,0 +1,245 @@
+import uuid
+from datetime import datetime, timezone
+from typing import TYPE_CHECKING
+
+from solace_ai_connector.common.log import log
+
+from ..repository import (
+    IMessageRepository,
+    ISessionRepository,
+    Message,
+    Session,
+    SessionHistory,
+)
+from ..shared.enums import MessageType, SenderType
+from ..shared.types import PaginationInfo, SessionId, UserId
+
+if TYPE_CHECKING:
+    from ..component import WebUIBackendComponent
+
+
+class SessionService:
+    def __init__(
+        self,
+        session_repository: ISessionRepository,
+        message_repository: IMessageRepository,
+        component: "WebUIBackendComponent" = None,
+    ):
+        self.session_repository = session_repository
+        self.message_repository = message_repository
+        self.component = component
+
+    def get_user_sessions(
+        self, user_id: UserId, pagination: PaginationInfo | None = None
+    ) -> list[Session]:
+        if not user_id or user_id.strip() == "":
+            raise ValueError("User ID cannot be empty")
+
+        return self.session_repository.find_by_user(user_id, pagination)
+
+    def get_session_details(
+        self, session_id: SessionId, user_id: UserId
+    ) -> Session | None:
+        if not self._is_valid_session_id(session_id):
+            return None
+
+        return self.session_repository.find_user_session(session_id, user_id)
+
+    def get_session_history(
+        self,
+        session_id: SessionId,
+        user_id: UserId,
+        pagination: PaginationInfo | None = None,
+    ) -> SessionHistory | None:
+        if not self._is_valid_session_id(session_id):
+            return None
+
+        result = self.session_repository.find_user_session_with_messages(
+            session_id, user_id, pagination
+        )
+        if not result:
+            return None
+
+        session, messages = result
+        return SessionHistory(
+            session=session,
+            messages=messages,
+            total_message_count=len(messages),
+        )
+
+    def create_session(
+        self,
+        user_id: UserId,
+        name: str | None = None,
+        agent_id: str | None = None,
+        session_id: str | None = None,
+    ) -> Session:
+        if not user_id or user_id.strip() == "":
+            raise ValueError("User ID cannot be empty")
+
+        if not session_id:
+            session_id = str(uuid.uuid4())
+
+        # Leave name as None/empty - frontend will generate display name if needed
+
+        now = datetime.now(timezone.utc)
+        session = Session(
+            id=session_id,
+            user_id=user_id,
+            name=name,
+            agent_id=agent_id,
+            created_at=now,
+            updated_at=now,
+            last_activity=now,
+        )
+
+        created_session = self.session_repository.save(session)
+        log.info("Created new session %s for user %s", created_session.id, user_id)
+
+        return created_session
+
+    def update_session_name(
+        self, session_id: SessionId, user_id: UserId, name: str
+    ) -> Session | None:
+        if not self._is_valid_session_id(session_id):
+            raise ValueError("Invalid session ID")
+
+        if not name or len(name.strip()) == 0:
+            raise ValueError("Session name cannot be empty")
+
+        if len(name.strip()) > 255:
+            raise ValueError("Session name cannot exceed 255 characters")
+
+        session = self.session_repository.find_user_session(session_id, user_id)
+        if not session:
+            return None
+
+        session.update_name(name)
+        updated_session = self.session_repository.save(session)
+
+        log.info("Updated session %s name to '%s'", session_id, name)
+        return updated_session
+
+    def delete_session_with_notifications(
+        self, session_id: SessionId, user_id: UserId
+    ) -> bool:
+        if not self._is_valid_session_id(session_id):
+            raise ValueError("Invalid session ID")
+
+        session = self.session_repository.find_user_session(session_id, user_id)
+        if not session:
+            log.warning(
+                "Attempted to delete non-existent session %s by user %s",
+                session_id,
+                user_id,
+            )
+            return False
+
+        agent_id = session.agent_id
+
+        if not session.can_be_deleted_by_user(user_id):
+            log.warning(
+                "User %s not authorized to delete session %s", user_id, session_id
+            )
+            return False
+
+        deleted = self.session_repository.delete(session_id, user_id)
+        if not deleted:
+            return False
+
+        log.info("Session %s deleted successfully by user %s", session_id, user_id)
+
+        if agent_id and self.component:
+            self._notify_agent_of_session_deletion(session_id, user_id, agent_id)
+
+        return True
+
+    def add_message_to_session(
+        self,
+        session_id: SessionId,
+        user_id: UserId,
+        message: str,
+        sender_type: SenderType,
+        sender_name: str,
+        agent_id: str | None = None,
+        message_type: MessageType = MessageType.TEXT,
+    ) -> Message:
+        if not self._is_valid_session_id(session_id):
+            raise ValueError("Invalid session ID")
+
+        if not message or message.strip() == "":
+            raise ValueError("Message cannot be empty")
+
+        session = self.session_repository.find_user_session(session_id, user_id)
+        if not session:
+            session = self.create_session(
+                user_id=user_id,
+                agent_id=agent_id,
+                session_id=session_id,
+            )
+
+        message_entity = Message(
+            id=str(uuid.uuid4()),
+            session_id=session_id,
+            message=message.strip(),
+            sender_type=sender_type,
+            sender_name=sender_name,
+            message_type=message_type,
+            created_at=datetime.now(timezone.utc),
+        )
+
+        saved_message = self.message_repository.save(message_entity)
+
+        session.mark_activity()
+        self.session_repository.save(session)
+
+        log.info("Added message to session %s from %s", session_id, sender_name)
+        return saved_message
+
+    def _is_valid_session_id(self, session_id: SessionId) -> bool:
+        return (
+            session_id is not None
+            and session_id.strip() != ""
+            and session_id not in ["null", "undefined"]
+        )
+
+    def _notify_agent_of_session_deletion(
+        self, session_id: SessionId, user_id: UserId, agent_id: str
+    ) -> None:
+        try:
+            log.info(
+                "Publishing session deletion event for session %s (agent %s, user %s)",
+                session_id,
+                agent_id,
+                user_id,
+            )
+
+            if hasattr(self.component, "sam_events"):
+                success = self.component.sam_events.publish_session_deleted(
+                    session_id=session_id,
+                    user_id=user_id,
+                    agent_id=agent_id,
+                    gateway_id=self.component.gateway_id,
+                )
+
+                if success:
+                    log.info(
+                        "Successfully published session deletion event for session %s",
+                        session_id,
+                    )
+                else:
+                    log.warning(
+                        "Failed to publish session deletion event for session %s",
+                        session_id,
+                    )
+            else:
+                log.warning(
+                    "SAM Events not available for session deletion notification"
+                )
+
+        except Exception as e:
+            log.warning(
+                "Failed to publish session deletion event to agent %s: %s",
+                agent_id,
+                e,
+            )

solace_agent_mesh/gateway/http_sse/session_manager.py

@@ -9,7 +9,6 @@ from typing import Any
 from solace_ai_connector.common.log import log
 from starlette.requests import Request
 
-from .infrastructure.persistence_service import PersistenceService
 
 SESSION_KEY_CLIENT_ID = "a2a_client_id"
 SESSION_KEY_SESSION_ID = "a2a_session_id"
@@ -28,14 +27,12 @@ class SessionManager:
         self,
         secret_key: str,
         app_config: dict[str, Any],
-        persistence_service: "PersistenceService",
     ):
         if not secret_key:
             raise ValueError("Session secret key cannot be empty.")
         self.secret_key = secret_key
         self.force_user_identity = app_config.get("force_user_identity")
         self.use_authorization = app_config.get("frontend_use_authorization", False)
-        self.persistence_service = persistence_service
         self._temp_code_cache = {}
         log.info("[SessionManager] Initialized.")
         if self.force_user_identity:

solace_agent_mesh/gateway/http_sse/shared/enums.py

@@ -21,11 +21,6 @@ class TaskStatus(str, Enum):
     CANCELLED = "cancelled"
 
 
-class SessionStatus(str, Enum):
-    """Session status."""
-    ACTIVE = "active"
-    INACTIVE = "inactive"
-    ARCHIVED = "archived"
 
 
 class MessageType(str, Enum):

{solace_agent_mesh-1.3.0.dist-info → solace_agent_mesh-1.3.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: solace-agent-mesh
-Version: 1.3.0
+Version: 1.3.2
 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