revert: "feat(ai): Full session replay mode" (#42633)

Author: pauldambra

ee/hogai/chat_agent/session_summaries/nodes.py

@@ -12,7 +12,7 @@
 
 from posthog.schema import AssistantMessage, AssistantToolCallMessage, MaxRecordingUniversalFilters, RecordingsQuery
 
-from posthog.session_recordings.playlist_counters import convert_filters_to_recordings_query
+from posthog.session_recordings.models.session_recording_playlist import SessionRecordingPlaylist
 from posthog.sync import database_sync_to_async
 from posthog.temporal.ai.session_summary.summarize_session import execute_summarize_session
 from posthog.temporal.ai.session_summary.summarize_session_group import (
@@ -299,6 +299,41 @@ async def _generate_replay_filters(
             )
             return None
 
+    def _convert_max_filters_to_recordings_query(self, replay_filters: MaxRecordingUniversalFilters) -> RecordingsQuery:
+        """Convert Max-generated filters into recordings query format"""
+        properties = []
+        if replay_filters.filter_group and replay_filters.filter_group.values:
+            for inner_group in replay_filters.filter_group.values:
+                if hasattr(inner_group, "values"):
+                    properties.extend(inner_group.values)
+        recordings_query = RecordingsQuery(
+            date_from=replay_filters.date_from,
+            date_to=replay_filters.date_to,
+            properties=properties,
+            filter_test_accounts=replay_filters.filter_test_accounts,
+            limit=replay_filters.limit,
+            order=replay_filters.order,
+            # Handle duration filters - preserve the original key (e.g., "active_seconds" or "duration")
+            having_predicates=(
+                [
+                    {"key": dur.key, "type": "recording", "operator": dur.operator, "value": dur.value}
+                    for dur in (replay_filters.duration or [])
+                ]
+                if replay_filters.duration
+                else None
+            ),
+        )
+        return recordings_query
+
+    def _convert_current_filters_to_recordings_query(self, current_filters: dict[str, Any]) -> RecordingsQuery:
+        """Convert current filters into recordings query format"""
+        from posthog.session_recordings.playlist_counters import convert_filters_to_recordings_query
+
+        # Create a temporary playlist object to use the conversion function
+        temp_playlist = SessionRecordingPlaylist(filters=current_filters)
+        recordings_query = convert_filters_to_recordings_query(temp_playlist)
+        return recordings_query
+
     def _get_session_ids_with_filters(self, replay_filters: RecordingsQuery) -> list[str] | None:
         """Get session ids from DB with filters"""
         from posthog.session_recordings.queries.session_recording_list_from_query import SessionRecordingListFromQuery
@@ -404,7 +439,7 @@ async def search_sessions(
                     )
                     return self._node._create_error_response(self._node._base_error_instructions, state)
                 current_filters = cast(dict[str, Any], current_filters)
-                replay_filters = convert_filters_to_recordings_query(current_filters)
+                replay_filters = self._convert_current_filters_to_recordings_query(current_filters)
             # If not - generate filters to get session ids from DB
             else:
                 filter_query = await self._generate_filter_query(state.session_summarization_query, config)
@@ -436,9 +471,7 @@ async def search_sessions(
                         root_tool_call_id=None,
                     )
                 # Use filters when generated successfully
-                replay_filters = convert_filters_to_recordings_query(
-                    filter_generation_result.model_dump(exclude_none=True)
-                )
+                replay_filters = self._convert_max_filters_to_recordings_query(filter_generation_result)
                 self._node._stream_filters(filter_generation_result)
             # Query the filters to get session ids
             if (

ee/hogai/chat_agent/session_summaries/test/test_nodes.py

@@ -32,7 +32,6 @@
 from posthog.clickhouse.client import sync_execute
 from posthog.clickhouse.log_entries import TRUNCATE_LOG_ENTRIES_TABLE_SQL
 from posthog.models import SessionRecording
-from posthog.session_recordings.playlist_counters import convert_filters_to_recordings_query
 from posthog.session_recordings.queries.test.session_replay_sql import produce_replay_summary
 from posthog.session_recordings.sql.session_replay_event_sql import TRUNCATE_SESSION_REPLAY_EVENTS_TABLE_SQL
 from posthog.temporal.ai.session_summary.summarize_session_group import SessionSummaryStreamUpdate
@@ -141,7 +140,7 @@ def test_get_session_ids_with_filters_empty(self, mock_query_runner_class: Magic
         mock_query_runner_class.return_value = mock_query_runner
 
         # Convert MaxRecordingUniversalFilters to RecordingsQuery
-        recordings_query = convert_filters_to_recordings_query(mock_filters.model_dump(exclude_none=True))
+        recordings_query = self.node._session_search._convert_max_filters_to_recordings_query(mock_filters)
         result = self.node._session_search._get_session_ids_with_filters(
             replay_filters=recordings_query,
         )
@@ -156,10 +155,20 @@ def test_get_session_ids_with_filters_with_duration(self, mock_query_runner_clas
         mock_query_runner_class.return_value = mock_query_runner
 
         # First convert MaxRecordingUniversalFilters to RecordingsQuery
-        recordings_query = convert_filters_to_recordings_query(mock_filters.model_dump(exclude_none=True))
-        result = self.node._session_search._get_session_ids_with_filters(recordings_query)
+        recordings_query = self.node._session_search._convert_max_filters_to_recordings_query(mock_filters)
+        result = self.node._session_search._get_session_ids_with_filters(
+            replay_filters=recordings_query,
+        )
+
         self.assertEqual(result, ["session-1"])
 
+        # Verify duration filters were converted to having_predicates
+        call_args = mock_query_runner_class.call_args
+        # The query parameter should have having_predicates
+        query_param = call_args[1]["query"]
+        self.assertIsNotNone(query_param.having_predicates)
+        self.assertEqual(len(query_param.having_predicates), 2)
+
     @patch("posthog.session_recordings.queries.session_recording_list_from_query.SessionRecordingListFromQuery")
     @patch("ee.hogai.chat_agent.session_summaries.nodes.database_sync_to_async")
     @patch("products.replay.backend.max_tools.SearchSessionRecordingsTool")
@@ -813,7 +822,7 @@ def test_use_current_filters_with_os_and_events(self) -> None:
         }
 
         # Convert custom filters to recordings query
-        recordings_query = convert_filters_to_recordings_query(custom_filters)
+        recordings_query = self.node._session_search._convert_current_filters_to_recordings_query(custom_filters)
 
         # Use the node's method to get session IDs
         session_ids = self.node._session_search._get_session_ids_with_filters(
@@ -850,7 +859,7 @@ def test_use_current_filters_with_date_range(self) -> None:
         }
 
         # Convert custom filters to recordings query
-        recordings_query = convert_filters_to_recordings_query(custom_filters)
+        recordings_query = self.node._session_search._convert_current_filters_to_recordings_query(custom_filters)
 
         # Use the node's method to get session IDs
         session_ids = self.node._session_search._get_session_ids_with_filters(
@@ -888,7 +897,7 @@ def test_generate_filters_last_10_days(self) -> None:
         )
 
         # Convert the generated filters to recordings query using the node's method
-        recordings_query = convert_filters_to_recordings_query(generated_filters.model_dump(exclude_none=True))
+        recordings_query = self.node._session_search._convert_max_filters_to_recordings_query(generated_filters)
 
         # Use the node's method to get session IDs
         session_ids = self.node._session_search._get_session_ids_with_filters(
@@ -923,7 +932,7 @@ def test_get_session_ids_respects_limit(self) -> None:
         }
 
         # Convert custom filters to recordings query
-        recordings_query = convert_filters_to_recordings_query(custom_filters)
+        recordings_query = self.node._session_search._convert_current_filters_to_recordings_query(custom_filters)
 
         # Get session IDs with explicit limit of 1
         session_ids = self.node._session_search._get_session_ids_with_filters(replay_filters=recordings_query)

ee/hogai/core/agent_modes/presets/session_replay.py

@@ -2,102 +2,24 @@
 
 from posthog.schema import AgentMode
 
-from ee.hogai.tools.replay.filter_session_recordings import FilterSessionRecordingsTool
 from ee.hogai.tools.replay.summarize_sessions import SummarizeSessionsTool
-from ee.hogai.tools.todo_write import TodoWriteExample
 
 from ..factory import AgentModeDefinition
 from ..toolkit import AgentToolkit
 
 if TYPE_CHECKING:
     from ee.hogai.tool import MaxTool
 
-POSITIVE_EXAMPLE_FILTER_WITH_PROPERTIES = """
-User: Show me recordings of mobile users from the US who encountered errors
-Assistant: I'll help you find those recordings. Let me create a todo list to ensure I discover the right properties and filters.
-*Creates todo list with the following items:*
-1. Use read_taxonomy to discover person properties for country filtering
-2. Use read_taxonomy to discover session properties for device type
-3. Use read_taxonomy to discover recording properties for errors
-4. Filter session recordings with the discovered properties
-*Begins working on the first task*
-""".strip()
-
-POSITIVE_EXAMPLE_FILTER_WITH_PROPERTIES_REASONING = """
-The assistant used the todo list because:
-1. Filtering session recordings requires discovering multiple property types (person, session, recording)
-2. Property names and values must be validated through read_taxonomy before creating filters
-3. The query involves multiple filter criteria that need to be combined
-4. The filter_session_recordings tool documentation explicitly requires using read_taxonomy for property discovery
-5. Breaking this into steps ensures all properties are discovered before attempting to filter
-""".strip()
-
-POSITIVE_EXAMPLE_SUMMARIZE_WITH_CONTEXT = """
-User: Summarize sessions where users clicked the checkout button but didn't complete purchase
-Assistant: I'll help you analyze those sessions. This requires multiple steps to ensure we get the right recordings.
-*Creates todo list with the following items:*
-1. Use read_taxonomy to discover events related to checkout
-2. Use read_taxonomy to discover events related to purchase completion
-3. Filter session recordings for sessions with checkout events but without purchase events
-4. Summarize the filtered sessions to identify patterns and issues
-*Begins working on the first task*
-""".strip()
-
-POSITIVE_EXAMPLE_SUMMARIZE_WITH_CONTEXT_REASONING = """
-The assistant used the todo list because:
-1. Session summarization requires filtering first (can't summarize without identifying relevant sessions)
-2. The filtering requires discovering event properties through read_taxonomy
-3. Complex event-based filters need validation before being used
-4. The summarize_sessions tool requires filter_session_recordings to be called first
-5. This is a multi-step analysis requiring systematic progression through discovery, filtering, and summarization
-""".strip()
-
-POSITIVE_EXAMPLE_MULTIPLE_RECORDING_ANALYSES = """
-User: Compare mobile vs desktop user behavior and also check if users with errors have different session patterns
-Assistant: I'll help you analyze these different user segments. Let me break this down into separate analyses.
-*Creates todo list with the following items:*
-1. Filter and summarize mobile user sessions
-2. Filter and summarize desktop user sessions
-3. Filter and summarize sessions with console errors
-4. Filter and summarize sessions without errors
-5. Compare findings across segments
-*Begins working on the first task*
-""".strip()
-
-POSITIVE_EXAMPLE_MULTIPLE_RECORDING_ANALYSES_REASONING = """
-The assistant used the todo list because:
-1. The user requested multiple separate recording analyses that need distinct filters
-2. Each segment (mobile, desktop, errors, no errors) requires its own filter_session_recordings call
-3. Each segment needs individual summarization
-4. The todo list helps organize these parallel analyses into manageable tasks
-5. This approach allows for tracking progress across multiple recording queries and summaries
-""".strip()
-
 
 class SessionReplayAgentToolkit(AgentToolkit):
-    POSITIVE_TODO_EXAMPLES = [
-        TodoWriteExample(
-            example=POSITIVE_EXAMPLE_FILTER_WITH_PROPERTIES,
-            reasoning=POSITIVE_EXAMPLE_FILTER_WITH_PROPERTIES_REASONING,
-        ),
-        TodoWriteExample(
-            example=POSITIVE_EXAMPLE_SUMMARIZE_WITH_CONTEXT,
-            reasoning=POSITIVE_EXAMPLE_SUMMARIZE_WITH_CONTEXT_REASONING,
-        ),
-        TodoWriteExample(
-            example=POSITIVE_EXAMPLE_MULTIPLE_RECORDING_ANALYSES,
-            reasoning=POSITIVE_EXAMPLE_MULTIPLE_RECORDING_ANALYSES_REASONING,
-        ),
-    ]
-
     @property
     def tools(self) -> list[type["MaxTool"]]:
-        tools: list[type[MaxTool]] = [FilterSessionRecordingsTool, SummarizeSessionsTool]
+        tools: list[type[MaxTool]] = [SummarizeSessionsTool]
         return tools
 
 
 session_replay_agent = AgentModeDefinition(
     mode=AgentMode.SESSION_REPLAY,
-    mode_description="Specialized mode for analyzing session recordings and user behavior. This mode allows you to filter session recordings, and summarize entire sessions or a set of them.",
+    mode_description="Specialized mode for analyzing session recordings and user behavior. This mode allows you to get summaries of session recordings and insights about them in natural language.",
     toolkit_class=SessionReplayAgentToolkit,
 )