solace-agent-mesh 1.5.0__py3-none-any.whl → 1.6.0__py3-none-any.whl

solace_agent_mesh/gateway/base/app.py

@@ -2,11 +2,11 @@
 Base App class for Gateway implementations in the Solace AI Connector.
 """
 
+import logging
 import uuid
 from abc import abstractmethod
 from typing import Any, Dict, List, Type
 
-from solace_ai_connector.common.log import log
 from solace_ai_connector.common.utils import deep_merge
 from solace_ai_connector.flow.app import App
 from solace_ai_connector.components.component_base import ComponentBase
@@ -17,6 +17,7 @@ from ...common.a2a import (
     get_gateway_status_subscription_topic,
 )
 
+log = logging.getLogger(__name__)
 
 class BaseGatewayComponent(ComponentBase):
     pass
@@ -271,7 +272,7 @@ class BaseGatewayApp(App):
         broker_config["queue_name"] = (
             f"{self.namespace.strip('/')}/q/gdk/gateway/{self.gateway_id}"
         )
-        broker_config["temporary_queue"] = True
+        broker_config["temporary_queue"] = modified_app_info.get("broker", {}).get("temporary_queue", True)
         log.debug(
             "Injected broker settings for gateway '%s': %s",
             self.gateway_id,

solace_agent_mesh/gateway/base/component.py

@@ -2,6 +2,7 @@
 Base Component class for Gateway implementations in the Solace AI Connector.
 """
 
+import logging
 import asyncio
 import queue
 import base64
@@ -9,7 +10,6 @@ import uuid
 from datetime import datetime, timezone
 from typing import Any, Dict, Optional, List, Tuple, Union
 
-from solace_ai_connector.common.log import log
 from google.adk.artifacts import BaseArtifactService
 
 from ...common.agent_registry import AgentRegistry
@@ -53,6 +53,8 @@ from abc import abstractmethod
 
 from ...common.middleware.registry import MiddlewareRegistry
 
