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

solace_agent_mesh/gateway/http_sse/repository/session_repository.py

@@ -5,11 +5,11 @@ Session repository implementation using SQLAlchemy.
 from sqlalchemy.orm import Session as DBSession
 
 from ..shared.base_repository import PaginatedRepository
+from ..shared.pagination import PaginationParams
 from ..shared.types import PaginationInfo, SessionId, UserId
-from .entities import Message, Session
+from .entities import Session
 from .interfaces import ISessionRepository
 from .models import (
-    MessageModel,
     SessionModel,
     CreateSessionModel,
     UpdateSessionModel,
@@ -29,14 +29,14 @@ class SessionRepository(PaginatedRepository[SessionModel, Session], ISessionRepo
         return "session"
 
     def find_by_user(
-        self, user_id: UserId, pagination: PaginationInfo | None = None
+        self, user_id: UserId, pagination: PaginationParams | None = None
     ) -> list[Session]:
         """Find all sessions for a specific user."""
         query = self.db.query(SessionModel).filter(SessionModel.user_id == user_id)
         query = query.order_by(SessionModel.updated_time.desc())
 
         if pagination:
-            offset = (pagination.page - 1) * pagination.page_size
+            offset = (pagination.page_number - 1) * pagination.page_size
             query = query.offset(offset).limit(pagination.page_size)
 
         models = query.all()
@@ -96,52 +96,3 @@ class SessionRepository(PaginatedRepository[SessionModel, Session], ISessionRepo
         # Use BaseRepository delete method
         super().delete(self.db, session_id)
         return True
-
-    def find_user_session_with_messages(
-        self,
-        session_id: SessionId,
-        user_id: UserId,
-        pagination: PaginationInfo | None = None,
-    ) -> tuple[Session, list[Message]] | None:
-        """Find a session with its messages."""
-        session_model = (
-            self.db.query(SessionModel)
-            .filter(
-                SessionModel.id == session_id,
-                SessionModel.user_id == user_id,
-            )
-            .first()
-        )
-
-        if not session_model:
-            return None
-
-        message_query = self.db.query(MessageModel).filter(
-            MessageModel.session_id == session_id
-        )
-
-        if pagination:
-            offset = (pagination.page - 1) * pagination.page_size
-            message_query = message_query.offset(offset).limit(pagination.page_size)
-
-        message_models = message_query.order_by(MessageModel.created_time.asc()).all()
-
-        session = Session.model_validate(session_model)
-        messages = [self._message_model_to_entity(model) for model in message_models]
-
-        return session, messages
-
-
-    def _message_model_to_entity(self, model: MessageModel) -> Message:
-        """Convert SQLAlchemy message model to domain entity."""
-        from ..shared.enums import MessageType, SenderType
-
-        return Message(
-            id=model.id,
-            session_id=model.session_id,
-            message=model.message,
-            sender_type=SenderType(model.sender_type),
-            sender_name=model.sender_name,
-            message_type=MessageType.TEXT,  # Default for now
-            created_time=model.created_time,
-        )

solace_agent_mesh/gateway/http_sse/repository/task_repository.py

@@ -0,0 +1,173 @@
+"""
+Task repository implementation using SQLAlchemy.
+"""
+
+from sqlalchemy.orm import Session as DBSession
+
+from ..shared.types import PaginationInfo, PaginationParams, UserId
+from .entities import Task, TaskEvent
+from .interfaces import ITaskRepository
+from .models import TaskEventModel, TaskModel
+
+
+class TaskRepository(ITaskRepository):
+    """SQLAlchemy implementation of task repository."""
+
+    def __init__(self, db: DBSession):
+        self.db = db
+
+    def save_task(self, task: Task) -> Task:
+        """Create or update a task."""
+        model = self.db.query(TaskModel).filter(TaskModel.id == task.id).first()
+
+        if model:
+            # Update existing
+            model.end_time = task.end_time
+            model.status = task.status
+            model.total_input_tokens = task.total_input_tokens
+            model.total_output_tokens = task.total_output_tokens
+            model.total_cached_input_tokens = task.total_cached_input_tokens
+            model.token_usage_details = task.token_usage_details
+        else:
+            # Create new
+            model = TaskModel(
+                id=task.id,
+                user_id=task.user_id,
+                start_time=task.start_time,
+                end_time=task.end_time,
+                status=task.status,
+                initial_request_text=task.initial_request_text,
+                total_input_tokens=task.total_input_tokens,
+                total_output_tokens=task.total_output_tokens,
+                total_cached_input_tokens=task.total_cached_input_tokens,
+                token_usage_details=task.token_usage_details,
+            )
+            self.db.add(model)
+
+        self.db.commit()
+        self.db.refresh(model)
+        return self._task_model_to_entity(model)
+
+    def save_event(self, event: TaskEvent) -> TaskEvent:
+        """Save a task event."""
+        model = TaskEventModel(
+            id=event.id,
+            task_id=event.task_id,
+            user_id=event.user_id,
+            created_time=event.created_time,
+            topic=event.topic,
+            direction=event.direction,
+            payload=event.payload,
+        )
+        self.db.add(model)
+        self.db.commit()
+        self.db.refresh(model)
+        return self._event_model_to_entity(model)
+
+    def find_by_id(self, task_id: str) -> Task | None:
+        """Find a task by its ID."""
+        model = self.db.query(TaskModel).filter(TaskModel.id == task_id).first()
+        return self._task_model_to_entity(model) if model else None
+
+    def find_by_id_with_events(
+        self, task_id: str
+    ) -> tuple[Task, list[TaskEvent]] | None:
+        """Find a task with all its events."""
+        task_model = self.db.query(TaskModel).filter(TaskModel.id == task_id).first()
+        if not task_model:
+            return None
+
+        event_models = (
+            self.db.query(TaskEventModel)
+            .filter(TaskEventModel.task_id == task_id)
+            .order_by(TaskEventModel.created_time.asc())
+            .all()
+        )
+
+        task = self._task_model_to_entity(task_model)
+        events = [self._event_model_to_entity(model) for model in event_models]
+        return task, events
+
+    def search(
+        self,
+        user_id: UserId,
+        start_date: int | None = None,
+        end_date: int | None = None,
+        search_query: str | None = None,
+        pagination: PaginationParams | None = None,
+    ) -> list[Task]:
+        """Search for tasks with filters."""
+        query = self.db.query(TaskModel)
+        if user_id != "*":  # Allow wildcard for admin/system searches
+            query = query.filter(TaskModel.user_id == user_id)
+
+        if start_date:
+            query = query.filter(TaskModel.start_time >= start_date)
+        if end_date:
+            query = query.filter(TaskModel.start_time <= end_date)
+        if search_query:
+            query = query.filter(
+                TaskModel.initial_request_text.ilike(f"%{search_query}%")
+            )
+
+        query = query.order_by(TaskModel.start_time.desc())
+
+        if pagination:
+            offset = (pagination.page - 1) * pagination.page_size
+            query = query.offset(offset).limit(pagination.page_size)
+
+        models = query.all()
+        return [self._task_model_to_entity(model) for model in models]
+
+    def delete_tasks_older_than(self, cutoff_time_ms: int, batch_size: int) -> int:
+        """
+        Delete tasks (and their events via cascade) older than the cutoff time.
+        Uses batch deletion to avoid long-running transactions.
+
+        Args:
+            cutoff_time_ms: Epoch milliseconds - tasks with start_time before this will be deleted
+            batch_size: Number of tasks to delete per batch
+
+        Returns:
+            Total number of tasks deleted
+        """
+        total_deleted = 0
+        
+        while True:
+            # Find a batch of task IDs to delete
+            task_ids_to_delete = (
+                self.db.query(TaskModel.id)
+                .filter(TaskModel.start_time < cutoff_time_ms)
+                .limit(batch_size)
+                .all()
+            )
+            
+            if not task_ids_to_delete:
+                break
+            
+            # Extract IDs from the result tuples
+            ids = [task_id[0] for task_id in task_ids_to_delete]
+            
+            # Delete this batch
+            deleted_count = (
+                self.db.query(TaskModel)
+                .filter(TaskModel.id.in_(ids))
+                .delete(synchronize_session=False)
+            )
+            
+            self.db.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 _task_model_to_entity(self, model: TaskModel) -> Task:
+        """Convert SQLAlchemy task model to domain entity."""
+        return Task.model_validate(model)
+
+    def _event_model_to_entity(self, model: TaskEventModel) -> TaskEvent:
+        """Convert SQLAlchemy event model to domain entity."""
+        return TaskEvent.model_validate(model)

solace_agent_mesh/gateway/http_sse/routers/agent_cards.py

@@ -2,15 +2,16 @@
 API Router for agent discovery.
 """
 
+import logging
 from fastapi import APIRouter, Depends, HTTPException, status
 from typing import List
 
-from solace_ai_connector.common.log import log
-
 from ....common.agent_registry import AgentRegistry
 from a2a.types import AgentCard
 from ..dependencies import get_agent_registry
 
+log = logging.getLogger(__name__)
+
 router = APIRouter()
 
 

solace_agent_mesh/gateway/http_sse/routers/artifacts.py

@@ -2,6 +2,7 @@
 FastAPI router for managing session-specific artifacts via REST endpoints.
 """
 
+import logging
 from collections.abc import Callable
 from typing import TYPE_CHECKING, Any
 
@@ -32,8 +33,6 @@ import json
 from datetime import datetime, timezone
 from urllib.parse import parse_qs, quote, urlparse
 
-from solace_ai_connector.common.log import log
-
 from ....common.a2a.types import ArtifactInfo
 from ....common.utils.embeds import (
     LATE_EMBED_TYPES,
@@ -68,6 +67,7 @@ from ....agent.utils.artifact_helpers import (
     save_artifact_with_metadata,
 )
 
+log = logging.getLogger(__name__)
 
 class ArtifactUploadResponse(BaseModel):
     """Response model for artifact upload with camelCase fields."""
@@ -860,7 +860,7 @@ async def upload_artifact(
         f"[ArtifactRouter:Post:{filename}] User={user_id}, Session={session_id} -"
     )
     log.info(
-        "%s Request received. Upload filename: '%s', content type: %s, Metadata provided: %s",
+        "%s Request received. Upload filename: '%s', content type: %s",
         log_prefix,
         upload_file.filename,
         upload_file.content_type,

solace_agent_mesh/gateway/http_sse/routers/auth.py

@@ -2,6 +2,7 @@
 Router for handling authentication-related endpoints.
 """
 
+import logging
 from fastapi import (
     APIRouter,
     Request as FastAPIRequest,
@@ -15,7 +16,8 @@ import secrets
 from urllib.parse import urlencode
 
 from ...http_sse.dependencies import get_sac_component, get_api_config
-from solace_ai_connector.common.log import log
+
+log = logging.getLogger(__name__)
 
 router = APIRouter()
 

solace_agent_mesh/gateway/http_sse/routers/config.py

@@ -2,17 +2,18 @@
 API Router for providing frontend configuration.
 """
 
+import logging
 from fastapi import APIRouter, Depends, HTTPException, status
 from typing import Dict, Any
 
-from solace_ai_connector.common.log import log
-
 from ....gateway.http_sse.dependencies import get_sac_component, get_api_config
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
     from gateway.http_sse.component import WebUIBackendComponent
 
+log = logging.getLogger(__name__)
+
 router = APIRouter()
 
 
@@ -27,6 +28,30 @@ async def get_app_config(
     log_prefix = "[GET /api/v1/config] "
     log.info("%sRequest received.", log_prefix)
     try:
+        # Start with explicitly defined feature flags
+        feature_enablement = component.get_config("frontend_feature_enablement", {})
+
+        # Manually check for the task_logging feature and add it
+        task_logging_config = component.get_config("task_logging", {})
+        if task_logging_config and task_logging_config.get("enabled", False):
+            feature_enablement["taskLogging"] = True
+            log.debug("%s taskLogging feature flag is enabled.", log_prefix)
+
+        # Determine if feedback should be enabled
+        # Feedback requires SQL session storage for persistence
+        feedback_enabled = component.get_config("frontend_collect_feedback", False)
+        if feedback_enabled:
+            session_config = component.get_config("session_service", {})
+            session_type = session_config.get("type", "memory")
+            if session_type != "sql":
+                log.warning(
+                    "%s Feedback is configured but session_service type is '%s' (not 'sql'). "
+                    "Disabling feedback for frontend.",
+                    log_prefix,
+                    session_type
+                )
+                feedback_enabled = False
+
         config_data = {
             "frontend_server_url": "",
             "frontend_auth_login_url": component.get_config(
@@ -39,11 +64,9 @@ async def get_app_config(
                 "frontend_welcome_message", ""
             ),
             "frontend_redirect_url": component.get_config("frontend_redirect_url", ""),
-            "frontend_collect_feedback": component.get_config(
-                "frontend_collect_feedback", False
-            ),
+            "frontend_collect_feedback": feedback_enabled,
             "frontend_bot_name": component.get_config("frontend_bot_name", "A2A Agent"),
-            "frontend_feature_enablement": component.get_config("frontend_feature_enablement", {}),
+            "frontend_feature_enablement": feature_enablement,
             "persistence_enabled": api_config.get("persistence_enabled", False),
         }
         log.info("%sReturning frontend configuration.", log_prefix)