solace-agent-mesh 1.4.2__py3-none-any.whl → 1.4.4__py3-none-any.whl

solace_agent_mesh/gateway/http_sse/repository/session_repository.py

@@ -12,7 +12,7 @@ from .models import MessageModel, SessionModel
 
 class SessionRepository(ISessionRepository):
     """SQLAlchemy implementation of session repository."""
-    
+
     def __init__(self, db: DBSession):
         self.db = db
 
@@ -26,7 +26,7 @@ class SessionRepository(ISessionRepository):
             offset = (pagination.page - 1) * pagination.page_size
             query = query.offset(offset).limit(pagination.page_size)
 
-        models = query.order_by(SessionModel.updated_at.desc()).all()
+        models = query.order_by(SessionModel.updated_time.desc()).all()
         return [self._model_to_entity(model) for model in models]
 
     def find_user_session(
@@ -45,13 +45,15 @@ class SessionRepository(ISessionRepository):
 
     def save(self, session: Session) -> Session:
         """Save or update a session."""
-        model = self.db.query(SessionModel).filter(SessionModel.id == session.id).first()
+        model = (
+            self.db.query(SessionModel).filter(SessionModel.id == session.id).first()
+        )
 
         if model:
             # Update existing
             model.name = session.name
             model.agent_id = session.agent_id
-            model.updated_at = session.updated_at
+            model.updated_time = session.updated_time
         else:
             # Create new
             model = SessionModel(
@@ -59,8 +61,8 @@ class SessionRepository(ISessionRepository):
                 name=session.name,
                 user_id=session.user_id,
                 agent_id=session.agent_id,
-                created_at=session.created_at,
-                updated_at=session.updated_at,
+                created_time=session.created_time,
+                updated_time=session.updated_time,
             )
             self.db.add(model)
 
@@ -82,7 +84,10 @@ class SessionRepository(ISessionRepository):
         return result > 0
 
     def find_user_session_with_messages(
-        self, session_id: SessionId, user_id: UserId, pagination: PaginationInfo | None = None
+        self,
+        session_id: SessionId,
+        user_id: UserId,
+        pagination: PaginationInfo | None = None,
     ) -> tuple[Session, list[Message]] | None:
         """Find a session with its messages."""
         session_model = (
@@ -105,7 +110,7 @@ class SessionRepository(ISessionRepository):
             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_at.asc()).all()
+        message_models = message_query.order_by(MessageModel.created_time.asc()).all()
 
         session = self._model_to_entity(session_model)
         messages = [self._message_model_to_entity(model) for model in message_models]
@@ -119,15 +124,14 @@ class SessionRepository(ISessionRepository):
             user_id=model.user_id,
             name=model.name,
             agent_id=model.agent_id,
-            created_at=model.created_at,
-            updated_at=model.updated_at,
-            last_activity=model.updated_at,
+            created_time=model.created_time,
+            updated_time=model.updated_time,
         )
 
     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,
@@ -135,5 +139,5 @@ class SessionRepository(ISessionRepository):
             sender_type=SenderType(model.sender_type),
             sender_name=model.sender_name,
             message_type=MessageType.TEXT,  # Default for now
-            created_at=model.created_at,
-        )
+            created_time=model.created_time,
+        )

solace_agent_mesh/gateway/http_sse/routers/dto/responses/base_responses.py

@@ -0,0 +1,42 @@
+"""
+Base response classes with automatic timestamp serialization.
+"""
+
+from typing import Any
+
+from pydantic import BaseModel, ConfigDict
+
+from ....shared import epoch_ms_to_iso8601
+
+
+class BaseTimestampResponse(BaseModel):
+    """
+    Base class for responses that include standard timestamp fields.
+
+    Timestamp fields are stored as epoch milliseconds (int) internally.
+    Automatically converts created_time and updated_time to ISO strings in JSON output.
+    """
+
+    model_config = ConfigDict(populate_by_name=True)
+
+    def model_dump(self, **kwargs) -> dict[str, Any]:
+        kwargs.setdefault('by_alias', True)
+        """Override model_dump to convert timestamp fields to ISO strings."""
+        data = super().model_dump(**kwargs)
+
+        # Convert timestamp fields to ISO strings for JSON output
+        # Check both snake_case (internal) and camelCase (API) names
+        timestamp_fields = ["created_time", "updated_time", "createdTime", "updatedTime"]
+        for field in timestamp_fields:
+            if field in data and data[field] is not None:
+                data[field] = epoch_ms_to_iso8601(data[field])
+
+        return data
+
+    def model_dump_json(self, **kwargs) -> str:
+        """Override model_dump_json to use our timestamp conversion."""
+        # Get the converted data first, then serialize to JSON
+        converted_data = self.model_dump(**kwargs)
+        import json
+
+        return json.dumps(converted_data, default=str)

