fix: proper datetime comparison for timestamp filtering

Address review feedback on timezone handling:

- WebSocket endpoint now normalizes tz-aware datetimes (matches REST)
- event_service.py uses datetime comparison instead of string comparison
- Updated tests to reflect the new timezone contract

Co-authored-by: openhands <openhands@all-hands.dev>

Author: jpshackelford

openhands-agent-server/openhands/agent_server/sockets.py

@@ -25,6 +25,7 @@
 from openhands.agent_server.conversation_service import (
     get_default_conversation_service,
 )
+from openhands.agent_server.event_router import normalize_datetime_to_server_timezone
 from openhands.agent_server.models import BashEventBase, ExecuteBashRequest
 from openhands.agent_server.pub_sub import Subscriber
 from openhands.sdk import Event, Message
@@ -103,9 +104,10 @@ async def events_socket(
         session_api_key: Optional API key for authentication.
         resend_all: If True, resend all existing events when connecting.
         after_timestamp: If provided with resend_all=True, only resend events
-            with timestamps >= this value. Enables efficient bi-directional
-            loading where REST fetches historical events and WebSocket handles
-            events after a specific point in time.
+            with timestamps >= this value. Timestamps are interpreted in server
+            local time. Timezone-aware datetimes are converted to server timezone.
+            Enables efficient bi-directional loading where REST fetches historical
+            events and WebSocket handles events after a specific point in time.
     """
     if not await _accept_authenticated_websocket(websocket, session_api_key):
         return
@@ -121,17 +123,25 @@ async def events_socket(
         _WebSocketSubscriber(websocket)
     )
 
+    # Normalize timezone-aware datetimes to server timezone
+    normalized_after_timestamp = (
+        normalize_datetime_to_server_timezone(after_timestamp)
+        if after_timestamp
+        else None
+    )
+
     try:
         # Resend existing events if requested
         if resend_all:
-            if after_timestamp:
+            if normalized_after_timestamp:
                 logger.info(
-                    f"Resending events after {after_timestamp}: {conversation_id}"
+                    f"Resending events after {normalized_after_timestamp}: "
+                    f"{conversation_id}"
                 )
             else:
                 logger.info(f"Resending all events: {conversation_id}")
             async for event in page_iterator(
-                event_service.search_events, timestamp__gte=after_timestamp
+                event_service.search_events, timestamp__gte=normalized_after_timestamp
             ):
                 await _send_event(event, websocket)
 

tests/agent_server/test_event_router_websocket.py

@@ -456,7 +456,7 @@ class TestAfterTimestampFiltering:
     async def test_after_timestamp_passed_to_search_events(
         self, mock_websocket, mock_event_service, sample_conversation_id
     ):
-        """Test that after_timestamp is passed to search_events when provided."""
+        """Test that after_timestamp is normalized and passed to search_events."""
         from datetime import datetime
         from typing import cast
 
@@ -476,7 +476,8 @@ async def test_after_timestamp_passed_to_search_events(
         mock_event_service.search_events = AsyncMock(return_value=mock_event_page)
         mock_websocket.receive_json.side_effect = WebSocketDisconnect()
 
-        test_timestamp = datetime(2024, 1, 15, 10, 30, 0, tzinfo=UTC)
+        # Use a naive timestamp (as would typically come from REST API response)
+        test_timestamp = datetime(2024, 1, 15, 10, 30, 0)
 
         with (
             patch(
@@ -499,11 +500,69 @@ async def test_after_timestamp_passed_to_search_events(
                 after_timestamp=test_timestamp,
             )
 
-        # search_events should be called with timestamp__gte parameter
+        # search_events should be called with the (unchanged) naive timestamp
         mock_event_service.search_events.assert_called_once_with(
             page_id=None, timestamp__gte=test_timestamp
         )
 
+    @pytest.mark.asyncio
+    async def test_after_timestamp_timezone_aware_is_normalized(
+        self, mock_websocket, mock_event_service, sample_conversation_id
+    ):
+        """Test that timezone-aware timestamps are normalized to server timezone."""
+        from datetime import datetime
+        from typing import cast
+
+        from openhands.agent_server.models import EventPage
+        from openhands.sdk.event import Event
+
+        mock_events = [
+            MessageEvent(
+                id="event1",
+                source="user",
+                llm_message=Message(role="user", content=[TextContent(text="Hello")]),
+            ),
+        ]
+        mock_event_page = EventPage(
+            items=cast(list[Event], mock_events), next_page_id=None
+        )
+        mock_event_service.search_events = AsyncMock(return_value=mock_event_page)
+        mock_websocket.receive_json.side_effect = WebSocketDisconnect()
+
+        # Use a timezone-aware timestamp (UTC)
+        test_timestamp = datetime(2024, 1, 15, 10, 30, 0, tzinfo=UTC)
+
+        with (
+            patch(
+                "openhands.agent_server.sockets.conversation_service"
+            ) as mock_conv_service,
+            patch("openhands.agent_server.sockets.get_default_config") as mock_config,
+        ):
+            mock_config.return_value.session_api_keys = None
+            mock_conv_service.get_event_service = AsyncMock(
+                return_value=mock_event_service
+            )
+
+            from openhands.agent_server.sockets import events_socket
+
+            await events_socket(
+                sample_conversation_id,
+                mock_websocket,
+                session_api_key=None,
+                resend_all=True,
+                after_timestamp=test_timestamp,
+            )
+
+        # search_events should be called with the normalized timestamp
+        # (converted to server local timezone, which is still tz-aware)
+        mock_event_service.search_events.assert_called_once()
+        call_args = mock_event_service.search_events.call_args
+        passed_timestamp = call_args.kwargs["timestamp__gte"]
+        # The timestamp should have been converted to local timezone
+        assert passed_timestamp is not None
+        # It should represent the same instant in time
+        assert passed_timestamp == test_timestamp.astimezone(None)
+
     @pytest.mark.asyncio
     async def test_after_timestamp_without_resend_all_no_effect(
         self, mock_websocket, mock_event_service, sample_conversation_id

tests/agent_server/test_event_service.py

@@ -399,11 +399,17 @@ async def test_search_events_timestamp_range_filter(
     async def test_search_events_timestamp_filter_with_timezone_aware(
         self, event_service, mock_conversation_with_timestamped_events
     ):
-        """Test filtering events with timezone-aware datetime."""
+        """Test filtering events with timezone-aware datetime requires normalization.
+
+        Event timestamps are naive (server local time), so callers must normalize
+        timezone-aware datetimes to naive before filtering. This is done by the
+        REST/WebSocket API layer via normalize_datetime_to_server_timezone().
+        """
         event_service._conversation = mock_conversation_with_timestamped_events
 
-        # Filter events >= 12:00:00 UTC (should return events 3, 4, 5)
-        filter_time = datetime(2025, 1, 1, 12, 0, 0, tzinfo=UTC)
+        # Filter events >= 12:00:00 (naive, as if normalized by API layer)
+        # The API layer would convert a tz-aware datetime to naive server time
+        filter_time = datetime(2025, 1, 1, 12, 0, 0)  # naive datetime
         result = await event_service.search_events(timestamp__gte=filter_time)
 
         assert len(result.items) == 3
@@ -541,11 +547,16 @@ async def test_count_events_timestamp_range_filter(
     async def test_count_events_timestamp_filter_with_timezone_aware(
         self, event_service, mock_conversation_with_timestamped_events
     ):
-        """Test counting events with timezone-aware datetime."""
+        """Test counting events with timezone-aware datetime requires normalization.
+
+        Event timestamps are naive (server local time), so callers must normalize
+        timezone-aware datetimes to naive before filtering. This is done by the
+        REST/WebSocket API layer via normalize_datetime_to_server_timezone().
+        """
         event_service._conversation = mock_conversation_with_timestamped_events
 
-        # Count events >= 12:00:00 UTC (should return 3)
-        filter_time = datetime(2025, 1, 1, 12, 0, 0, tzinfo=UTC)
+        # Count events >= 12:00:00 (naive, as if normalized by API layer)
+        filter_time = datetime(2025, 1, 1, 12, 0, 0)  # naive datetime
         result = await event_service.count_events(timestamp__gte=filter_time)
         assert result == 3