solace-agent-mesh 1.5.1__py3-none-any.whl → 1.6.1__py3-none-any.whl

solace_agent_mesh/gateway/http_sse/routers/visualization.py

@@ -134,26 +134,32 @@ from sse_starlette.sse import EventSourceResponse
 
 def _generate_sse_url(fastapi_request: FastAPIRequest, stream_id: str) -> str:
     """
-    Generate SSE endpoint URL with proper scheme detection for reverse proxy scenarios.
+    Generate SSE endpoint URL with proper scheme and host detection for reverse proxy scenarios.
 
     Args:
         fastapi_request: The FastAPI request object
         stream_id: The stream ID for the SSE endpoint
 
     Returns:
-        Complete SSE URL with correct scheme (http/https)
+        Complete SSE URL with correct scheme (http/https) and host.
     """
+    base_url = fastapi_request.url_for(
+        "get_visualization_stream_events", stream_id=stream_id
+    )
+
     forwarded_proto = fastapi_request.headers.get("x-forwarded-proto")
-    if forwarded_proto and forwarded_proto.lower() == "https":
-        scheme = "https"
+    forwarded_host = fastapi_request.headers.get("x-forwarded-host")
+
+    if forwarded_proto and forwarded_host:
+        # In a reverse proxy environment like GitHub Codespaces, reconstruct the URL
+        # using the forwarded headers to ensure it's publicly accessible.
+        return str(base_url.replace(scheme=forwarded_proto, netloc=forwarded_host))
+    elif forwarded_proto:
+        # Handle cases with only a forwarded protocol (standard reverse proxy)
+        return str(base_url.replace(scheme=forwarded_proto))
     else:
-        scheme = fastapi_request.url.scheme
-
-    return str(
-        fastapi_request.url_for(
-            "get_visualization_stream_events", stream_id=stream_id
-        ).replace(scheme=scheme)
-    )
+        # Default behavior when not behind a reverse proxy
+        return str(base_url)
 
 
 def _translate_target_to_solace_topics(

solace_agent_mesh/gateway/http_sse/services/data_retention_service.py

@@ -188,8 +188,8 @@ class DataRetentionService:
 
         db = self.session_factory()
         try:
-            repo = TaskRepository(db)
-            total_deleted = repo.delete_tasks_older_than(cutoff_time_ms, batch_size)
+            repo = TaskRepository()
+            total_deleted = repo.delete_tasks_older_than(db, cutoff_time_ms, batch_size)
 
             if total_deleted == 0:
                 log.info(
@@ -241,8 +241,8 @@ class DataRetentionService:
 
         db = self.session_factory()
         try:
-            repo = FeedbackRepository(db)
-            total_deleted = repo.delete_feedback_older_than(cutoff_time_ms, batch_size)
+            repo = FeedbackRepository()
+            total_deleted = repo.delete_feedback_older_than(db, cutoff_time_ms, batch_size)
 
             if total_deleted == 0:
                 log.info(

solace_agent_mesh/gateway/http_sse/services/feedback_service.py

@@ -71,8 +71,8 @@ class FeedbackService:
 
                 db = self.session_factory()
                 try:
-                    repo = FeedbackRepository(db)
-                    repo.save(feedback_entity)
+                    repo = FeedbackRepository()
+                    repo.save(db, feedback_entity)
                     db.commit()
                     log.info(
                         "Feedback from user '%s' for task '%s' saved to database.",
@@ -131,14 +131,14 @@ class FeedbackService:
         db = self.session_factory()
         try:
             from ..repository.chat_task_repository import ChatTaskRepository
-            
-            task_repo = ChatTaskRepository(db)
-            task = task_repo.find_by_id(task_id, user_id)
-            
+
+            task_repo = ChatTaskRepository()
+            task = task_repo.find_by_id(db, task_id, user_id)
+
             if task:
                 # Update feedback in task metadata
                 task.add_feedback(feedback_type, feedback_text)
-                task_repo.save(task)
+                task_repo.save(db, task)
                 db.commit()
                 log.info(
                     "Updated task metadata with feedback for task '%s' by user '%s'",
@@ -187,45 +187,53 @@ class FeedbackService:
 
         if include_task_info == "summary":
             log.debug("%s Including task summary.", log_id)
-            task_summary_data = self.task_repo.find_by_id(payload.task_id)
-            if task_summary_data:
-                event_payload["task_summary"] = task_summary_data.model_dump()
+            db = self.session_factory()
+            try:
+                task_summary_data = self.task_repo.find_by_id(db, payload.task_id)
+                if task_summary_data:
+                    event_payload["task_summary"] = task_summary_data.model_dump()
+            finally:
+                db.close()
 
         elif include_task_info == "stim":
             log.debug("%s Including task stim data.", log_id)
-            task_with_events = self.task_repo.find_by_id_with_events(payload.task_id)
-            if task_with_events:
-                task, events = task_with_events
-                stim_data = create_stim_from_task_data(task, events)
-                event_payload["task_stim_data"] = stim_data
-
-                # Check payload size
-                max_size = config.get("max_payload_size_bytes", 9000000)
-                try:
-                    payload_bytes = json.dumps(event_payload).encode("utf-8")
-                    if len(payload_bytes) > max_size:
-                        log.warning(
-                            "%s Stim payload size (%d bytes) exceeds limit (%d bytes). Falling back to summary.",
-                            log_id,
-                            len(payload_bytes),
-                            max_size,
-                        )
-                        # Fallback to summary
-                        del event_payload["task_stim_data"]
-                        task_summary_data = self.task_repo.find_by_id(payload.task_id)
-                        if task_summary_data:
-                            event_payload[
-                                "task_summary"
-                            ] = task_summary_data.model_dump()
-                        event_payload["truncation_details"] = {
-                            "strategy": "fallback_to_summary",
-                            "reason": "payload_too_large",
-                        }
-                except Exception as e:
-                    log.error("%s Error checking payload size: %s", log_id, e)
-                    # If we can't check size, better to not send a potentially huge message
-                    if "task_stim_data" in event_payload:
-                        del event_payload["task_stim_data"]
+            db = self.session_factory()
+            try:
+                task_with_events = self.task_repo.find_by_id_with_events(db, payload.task_id)
+                if task_with_events:
+                    task, events = task_with_events
+                    stim_data = create_stim_from_task_data(task, events)
+                    event_payload["task_stim_data"] = stim_data
+
+                    # Check payload size
+                    max_size = config.get("max_payload_size_bytes", 9000000)
+                    try:
+                        payload_bytes = json.dumps(event_payload).encode("utf-8")
+                        if len(payload_bytes) > max_size:
+                            log.warning(
+                                "%s Stim payload size (%d bytes) exceeds limit (%d bytes). Falling back to summary.",
+                                log_id,
+                                len(payload_bytes),
+                                max_size,
+                            )
+                            # Fallback to summary
+                            del event_payload["task_stim_data"]
+                            task_summary_data = self.task_repo.find_by_id(db, payload.task_id)
+                            if task_summary_data:
+                                event_payload[
+                                    "task_summary"
+                                ] = task_summary_data.model_dump()
+                            event_payload["truncation_details"] = {
+                                "strategy": "fallback_to_summary",
+                                "reason": "payload_too_large",
+                            }
+                    except Exception as e:
+                        log.error("%s Error checking payload size: %s", log_id, e)
+                        # If we can't check size, better to not send a potentially huge message
+                        if "task_stim_data" in event_payload:
+                            del event_payload["task_stim_data"]
+            finally:
+                db.close()
 
         # Publish the event
         topic = config.get("topic", "sam/feedback/v1")

solace_agent_mesh/gateway/http_sse/services/session_service.py

@@ -31,7 +31,7 @@ class SessionService:
     def _get_repositories(self, db: DbSession):
         """Create session repository for the given database session."""
         from ..repository import SessionRepository
-        session_repository = SessionRepository(db)
+        session_repository = SessionRepository()
         return session_repository
 
     def is_persistence_enabled(self) -> bool:
@@ -57,8 +57,8 @@ class SessionService:
         session_repository = self._get_repositories(db)
 
         # Pass pagination params directly - repository will handle offset calculation
-        sessions = session_repository.find_by_user(user_id, pagination)
-        total_count = session_repository.count_by_user(user_id)
+        sessions = session_repository.find_by_user(db, user_id, pagination)
+        total_count = session_repository.count_by_user(db, user_id)
 
         return PaginatedResponse.create(sessions, total_count, pagination)
 
@@ -69,7 +69,7 @@ class SessionService:
             return None
 
         session_repository = self._get_repositories(db)
-        return session_repository.find_user_session(session_id, user_id)
+        return session_repository.find_user_session(db, session_id, user_id)
 
     def create_session(
         self,
@@ -100,7 +100,7 @@ class SessionService:
         )
 
         session_repository = self._get_repositories(db)
-        created_session = session_repository.save(session)
+        created_session = session_repository.save(db, session)
         log.info("Created new session %s for user %s", created_session.id, user_id)
 
         if not created_session:
@@ -121,12 +121,12 @@ class SessionService:
             raise ValueError("Session name cannot exceed 255 characters")
 
         session_repository = self._get_repositories(db)
-        session = session_repository.find_user_session(session_id, user_id)
+        session = session_repository.find_user_session(db, session_id, user_id)
         if not session:
             return None
 
         session.update_name(name)
-        updated_session = session_repository.save(session)
+        updated_session = session_repository.save(db, session)
 
         log.info("Updated session %s name to '%s'", session_id, name)
         return updated_session
@@ -138,7 +138,7 @@ class SessionService:
             raise ValueError("Invalid session ID")
 
         session_repository = self._get_repositories(db)
-        session = session_repository.find_user_session(session_id, user_id)
+        session = session_repository.find_user_session(db, session_id, user_id)
         if not session:
             log.warning(
                 "Attempted to delete non-existent session %s by user %s",
@@ -155,7 +155,7 @@ class SessionService:
             )
             return False
 
-        deleted = session_repository.delete(session_id, user_id)
+        deleted = session_repository.delete(db, session_id, user_id)
         if not deleted:
             return False
 
@@ -196,10 +196,10 @@ class SessionService:
         """
         # Validate session exists and belongs to user
         session_repository = self._get_repositories(db)
-        session = session_repository.find_user_session(session_id, user_id)
+        session = session_repository.find_user_session(db, session_id, user_id)
         if not session:
             raise ValueError(f"Session {session_id} not found for user {user_id}")
-        
+
         # Create task entity - pass strings directly
         task = ChatTask(
             id=task_id,
@@ -211,14 +211,14 @@ class SessionService:
             created_time=now_epoch_ms(),
             updated_time=None
         )
-        
+
         # Save via repository
-        task_repo = ChatTaskRepository(db)
-        saved_task = task_repo.save(task)
-        
+        task_repo = ChatTaskRepository()
+        saved_task = task_repo.save(db, task)
+
         # Update session activity
         session.mark_activity()
-        session_repository.save(session)
+        session_repository.save(db, session)
         
         log.info(f"Saved task {task_id} for session {session_id}")
         return saved_task
@@ -245,13 +245,13 @@ class SessionService:
         """
         # Validate session exists and belongs to user
         session_repository = self._get_repositories(db)
-        session = session_repository.find_user_session(session_id, user_id)
+        session = session_repository.find_user_session(db, session_id, user_id)
         if not session:
             raise ValueError(f"Session {session_id} not found for user {user_id}")
-        
+
         # Load tasks
-        task_repo = ChatTaskRepository(db)
-        return task_repo.find_by_session(session_id, user_id)
+        task_repo = ChatTaskRepository()
+        return task_repo.find_by_session(db, session_id, user_id)
 
     def get_session_messages_from_tasks(
         self,

solace_agent_mesh/gateway/http_sse/services/task_logger_service.py

@@ -71,7 +71,7 @@ class TaskLoggerService:
 
         db = self.session_factory()
         try:
-            repo = TaskRepository(db)
+            repo = TaskRepository()
 
             # Infer details from the parsed event
             direction, task_id, user_id = self._infer_event_details(
@@ -95,7 +95,7 @@ class TaskLoggerService:
             sanitized_payload = self._sanitize_payload(payload)
 
             # Check for existing task or create a new one
-            task = repo.find_by_id(task_id)
+            task = repo.find_by_id(db, task_id)
             if not task:
                 if direction == "request":
                     initial_text = self._extract_initial_text(parsed_event)
@@ -107,7 +107,7 @@ class TaskLoggerService:
                             initial_text[:1024] if initial_text else None
                         ),  # Truncate
                     )
-                    repo.save_task(new_task)
+                    repo.save_task(db, new_task)
                     log.info(
                         f"{self.log_identifier} Created new task record for ID: {task_id}"
                     )
@@ -120,7 +120,7 @@ class TaskLoggerService:
                         start_time=now_epoch_ms(),
                         initial_request_text="[Task started before logger was active]",
                     )
-                    repo.save_task(placeholder_task)
+                    repo.save_task(db, placeholder_task)
                     log.info(
                         f"{self.log_identifier} Created placeholder task record for ID: {task_id}"
                     )
@@ -135,12 +135,12 @@ class TaskLoggerService:
                 direction=direction,
                 payload=sanitized_payload,
             )
-            repo.save_event(task_event)
+            repo.save_event(db, task_event)
 
             # If it's a final event, update the master task record
             final_status = self._get_final_status(parsed_event)
             if final_status:
-                task_to_update = repo.find_by_id(task_id)
+                task_to_update = repo.find_by_id(db, task_id)
                 if task_to_update:
                     task_to_update.end_time = now_epoch_ms()
                     task_to_update.status = final_status
@@ -159,8 +159,8 @@ class TaskLoggerService:
                                 f"output={token_usage.get('total_output_tokens')}, "
                                 f"cached={token_usage.get('total_cached_input_tokens')}"
                             )
-                    
-                    repo.save_task(task_to_update)
+
+                    repo.save_task(db, task_to_update)
                     log.info(
                         f"{self.log_identifier} Finalized task record for ID: {task_id} with status: {final_status}"
                     )

solace_agent_mesh/gateway/http_sse/shared/base_repository.py

@@ -6,16 +6,15 @@ for database session management and transaction handling.
 """
 
 from abc import ABC, abstractmethod
-from typing import Dict, Any, List, Optional, TypeVar, Generic, Type
+from typing import Any, Generic, TypeVar
+
 from sqlalchemy.orm import Session
-from sqlalchemy.exc import NoResultFound
-from .exceptions import EntityNotFoundError, ValidationError
-from .types import PaginationInfo
 
+from .exceptions import EntityNotFoundError
 
-T = TypeVar('T')
-ModelType = TypeVar('ModelType')
-EntityType = TypeVar('EntityType')
+T = TypeVar("T")
+ModelType = TypeVar("ModelType")
+EntityType = TypeVar("EntityType")
 
 
 class BaseRepository(ABC, Generic[ModelType, EntityType]):
@@ -27,7 +26,7 @@ class BaseRepository(ABC, Generic[ModelType, EntityType]):
     transactions should be handled at the service/API layer.
     """
 
-    def __init__(self, model_class: Type[ModelType], entity_class: Type[EntityType]):
+    def __init__(self, model_class: type[ModelType], entity_class: type[EntityType]):
         """
         Initialize repository with model and entity classes.
 
@@ -44,7 +43,7 @@ class BaseRepository(ABC, Generic[ModelType, EntityType]):
         """Return the entity name for error messages."""
         pass
 
-    def create(self, session: Session, create_data: Dict[str, Any]) -> EntityType:
+    def create(self, session: Session, create_data: dict[str, Any]) -> EntityType:
         """
         Create a new entity.
 
@@ -83,16 +82,20 @@ class BaseRepository(ABC, Generic[ModelType, EntityType]):
         Raises:
             EntityNotFoundError: If entity not found
         """
-        model_instance = session.query(self.model_class).filter(
-            self.model_class.id == str(entity_id)
-        ).first()
+        model_instance = (
+            session.query(self.model_class)
+            .filter(self.model_class.id == str(entity_id))
+            .first()
+        )
 
         if not model_instance:
             raise EntityNotFoundError(self.entity_name, entity_id)
 
         return self.entity_class.model_validate(model_instance)
 
-    def get_all(self, session: Session, limit: Optional[int] = None, offset: Optional[int] = None) -> List[EntityType]:
+    def get_all(
+        self, session: Session, limit: int | None = None, offset: int | None = None
+    ) -> list[EntityType]:
         """
         Get all entities with optional pagination.
 
@@ -112,9 +115,13 @@ class BaseRepository(ABC, Generic[ModelType, EntityType]):
             query = query.limit(limit)
 
         model_instances = query.all()
-        return [self.entity_class.model_validate(instance) for instance in model_instances]
+        return [
+            self.entity_class.model_validate(instance) for instance in model_instances
+        ]
 
-    def update(self, session: Session, entity_id: Any, update_data: Dict[str, Any]) -> EntityType:
+    def update(
+        self, session: Session, entity_id: Any, update_data: dict[str, Any]
+    ) -> EntityType:
         """
         Update an entity.
 
@@ -129,9 +136,11 @@ class BaseRepository(ABC, Generic[ModelType, EntityType]):
         Raises:
             EntityNotFoundError: If entity not found
         """
-        model_instance = session.query(self.model_class).filter(
-            self.model_class.id == str(entity_id)
-        ).first()
+        model_instance = (
+            session.query(self.model_class)
+            .filter(self.model_class.id == str(entity_id))
+            .first()
+        )
 
         if not model_instance:
             raise EntityNotFoundError(self.entity_name, entity_id)
@@ -158,9 +167,11 @@ class BaseRepository(ABC, Generic[ModelType, EntityType]):
         Raises:
             EntityNotFoundError: If entity not found
         """
-        model_instance = session.query(self.model_class).filter(
-            self.model_class.id == str(entity_id)
-        ).first()
+        model_instance = (
+            session.query(self.model_class)
+            .filter(self.model_class.id == str(entity_id))
+            .first()
+        )
 
         if not model_instance:
             raise EntityNotFoundError(self.entity_name, entity_id)
@@ -179,9 +190,11 @@ class BaseRepository(ABC, Generic[ModelType, EntityType]):
         Returns:
             True if entity exists, False otherwise
         """
-        count = session.query(self.model_class).filter(
-            self.model_class.id == str(entity_id)
-        ).count()
+        count = (
+            session.query(self.model_class)
+            .filter(self.model_class.id == str(entity_id))
+            .count()
+        )
 
         return count > 0
 
@@ -200,52 +213,13 @@ class BaseRepository(ABC, Generic[ModelType, EntityType]):
 
 class PaginatedRepository(BaseRepository[ModelType, EntityType]):
     """
-    Base repository with enhanced pagination support.
-    """
-
-    def get_paginated(self, session: Session, page_number: int, page_size: int) -> tuple[List[EntityType], int]:
-        """
-        Get paginated results.
-
-        Args:
-            session: Database session
-            page_number: Page number (1-based)
-            page_size: Number of items per page
-
-        Returns:
-            Tuple of (entities, total_count)
-        """
-        offset = (page_number - 1) * page_size
+    Base repository with pagination support.
 
-        total_count = self.count(session)
-
-        entities = self.get_all(session, limit=page_size, offset=offset)
-
-        return entities, total_count
-
-    def get_paginated_with_info(self, session: Session, pagination: PaginationInfo) -> tuple[List[EntityType], PaginationInfo]:
-        """
-        Get paginated results with complete pagination info.
-
-        Args:
-            session: Database session
-            pagination: Pagination parameters
-
-        Returns:
-            Tuple of (entities, updated_pagination_info)
-        """
-        entities, total_count = self.get_paginated(session, pagination.page, pagination.page_size)
-
-        updated_pagination = PaginationInfo(
-            page=pagination.page,
-            page_size=pagination.page_size,
-            total_items=total_count,
-            total_pages=(total_count + pagination.page_size - 1) // pagination.page_size,
-            has_next=pagination.page * pagination.page_size < total_count,
-            has_previous=pagination.page > 1
-        )
+    Concrete repositories should implement their own pagination methods
+    that apply specific filters and ordering before pagination.
+    """
 
-        return entities, updated_pagination
+    pass
 
 
 class ValidationMixin:
@@ -253,7 +227,7 @@ class ValidationMixin:
     Mixin for repositories that need validation logic.
     """
 
-    def validate_create_data(self, create_data: Dict[str, Any]) -> None:
+    def validate_create_data(self, create_data: dict[str, Any]) -> None:
         """
         Validate data before creation.
 
@@ -265,7 +239,7 @@ class ValidationMixin:
         """
         pass
 
-    def validate_update_data(self, update_data: Dict[str, Any]) -> None:
+    def validate_update_data(self, update_data: dict[str, Any]) -> None:
         """
         Validate data before update.
 
@@ -275,4 +249,4 @@ class ValidationMixin:
         Raises:
             ValidationError: If validation fails
         """
-        pass
+        pass

solace_agent_mesh/gateway/http_sse/shared/types.py

@@ -35,24 +35,6 @@ class LegacyTimestamp(BaseModel):
     updated_at: datetime | None = None
 
 
-class PaginationParams(BaseModel):
-    """Pagination parameters for list requests."""
-
-    page: int
-    page_size: int
-
-
-class PaginationInfo(BaseModel):
-    """Pagination information for list responses."""
-
-    page: int
-    page_size: int
-    total_items: int
-    total_pages: int
-    has_next: bool
-    has_previous: bool
-
-
 class SortInfo(BaseModel):
     """Sorting information for list requests."""
 

solace_agent_mesh/templates/gateway_config_template.yaml

@@ -21,11 +21,6 @@ apps:
       
       artifact_service: __ARTIFACT_SERVICE__
 
-      authorization_service:
-        type: "none" # Or "default_rbac"
-        # role_definitions_path: "config/auth/roles.yaml"
-        # user_assignments_path: "config/auth/users.yaml"
-
       system_purpose: >
         __SYSTEM_PURPOSE__
 

solace_agent_mesh/templates/logging_config_template.ini

@@ -2,22 +2,22 @@
 keys=root,solace_ai_connector,solace_agent_mesh,sam_trace
 
 [logger_root]
-level=WARN
+level=${LOGGING_ROOT_LEVEL, WARNING}
 handlers=streamHandler,rotatingFileHandler
 qualname=root
 
 [logger_solace_ai_connector]
-level=INFO
+level=${LOGGING_SOLACE_AI_CONNECTOR_LEVEL, INFO}
 handlers=
 qualname=solace_ai_connector
 
 [logger_solace_agent_mesh]
-level=INFO
+level=${LOGGING_SAM_LEVEL, INFO}
 handlers=
 qualname=solace_agent_mesh
 
 [logger_sam_trace]
-level=INFO
+level=${LOGGING_SAM_TRACE_LEVEL, INFO}
 handlers=
 qualname=sam_trace
 
@@ -35,7 +35,11 @@ formatter=simpleFormatter
 args=(sys.stdout,)
 
 [formatters]
-keys=simpleFormatter
+keys=simpleFormatter,jsonFormatter
 
 [formatter_simpleFormatter]
-format=%(asctime)s | %(levelname)-5s | %(name)s | %(message)s
+format=%(asctime)s | %(levelname)-5s | %(name)s | %(message)s
+
+[formatter_jsonFormatter]
+class=pythonjsonlogger.jsonlogger.JsonFormatter
+format=%(asctime)s %(levelname)s %(name)s %(message)s

solace_agent_mesh/templates/plugin_gateway_config_template.yaml

@@ -47,9 +47,6 @@ apps:
       gateway_id: __COMPONENT_KEBAB_CASE_NAME__-gw-01
       artifact_service: *default_artifact_service
 
-      authorization_service:
-        type: "none" # Or "default_rbac"
-
       system_purpose: >
             The system is an AI Chatbot with agentic capabilities.
             It will use the agents available to provide information,