solace_agent_mesh/gateway/http_sse/routers/dto/responses/session_responses.py

@@ -2,40 +2,42 @@
 Session-related response DTOs.
 """
 
-from typing import List, Optional
-from datetime import datetime
-from pydantic import BaseModel
+from pydantic import BaseModel, ConfigDict, Field
 
-from ....shared.types import SessionId, UserId, MessageId, PaginationInfo
-from ....shared.enums import SenderType, MessageType
+from ....shared.enums import MessageType, SenderType
+from ....shared.types import MessageId, PaginationInfo, SessionId, UserId
+from .base_responses import BaseTimestampResponse
 
 
-class MessageResponse(BaseModel):
+class MessageResponse(BaseTimestampResponse):
     """Response DTO for a chat message."""
+
     id: MessageId
-    session_id: SessionId
+    session_id: SessionId = Field(alias="sessionId")
     message: str
-    sender_type: SenderType
-    sender_name: str
-    message_type: MessageType = MessageType.TEXT
-    timestamp: datetime
-    created_at: datetime
-    updated_at: Optional[datetime] = None
+    sender_type: SenderType = Field(alias="senderType")
+    sender_name: str = Field(alias="senderName")
+    message_type: MessageType = Field(default=MessageType.TEXT, alias="messageType")
+    created_time: int = Field(alias="createdTime")
+    updated_time: int | None = Field(default=None, alias="updatedTime")
 
 
-class SessionResponse(BaseModel):
+class SessionResponse(BaseTimestampResponse):
     """Response DTO for a session."""
+
     id: SessionId
-    user_id: UserId
-    name: Optional[str] = None
-    agent_id: Optional[str] = None
-    created_at: datetime
-    updated_at: Optional[datetime] = None
-    last_activity: Optional[datetime] = None
+    user_id: UserId = Field(alias="userId")
+    name: str | None = None
+    agent_id: str | None = Field(default=None, alias="agentId")
+    created_time: int = Field(alias="createdTime")
+    updated_time: int | None = Field(default=None, alias="updatedTime")
 
 
 class SessionListResponse(BaseModel):
     """Response DTO for a list of sessions."""
-    sessions: List[SessionResponse]
-    pagination: Optional[PaginationInfo] = None
-    total_count: int
+
+    model_config = ConfigDict(populate_by_name=True)
+
+    sessions: list[SessionResponse]
+    pagination: PaginationInfo | None = None
+    total_count: int = Field(alias="totalCount")

solace_agent_mesh/gateway/http_sse/routers/sessions.py

@@ -1,13 +1,10 @@
-from fastapi import APIRouter, Body, Depends, HTTPException, status, BackgroundTasks
+from fastapi import APIRouter, Body, Depends, HTTPException, status
 from solace_ai_connector.common.log import log
 
+from ..dependencies import get_session_business_service
 from ..services.session_service import SessionService
-from ..dependencies import (
-    get_session_business_service,
-)
 from ..shared.auth_utils import get_current_user
 from .dto.requests.session_requests import (
-    DeleteSessionRequest,
     GetSessionHistoryRequest,
     GetSessionRequest,
     GetSessionsRequest,
@@ -44,9 +41,8 @@ async def get_all_sessions(
                 user_id=domain.user_id,
                 name=domain.name,
                 agent_id=domain.agent_id,
-                created_at=domain.created_at,
-                updated_at=domain.updated_at,
-                last_activity=domain.last_activity,
+                created_time=domain.created_time,
+                updated_time=domain.updated_time,
             )
             session_responses.append(session_response)
 
@@ -101,9 +97,8 @@ async def get_session(
             user_id=session_domain.user_id,
             name=session_domain.name,
             agent_id=session_domain.agent_id,
-            created_at=session_domain.created_at,
-            updated_at=session_domain.updated_at,
-            last_activity=session_domain.last_activity,
+            created_time=session_domain.created_time,
+            updated_time=session_domain.updated_time,
         )
 
     except HTTPException:
@@ -170,8 +165,7 @@ async def get_session_history(
                 sender_type=message_domain.sender_type,
                 sender_name=message_domain.sender_name,
                 message_type=message_domain.message_type,
-                timestamp=message_domain.created_at,
-                created_at=message_domain.created_at,
+                created_time=message_domain.created_time,
             )
             message_responses.append(message_response)
 
@@ -234,9 +228,8 @@ async def update_session_name(
             user_id=updated_domain.user_id,
             name=updated_domain.name,
             agent_id=updated_domain.agent_id,
-            created_at=updated_domain.created_at,
-            updated_at=updated_domain.updated_at,
-            last_activity=updated_domain.last_activity,
+            created_time=updated_domain.created_time,
+            updated_time=updated_domain.updated_time,
         )
 
     except HTTPException:
@@ -282,9 +275,7 @@ async def delete_session(
 
     except ValueError as e:
         log.warning("Validation error deleting session %s: %s", session_id, e)
-        raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST, detail=str(e)
-        )
+        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(e))
     except Exception as e:
         log.error(
             "Error deleting session %s for user %s: %s",

solace_agent_mesh/gateway/http_sse/services/session_service.py

@@ -1,5 +1,4 @@
 import uuid
-from datetime import datetime, timezone
 from typing import TYPE_CHECKING
 
 from solace_ai_connector.common.log import log
@@ -13,6 +12,7 @@ from ..repository import (
 )
 from ..shared.enums import MessageType, SenderType
 from ..shared.types import PaginationInfo, SessionId, UserId
+from ..shared import now_epoch_ms
 
 if TYPE_CHECKING:
     from ..component import WebUIBackendComponent
@@ -82,15 +82,14 @@ class SessionService:
 
         # Leave name as None/empty - frontend will generate display name if needed
 
-        now = datetime.now(timezone.utc)
+        now_ms = now_epoch_ms()
         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_time=now_ms,
+            updated_time=now_ms,
         )
 
         created_session = self.session_repository.save(session)
@@ -185,7 +184,7 @@ class SessionService:
             sender_type=sender_type,
             sender_name=sender_name,
             message_type=message_type,
-            created_at=datetime.now(timezone.utc),
+            created_time=now_epoch_ms(),
         )
 
         saved_message = self.message_repository.save(message_entity)

solace_agent_mesh/gateway/http_sse/shared/__init__.py

@@ -5,5 +5,21 @@ Contains common utilities, constants, enums, and types used across layers.
 """
 
 from .auth_utils import get_current_user