+log = logging.getLogger(__name__)
+
 info = {
     "class_name": "BaseGatewayComponent",
     "description": (
@@ -280,6 +282,9 @@ class BaseGatewayComponent(SamComponentBase):
             "user_id_for_a2a", user_identity.get("id")
         )
 
+        system_purpose = self.get_config("system_purpose", "")
+        response_format = self.get_config("response_format", "")
+
         if not a2a_session_id:
             a2a_session_id = f"gdk-session-{uuid.uuid4().hex}"
             log.warning(
@@ -289,7 +294,11 @@ class BaseGatewayComponent(SamComponentBase):
             )
             external_request_context["a2a_session_id"] = a2a_session_id
 
-        a2a_metadata = {"agent_name": target_agent_name}
+        a2a_metadata = {
+            "agent_name": target_agent_name,
+            "system_purpose": system_purpose,
+            "response_format": response_format,
+        }
         invoked_artifacts = external_request_context.get("invoked_with_artifacts")
         if invoked_artifacts:
             a2a_metadata["invoked_with_artifacts"] = invoked_artifacts

solace_agent_mesh/gateway/base/task_context.py

@@ -2,10 +2,11 @@
 Manages context for tasks being processed by a gateway.
 """
 
+import logging
 import threading
 from typing import Dict, Optional, Any
 
-from solace_ai_connector.common.log import log
+log = logging.getLogger(__name__)
 
 
 class TaskContextManager:

solace_agent_mesh/gateway/http_sse/alembic/versions/20251015_add_session_performance_indexes.py

@@ -0,0 +1,70 @@
+"""add performance indexes for query optimization
+
+Revision ID: 20251015_session_idx
+Revises: 98882922fa59
+Create Date: 2025-10-15
+
+"""
+
+from collections.abc import Sequence
+
+import sqlalchemy as sa
+from alembic import op
+
+revision: str = "20251015_session_idx"
+down_revision: str | Sequence[str] | None = "98882922fa59"
+branch_labels: str | Sequence[str] | None = None
+depends_on: str | Sequence[str] | None = None
+
+
+def upgrade() -> None:
+    """Add composite indexes for optimal query performance."""
+
+    op.create_index("ix_sessions_user_id", "sessions", ["user_id"], unique=False)
+
+    op.create_index(
+        "ix_sessions_user_updated",
+        "sessions",
+        ["user_id", sa.text("updated_time DESC")],
+        unique=False,
+    )
+
+    op.create_index(
+        "ix_chat_tasks_session_user_created",
+        "chat_tasks",
+        ["session_id", "user_id", "created_time"],
+        unique=False,
+    )
+
+    op.create_index(
+        "ix_tasks_user_start_time",
+        "tasks",
+        ["user_id", sa.text("start_time DESC")],
+        unique=False,
+    )
+
+    op.create_index(
+        "ix_task_events_task_created",
+        "task_events",
+        ["task_id", "created_time"],
+        unique=False,
+    )
+
+    op.drop_index("ix_tasks_initial_request_text", table_name="tasks")
+
+
+def downgrade() -> None:
+    """Remove performance indexes."""
+
+    op.create_index(
+        op.f("ix_tasks_initial_request_text"),
+        "tasks",
+        ["initial_request_text"],
+        unique=False,
+    )
+
+    op.drop_index("ix_task_events_task_created", table_name="task_events")
+    op.drop_index("ix_tasks_user_start_time", table_name="tasks")
+    op.drop_index("ix_chat_tasks_session_user_created", table_name="chat_tasks")
+    op.drop_index("ix_sessions_user_updated", table_name="sessions")
+    op.drop_index("ix_sessions_user_id", table_name="sessions")

solace_agent_mesh/gateway/http_sse/app.py

@@ -3,14 +3,15 @@ Custom Solace AI Connector App class for the Web UI Backend.
 Defines configuration schema and programmatically creates the WebUIBackendComponent.
 """
 
+import logging
 from typing import Any, Dict, List
-from solace_ai_connector.common.log import log
 
 from ...gateway.http_sse.component import WebUIBackendComponent
 
 from ...gateway.base.app import BaseGatewayApp
 from ...gateway.base.component import BaseGatewayComponent
 
+log = logging.getLogger(__name__)
 
 info = {
     "class_name": "WebUIBackendApp",

solace_agent_mesh/gateway/http_sse/component.py

@@ -2,6 +2,7 @@
 Custom Solace AI Connector Component to host the FastAPI backend for the Web UI.
 """
 
+import logging
 import asyncio
 import json
 import queue
@@ -14,7 +15,7 @@ from typing import Any
 import uvicorn
 from fastapi import FastAPI, UploadFile
 from fastapi import Request as FastAPIRequest
-from solace_ai_connector.common.log import log
+
 from solace_ai_connector.components.inputs_outputs.broker_input import BrokerInput
 from solace_ai_connector.flow.app import App as SACApp
 from solace_ai_connector.common.event import Event, EventType
@@ -31,6 +32,8 @@ from .services.feedback_service import FeedbackService
 from .services.task_logger_service import TaskLoggerService
 from . import dependencies
 
+log = logging.getLogger(__name__)
+
 try:
     from google.adk.artifacts import BaseArtifactService
 except ImportError:
@@ -143,6 +146,27 @@ class WebUIBackendComponent(BaseGatewayComponent):
             timer_id=self._sse_cleanup_timer_id,
             interval_ms=cleanup_interval_sec * 1000,
         )
+        
+        # Set up health check timer for agent registry
+        from ...common.constants import HEALTH_CHECK_INTERVAL_SECONDS
+        self.health_check_timer_id = f"agent_health_check_{self.gateway_id}"
+        health_check_interval_seconds = self.get_config("agent_health_check_interval_seconds", HEALTH_CHECK_INTERVAL_SECONDS)
+        if health_check_interval_seconds > 0:
+            log.info(
+                "%s Scheduling agent health check every %d seconds.",
+                self.log_identifier,
+                health_check_interval_seconds,
+            )
+            self.add_timer(
+                delay_ms=health_check_interval_seconds * 1000,
+                timer_id=self.health_check_timer_id,
+                interval_ms=health_check_interval_seconds * 1000,
+            )
+        else:
+            log.warning(
+                "%s Agent health check interval not configured or invalid, health checks will not run periodically.",
+                self.log_identifier,
+            )
 
         session_config = self._resolve_session_config()
         if session_config.get("type") == "sql":
@@ -262,6 +286,10 @@ class WebUIBackendComponent(BaseGatewayComponent):
                 log.debug("%s SSE buffer cleanup timer triggered.", self.log_identifier)
                 self.sse_event_buffer.cleanup_stale_buffers()
                 return
+            elif event.data.get("timer_id") == self.health_check_timer_id:
+                log.debug("%s Agent health check timer triggered.", self.log_identifier)
+                self._check_agent_health()
+                return
             
             if timer_id == self._data_retention_timer_id:
                 log.debug("%s Data retention cleanup timer triggered.", self.log_identifier)
@@ -351,7 +379,7 @@ class WebUIBackendComponent(BaseGatewayComponent):
                     ),
                     "retry_interval": main_broker_config.get("retry_interval"),
                     "retry_count": main_broker_config.get("retry_count"),
-                    "temporary_queue": True,
+                    "temporary_queue": main_broker_config.get("temporary_queue", True),
                 },
             }
 
@@ -483,7 +511,7 @@ class WebUIBackendComponent(BaseGatewayComponent):
                     ),
                     "retry_interval": main_broker_config.get("retry_interval"),
                     "retry_count": main_broker_config.get("retry_count"),
-                    "temporary_queue": True,
+                    "temporary_queue": main_broker_config.get("temporary_queue", True),
                 },
             }
 
@@ -1401,6 +1429,7 @@ class WebUIBackendComponent(BaseGatewayComponent):
             self.data_retention_service = None
             log.info("%s Data retention service cleaned up.", self.log_identifier)
         
+        self.cancel_timer(self.health_check_timer_id)
         log.info("%s Cleaning up visualization resources...", self.log_identifier)
         if self._visualization_message_queue:
             self._visualization_message_queue.put(None)
@@ -1726,6 +1755,76 @@ class WebUIBackendComponent(BaseGatewayComponent):
 
     def get_agent_registry(self) -> AgentRegistry:
         return self.agent_registry
+        
+    def _check_agent_health(self):
+        """
+        Checks the health of peer agents and de-registers unresponsive ones.
+        This is called periodically by the health check timer.
+        Uses TTL-based expiration to determine if an agent is unresponsive.
+        """
+            
+        log.debug("%s Performing agent health check...", self.log_identifier)
+        
+        # Get TTL from configuration or use default from constants
+        from ...common.constants import HEALTH_CHECK_TTL_SECONDS, HEALTH_CHECK_INTERVAL_SECONDS
+        ttl_seconds = self.get_config("agent_health_check_ttl_seconds", HEALTH_CHECK_TTL_SECONDS)
+        health_check_interval = self.get_config("agent_health_check_interval_seconds", HEALTH_CHECK_INTERVAL_SECONDS)
+
+        log.debug(
+            "%s Health check configuration: interval=%d seconds, TTL=%d seconds",
+            self.log_identifier,
+            health_check_interval,
+            ttl_seconds
+        )
+        
+        # Validate configuration values
+        if ttl_seconds <= 0 or health_check_interval <= 0 or ttl_seconds < health_check_interval:
+            log.error(
+                "%s agent_health_check_ttl_seconds (%d) and agent_health_check_interval_seconds (%d) must be positive and TTL must be greater than interval.",
+                self.log_identifier,
+                ttl_seconds,
+                health_check_interval
+            )
+            raise ValueError(f"Invalid health check configuration. agent_health_check_ttl_seconds ({ttl_seconds}) and agent_health_check_interval_seconds ({health_check_interval}) must be positive and TTL must be greater than interval.")
+        
+        # Get all agent names from the registry
+        agent_names = self.agent_registry.get_agent_names()
+        total_agents = len(agent_names)
+        agents_to_deregister = []
+        
+        log.debug("%s Checking health of %d peer agents", self.log_identifier, total_agents)
+        
+        for agent_name in agent_names:
+            # Check if the agent's TTL has expired
+            is_expired, time_since_last_seen = self.agent_registry.check_ttl_expired(agent_name, ttl_seconds)
+            
+            if is_expired:
+                log.warning(
+                    "%s Agent '%s' TTL has expired. De-registering. Time since last seen: %d seconds (TTL: %d seconds)",
+                    self.log_identifier,
+                    agent_name,
+                    time_since_last_seen,
+                    ttl_seconds
+                )
+                agents_to_deregister.append(agent_name)
+        
+        # De-register unresponsive agents
+        for agent_name in agents_to_deregister:
+            self._deregister_agent(agent_name)
+            
+        log.info(
+            "%s Agent health check completed. Total agents: %d, De-registered: %d",
+            self.log_identifier,
+            total_agents,
+            len(agents_to_deregister)
+        )
+        
+    def _deregister_agent(self, agent_name: str):
+        """
+        De-registers an agent from the registry and publishes a de-registration event.
+        """
+        # Remove from registry
+        self.agent_registry.remove_agent(agent_name)
 
     def get_sse_manager(self) -> SSEManager:
         return self.sse_manager

solace_agent_mesh/gateway/http_sse/components/task_logger_forwarder.py

@@ -2,13 +2,14 @@
 SAC Component to forward messages from an internal BrokerInput
 to the WebUIBackendComponent's internal queue for task logging.
 """
-
+import logging
 import queue
 from typing import Any, Dict
 
 from solace_ai_connector.components.component_base import ComponentBase
 from solace_ai_connector.common.message import Message as SolaceMessage
-from solace_ai_connector.common.log import log
+
+log = logging.getLogger(__name__)
 
 info = {
     "class_name": "TaskLoggerForwarderComponent",

solace_agent_mesh/gateway/http_sse/components/visualization_forwarder_component.py

@@ -3,12 +3,14 @@ SAC Component to forward messages from an internal BrokerInput
 to the WebUIBackendComponent's internal queue for visualization.
 """
 
+import logging
 import queue
 from typing import Any, Dict
 
 from solace_ai_connector.components.component_base import ComponentBase
 from solace_ai_connector.common.message import Message as SolaceMessage
-from solace_ai_connector.common.log import log
+
+log = logging.getLogger(__name__)
 
 info = {
     "class_name": "VisualizationForwarderComponent",

solace_agent_mesh/gateway/http_sse/dependencies.py

@@ -3,12 +3,12 @@ Defines FastAPI dependency injectors to access shared resources
 managed by the WebUIBackendComponent.
 """
 
+import logging
 from collections.abc import Callable, Generator
 from contextlib import contextmanager
 from typing import TYPE_CHECKING, Any
 
 from fastapi import Depends, HTTPException, Request, status
-from solace_ai_connector.common.log import log
 from sqlalchemy import create_engine
 from sqlalchemy.orm import Session, sessionmaker
 
@@ -30,6 +30,8 @@ from .repository.interfaces import ITaskRepository
 from .repository.task_repository import TaskRepository
 from .services.session_service import SessionService
 
+log = logging.getLogger(__name__)
+
 try:
     from google.adk.artifacts import BaseArtifactService
 except ImportError:
@@ -241,10 +243,10 @@ def get_people_service(
     return PeopleService(identity_service=identity_service)
 
 
-def get_task_repository(db: Session = Depends(get_db)) -> ITaskRepository:
+def get_task_repository() -> ITaskRepository:
     """FastAPI dependency to get an instance of TaskRepository."""
     log.debug("[Dependencies] get_task_repository called")
-    return TaskRepository(db)
+    return TaskRepository()
 
 
 def get_feedback_service(
@@ -523,9 +525,9 @@ def get_session_validator(
             try:
                 db = SessionLocal()
                 try:
-                    session_repository = SessionRepository(db)
+                    session_repository = SessionRepository()
                     session_domain = session_repository.find_user_session(
-                        session_id, user_id
+                        db, session_id, user_id
                     )
                     return session_domain is not None
                 finally:

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
 
@@ -38,6 +38,8 @@ 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
@@ -95,7 +97,8 @@ async def _get_user_info(
 
 def _extract_user_identifier(user_info: dict) -> str:
     user_identifier = (
-        user_info.get("sub")
+        user_info.get("user_id") # internal /user_info endpoint format maps identifier to user_id
+        or user_info.get("sub")
         or user_info.get("client_id")
         or user_info.get("username")
         or user_info.get("oid")

solace_agent_mesh/gateway/http_sse/repository/chat_task_repository.py

@@ -16,12 +16,9 @@ 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:
+    def save(self, session: DBSession, task: ChatTask) -> ChatTask:
         """Save or update a chat task (upsert)."""
-        existing = self.db.query(ChatTaskModel).filter(
+        existing = session.query(ChatTaskModel).filter(
             ChatTaskModel.id == task.id
         ).first()
 
@@ -43,12 +40,12 @@ class ChatTaskRepository(IChatTaskRepository):
                 created_time=task.created_time,
                 updated_time=task.updated_time
             )
-            self.db.add(model)
+            session.add(model)
 
-        self.db.commit()
+        session.flush()
 
         # Reload to get updated values
-        model = self.db.query(ChatTaskModel).filter(
+        model = session.query(ChatTaskModel).filter(
             ChatTaskModel.id == task.id
         ).first()
 
@@ -56,11 +53,12 @@ class ChatTaskRepository(IChatTaskRepository):
 
     def find_by_session(
         self,
+        session: DBSession,
         session_id: SessionId,
         user_id: UserId
     ) -> List[ChatTask]:
         """Find all tasks for a session."""
-        models = self.db.query(ChatTaskModel).filter(
+        models = session.query(ChatTaskModel).filter(
             ChatTaskModel.session_id == session_id,
             ChatTaskModel.user_id == user_id
         ).order_by(ChatTaskModel.created_time.asc()).all()
@@ -69,23 +67,24 @@ class ChatTaskRepository(IChatTaskRepository):
 
     def find_by_id(
         self,
+        session: DBSession,
         task_id: str,
         user_id: UserId
     ) -> Optional[ChatTask]:
         """Find a specific task."""
-        model = self.db.query(ChatTaskModel).filter(
+        model = session.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:
+    def delete_by_session(self, session: DBSession, session_id: SessionId) -> bool:
         """Delete all tasks for a session."""
-        result = self.db.query(ChatTaskModel).filter(
+        result = session.query(ChatTaskModel).filter(
             ChatTaskModel.session_id == session_id
         ).delete()
-        self.db.commit()
+        session.flush()
         return result > 0
 
     def _model_to_entity(self, model: ChatTaskModel) -> ChatTask:

solace_agent_mesh/gateway/http_sse/repository/feedback_repository.py

@@ -12,10 +12,7 @@ from .models import FeedbackModel
 class FeedbackRepository(IFeedbackRepository):
     """SQLAlchemy implementation of feedback repository."""
 
-    def __init__(self, db: DBSession):
-        self.db = db
-
-    def save(self, feedback: Feedback) -> Feedback:
+    def save(self, session: DBSession, feedback: Feedback) -> Feedback:
         """Save feedback."""
         model = FeedbackModel(
             id=feedback.id,
@@ -26,12 +23,12 @@ class FeedbackRepository(IFeedbackRepository):
             comment=feedback.comment,
             created_time=feedback.created_time,
         )
-        self.db.add(model)
-        self.db.commit()
-        self.db.refresh(model)
+        session.add(model)
+        session.flush()
+        session.refresh(model)
         return self._model_to_entity(model)
 
-    def delete_feedback_older_than(self, cutoff_time_ms: int, batch_size: int) -> int:
+    def delete_feedback_older_than(self, session: DBSession, cutoff_time_ms: int, batch_size: int) -> int:
         """
         Delete feedback records older than the cutoff time.
         Uses batch deletion to avoid long-running transactions.
@@ -44,36 +41,36 @@ class FeedbackRepository(IFeedbackRepository):
             Total number of feedback records deleted
         """
         total_deleted = 0
-        
+
         while True:
             # Find a batch of feedback IDs to delete
             feedback_ids_to_delete = (
-                self.db.query(FeedbackModel.id)
+                session.query(FeedbackModel.id)
                 .filter(FeedbackModel.created_time < cutoff_time_ms)
                 .limit(batch_size)
                 .all()
             )
-            
+
             if not feedback_ids_to_delete:
                 break
-            
+
             # Extract IDs from the result tuples
             ids = [feedback_id[0] for feedback_id in feedback_ids_to_delete]
-            
+
             # Delete this batch
             deleted_count = (
-                self.db.query(FeedbackModel)
+                session.query(FeedbackModel)
                 .filter(FeedbackModel.id.in_(ids))
                 .delete(synchronize_session=False)
             )
-            
-            self.db.commit()
+
+            session.commit()
             total_deleted += deleted_count
-            
+
             # If we deleted fewer than batch_size, we're done
             if deleted_count < batch_size:
                 break
-        
+
         return total_deleted
 
     def _model_to_entity(self, model: FeedbackModel) -> Feedback: