solace-agent-mesh 1.4.12__py3-none-any.whl → 1.5.0__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/artifacts.py

@@ -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/config.py

@@ -27,6 +27,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 +63,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)

solace_agent_mesh/gateway/http_sse/routers/dto/dto_llm.txt

@@ -0,0 +1,346 @@
+# DEVELOPER GUIDE: dto
+
+## Quick Summary
+The `dto` directory contains Data Transfer Objects (DTOs) for API contract definition and validation in the HTTP SSE gateway. It's organized into two main subdirectories: `requests` for incoming API request validation using Pydantic models, and `responses` for structured API response formatting with automatic timestamp conversion. The DTOs primarily focus on session management operations and provide type-safe interfaces for API endpoints.
+
+## Files and Subdirectories Overview
+- **Direct files:** 
+  - `__init__.py` - Main module exports for requests and responses submodules
+- **Subdirectories:**
+  - `requests/` - Request DTOs for API endpoint validation (session CRUD operations)
+  - `responses/` - Response DTOs with automatic timestamp serialization and field aliasing
+
+## Developer API Reference
+
+### Direct Files
+
+#### __init__.py
+**Purpose:** Main entry point that exports the requests and responses submodules
+**Import:** `from solace_agent_mesh.gateway.http_sse.routers.dto import requests, responses`
+
+**Exports:**
+- `requests` - Module containing all request DTOs
+- `responses` - Module containing all response DTOs
+
+### Subdirectory APIs
+
+#### requests/
+**Purpose:** Provides Pydantic models for validating incoming API requests, specifically for session management operations
+**Key Exports:** GetSessionsRequest, GetSessionRequest, GetSessionHistoryRequest, UpdateSessionRequest, DeleteSessionRequest
+**Import Examples:**
+```python
+from solace_agent_mesh.gateway.http_sse.routers.dto.requests import (
+    GetSessionRequest,
+    GetSessionHistoryRequest,
+    UpdateSessionRequest
+)
+```
+
+#### responses/
+**Purpose:** Provides structured response DTOs with automatic timestamp conversion and field aliasing for API consistency
+**Key Exports:** MessageResponse, SessionResponse, SessionListResponse, BaseTimestampResponse
+**Import Examples:**
+```python
+from solace_agent_mesh.gateway.http_sse.routers.dto.responses import (
+    MessageResponse,
+    SessionResponse,
+    SessionListResponse
+)
+```
+
+## Complete Usage Guide
+
+### 1. Basic Imports and Setup
+
+```python
+# Import the main dto modules
+from solace_agent_mesh.gateway.http_sse.routers.dto import requests, responses
+
+# Or import specific DTOs directly
+from solace_agent_mesh.gateway.http_sse.routers.dto.requests import (
+    GetSessionRequest,
+    GetSessionHistoryRequest,
+    UpdateSessionRequest
+)
+from solace_agent_mesh.gateway.http_sse.routers.dto.responses import (
+    SessionResponse,
+    MessageResponse,
+    SessionListResponse
+)
+```
+
+### 2. Working with Request DTOs
+
+```python
+from solace_agent_mesh.gateway.http_sse.routers.dto.requests import (
+    GetSessionRequest,
+    GetSessionHistoryRequest,
+    UpdateSessionRequest
+)
+from pydantic import ValidationError
+
+# Create a request to get a specific session
+def get_session(session_id: str, user_id: str):
+    try:
+        request = GetSessionRequest(
+            session_id=session_id,
+            user_id=user_id
+        )
+        return request
+    except ValidationError as e:
+        print(f"Invalid request parameters: {e}")
+        return None
+
+# Create a request to get session history with pagination
+def get_session_history(session_id: str, user_id: str, page: int = 1, size: int = 20):
+    try:
+        request = GetSessionHistoryRequest(
+            session_id=session_id,
+            user_id=user_id,
+            pagination={"page": page, "size": size}
+        )
+        return request
+    except ValidationError as e:
+        print(f"Validation failed: {e}")
+        return None
+
+# Create a request to update session name
+def update_session_name(session_id: str, user_id: str, new_name: str):
+    try:
+        request = UpdateSessionRequest(
+            session_id=session_id,
+            user_id=user_id,
+            name=new_name  # Automatically validated (1-255 characters)
+        )
+        return request
+    except ValidationError as e:
+        print(f"Validation failed: {e}")
+        return None
+```
+
+### 3. Working with Response DTOs
+
+```python
+from solace_agent_mesh.gateway.http_sse.routers.dto.responses import (
+    SessionResponse,
+    MessageResponse,
+    SessionListResponse
+)
+from solace_agent_mesh.gateway.http_sse.shared.enums import MessageType, SenderType
+import time
+
+# Create session responses
+def create_session_response(session_data: dict) -> SessionResponse:
+    return SessionResponse(
+        id=session_data["id"],
+        user_id=session_data["user_id"],
+        name=session_data.get("name"),
+        agent_id=session_data.get("agent_id"),
+        created_time=int(time.time() * 1000),  # Current time in epoch ms
+        updated_time=session_data.get("updated_time")
+    )
+
+# Create message responses
+def create_message_response(message_data: dict) -> MessageResponse:
+    return MessageResponse(
+        id=message_data["id"],
+        session_id=message_data["session_id"],
+        message=message_data["message"],
+        sender_type=SenderType.USER,
+        sender_name=message_data["sender_name"],
+        message_type=MessageType.TEXT,
+        created_time=int(time.time() * 1000)
+    )
+
+# Create paginated session list responses
+def create_session_list_response(sessions: list, total: int) -> SessionListResponse:
+    session_responses = [create_session_response(session) for session in sessions]
+    return SessionListResponse(
+        sessions=session_responses,
+        pagination={"page": 1, "size": len(sessions), "total_pages": 1},
+        total_count=total
+    )
+```
+
+### 4. Complete API Endpoint Example
+
+```python
+from fastapi import APIRouter, HTTPException
+from solace_agent_mesh.gateway.http_sse.routers.dto.requests import (
+    GetSessionRequest,
+    GetSessionHistoryRequest,
+    UpdateSessionRequest
+)
+from solace_agent_mesh.gateway.http_sse.routers.dto.responses import (
+    SessionResponse,
+    MessageResponse,
+    SessionListResponse
+)
+
+router = APIRouter()
+
+@router.get("/sessions/{session_id}")
+async def get_session(session_id: str, user_id: str) -> SessionResponse:
+    """Get a specific session"""
+    
+    # Create and validate request DTO
+    request = GetSessionRequest(
+        session_id=session_id,
+        user_id=user_id
+    )
+    
+    # Fetch data (mock implementation)
+    session_data = fetch_session(request)
+    
+    # Return structured response with automatic timestamp conversion
+    return SessionResponse(
+        id=session_data["id"],
+        user_id=session_data["user_id"],
+        name=session_data["name"],
+        created_time=session_data["created_time"]
+    )
+
+@router.get("/sessions/{session_id}/history")
+async def get_session_history(
+    session_id: str,
+    user_id: str,
+    page: int = 1,
+    size: int = 20
+) -> list[MessageResponse]:
+    """Get session message history"""
+    
+    # Validate request using DTO
+    request = GetSessionHistoryRequest(
+        session_id=session_id,
+        user_id=user_id,
+        pagination={"page": page, "size": size}
+    )
+    
+    # Fetch messages (mock implementation)
+    messages_data = fetch_session_messages(request)
+    
+    # Return response DTOs with automatic field aliasing
+    return [
+        MessageResponse(
+            id=msg["id"],
+            session_id=msg["session_id"],
+            message=msg["message"],
+            sender_type=msg["sender_type"],
+            sender_name=msg["sender_name"],
+            message_type=msg["message_type"],
+            created_time=msg["created_time"]
+        )
+        for msg in messages_data
+    ]
+
+@router.put("/sessions/{session_id}")
+async def update_session(
+    session_id: str,
+    user_id: str,
+    name: str
+) -> SessionResponse:
+    """Update session name"""
+    
+    # Validate request using DTO
+    try:
+        request = UpdateSessionRequest(
+            session_id=session_id,
+            user_id=user_id,
+            name=name
+        )
+    except ValidationError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    
+    # Update session (mock implementation)
+    updated_session = update_session_in_db(request)
+    
+    # Return response DTO with automatic field aliasing
+    return SessionResponse(
+        id=updated_session["id"],
+        user_id=updated_session["user_id"],
+        name=updated_session["name"],
+        created_time=updated_session["created_time"],
+        updated_time=updated_session["updated_time"]
+    )
+```
+
+### 5. JSON Serialization with Automatic Timestamp Conversion
+
+```python
+from solace_agent_mesh.gateway.http_sse.routers.dto.responses import SessionResponse, MessageResponse
+from solace_agent_mesh.gateway.http_sse.shared.enums import MessageType, SenderType
+import json
+
+# Create a session response
+session = SessionResponse(
+    id="sess_123",
+    user_id="user_456",
+    name="My Session",
+    created_time=1640995200000,  # Epoch milliseconds
+    updated_time=1640995260000
+)
+
+# Automatic conversion to ISO strings in JSON output
+json_output = session.model_dump_json()
+print(json_output)
+# Output: {
+#   "id": "sess_123",
+#   "userId": "user_456",  # Note the camelCase aliasing
+#   "name": "My Session",
+#   "createdTime": "2022-01-01T00:00:00Z",  # Converted to ISO string
+#   "updatedTime": "2022-01-01T00:01:00Z"
+# }
+
+# Create a message response with field aliasing
+message = MessageResponse(
+    id="msg_789",
+    session_id="sess_123",
+    message="Hello world",
+    sender_type=SenderType.USER,
+    sender_name="John Doe",
+    message_type=MessageType.TEXT,
+    created_time=1640995200000
+)
+
+# Get dict with converted timestamps and aliased fields
+dict_output = message.model_dump()
+print(dict_output["sessionId"])  # "sess_123" (camelCase alias)
+print(dict_output["senderType"])  # SenderType.USER (camelCase alias)
+print(dict_output["createdTime"])  # "2022-01-01T00:00:00Z" (converted timestamp)
+```
+
+### 6. Custom Response Classes Using Base
+
+```python
+from solace_agent_mesh.gateway.http_sse.routers.dto.responses.base_responses import BaseTimestampResponse
+
+class CustomResponse(BaseTimestampResponse):
+    """Custom response with automatic timestamp handling"""
+    name: str
+    status: str
+    created_time: int
+    last_accessed: int | None = None
+    
+    class Config:
+        # Add field aliases if needed
+        alias_generator = lambda field_name: ''.join(
+            word.capitalize() if i > 0 else word 
+            for i, word in enumerate(field_name.split('_'))
+        )
+
+# Usage
+custom_response = CustomResponse(
+    name="Test Item",
+    status="active",
+    created_time=1640995200000,
+    last_accessed=1640995300000
+)
+
+# Automatic timestamp conversion in JSON
+json_data = custom_response.model_dump_json()
+# Fields like created_time become ISO strings automatically
+```
+
+This comprehensive guide shows how the `dto` directory provides a complete type-safe API contract system with automatic validation for requests and structured responses with timestamp conversion for the HTTP SSE gateway.
+
+# content_hash: 3bb29d4c46b962221fc3034560b7e0da75b5a41f7f8f4d4f25aecf26e10f83f5

solace_agent_mesh/gateway/http_sse/routers/dto/requests/__init__.py

@@ -4,12 +4,12 @@ Request DTOs for API endpoints.
 
 from .session_requests import (
     GetSessionRequest,
-    GetSessionHistoryRequest,
     UpdateSessionRequest,
 )
+from .task_requests import SaveTaskRequest
 
 __all__ = [
     "GetSessionRequest",
-    "GetSessionHistoryRequest",
     "UpdateSessionRequest",
-]
+    "SaveTaskRequest",
+]