+from .timestamp_utils import (
+    datetime_to_epoch_ms,
+    epoch_ms_to_datetime,
+    epoch_ms_to_iso8601,
+    iso8601_to_epoch_ms,
+    now_epoch_ms,
+    validate_epoch_ms,
+)
 
-__all__ = ["get_current_user"]
+__all__ = [
+    "get_current_user",
+    "now_epoch_ms",
+    "epoch_ms_to_iso8601",
+    "iso8601_to_epoch_ms",
+    "datetime_to_epoch_ms",
+    "epoch_ms_to_datetime",
+    "validate_epoch_ms",
+]

solace_agent_mesh/gateway/http_sse/shared/timestamp_utils.py

@@ -0,0 +1,97 @@
+"""
+Epoch timestamp utilities for database portability and timezone handling.
+
+Matches the Java backend pattern:
+- Store as epoch milliseconds in database
+- Return as ISO 8601 strings via API
+- UI handles timezone conversion
+
+This provides a consistent approach across the platform.
+"""
+
+import time
+from datetime import datetime, timezone
+
+
+def now_epoch_ms() -> int:
+    """
+    Get current time as milliseconds since epoch (matches Java pattern).
+
+    Returns:
+        Current time as epoch milliseconds
+    """
+    return int(time.time() * 1000)
+
+
+def epoch_ms_to_iso8601(epoch_ms: int) -> str:
+    """
+    Convert epoch milliseconds to ISO 8601 string (matches Java epochLongToIso8601String).
+
+    Args:
+        epoch_ms: Time in milliseconds since epoch
+
+    Returns:
+        ISO 8601 formatted string in UTC timezone
+    """
+    return datetime.fromtimestamp(epoch_ms / 1000, tz=timezone.utc).isoformat()
+
+
+def iso8601_to_epoch_ms(iso8601_string: str) -> int:
+    """
+    Convert ISO 8601 string to epoch milliseconds (matches Java iso8601StringToEpochLong).
+
+    Args:
+        iso8601_string: ISO 8601 formatted datetime string
+
+    Returns:
+        Time as epoch milliseconds
+    """
+    dt = datetime.fromisoformat(iso8601_string.replace("Z", "+00:00"))
+    return int(dt.timestamp() * 1000)
+
+
+def datetime_to_epoch_ms(dt: datetime) -> int:
+    """
+    Convert datetime object to epoch milliseconds.
+
+    Args:
+        dt: Python datetime object
+
+    Returns:
+        Time as epoch milliseconds
+    """
+    return int(dt.timestamp() * 1000)
+
+
+def epoch_ms_to_datetime(epoch_ms: int) -> datetime:
+    """
+    Convert epoch milliseconds to datetime object.
+
+    Args:
+        epoch_ms: Time in milliseconds since epoch
+
+    Returns:
+        Python datetime object in UTC
+    """
+    return datetime.fromtimestamp(epoch_ms / 1000, tz=timezone.utc)
+
+
+def validate_epoch_ms(epoch_ms: int | None) -> bool:
+    """
+    Validate that an epoch milliseconds value is reasonable.
+
+    Args:
+        epoch_ms: Time in milliseconds since epoch
+
+    Returns:
+        True if the timestamp appears valid
+    """
+    if epoch_ms is None:
+        return False
+
+    # Check if timestamp is in reasonable range
+    # After 1970-01-01 and before year 2100
+    min_epoch_ms = 0
+    max_epoch_ms = 4102444800000  # 2100-01-01 00:00:00 UTC
+
+    return min_epoch_ms <= epoch_ms <= max_epoch_ms

solace_agent_mesh/gateway/http_sse/shared/types.py

@@ -2,8 +2,9 @@
 Custom types and type aliases used throughout the application.
 """
 
-from typing import Dict, Any, List, Optional, Union
 from datetime import datetime
+from typing import Any
+
 from pydantic import BaseModel
 
 # Basic type aliases
@@ -14,18 +15,29 @@ TaskId = str
 AgentId = str
 
 # Dictionary types
-JsonDict = Dict[str, Any]
-Headers = Dict[str, str]
-QueryParams = Dict[str, Union[str, List[str]]]
+JsonDict = dict[str, Any]
+Headers = dict[str, str]
+QueryParams = dict[str, str | list[str]]
+
 
 # Common data structures
 class Timestamp(BaseModel):
-    """Standardized timestamp representation."""
+    """Standardized timestamp representation using epoch milliseconds."""
+
+    created_time: int  # Epoch milliseconds
+    updated_time: int | None = None  # Epoch milliseconds
+
+
+class LegacyTimestamp(BaseModel):
+    """Legacy timestamp representation (deprecated - use Timestamp instead)."""
+
     created_at: datetime
-    updated_at: Optional[datetime] = None
+    updated_at: datetime | None = None
+
 
 class PaginationInfo(BaseModel):
     """Pagination information for list responses."""
+
     page: int
     page_size: int
     total_items: int
@@ -33,13 +45,17 @@ class PaginationInfo(BaseModel):
     has_next: bool
     has_previous: bool
 
+
 class SortInfo(BaseModel):
     """Sorting information for list requests."""
+
     field: str
     direction: str = "asc"  # asc or desc
 
+
 class FilterInfo(BaseModel):
     """Filtering information for list requests."""
+
     field: str
     operator: str  # eq, ne, gt, lt, gte, lte, contains, in
-    value: Any
+    value: Any

{solace_agent_mesh-1.4.2.dist-info → solace_agent_mesh-1.4.4.dist-info}/METADATA

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