(fix): Condensation events to reconstruct contexts added to event stream

openhands/agenthub/codeact_agent/codeact_agent.py

@@ -11,8 +11,10 @@
     Action,
     AgentFinishAction,
 )
+from openhands.events.event import Event
 from openhands.llm.llm import LLM
 from openhands.memory.condenser import Condenser
+from openhands.memory.condenser.condenser import Condensation, View
 from openhands.memory.conversation_memory import ConversationMemory
 from openhands.runtime.plugins import (
     AgentSkillsRequirement,
@@ -92,6 +94,7 @@ def reset(self) -> None:
 
     def step(self, state: State) -> Action:
         """Performs one step using the CodeAct Agent.
+
         This includes gathering info on previous steps and prompting the model to make a command to execute.
 
         Parameters:
@@ -113,8 +116,23 @@ def step(self, state: State) -> Action:
         if latest_user_message and latest_user_message.content.strip() == '/exit':
             return AgentFinishAction()
 
-        # prepare what we want to send to the LLM
-        messages = self._get_messages(state)
+        # Condense the events from the state. If we get a view we'll pass those
+        # to the conversation manager for processing, but if we get a condensation
+        # event we'll just return that instead of an action. The controller will
+        # immediately ask the agent to step again with the new view.
+        condensed_history: list[Event] = []
+        match self.condenser.condensed_history(state):
+            case View(events=events):
+                condensed_history = events
+
+            case Condensation(action=condensation_action):
+                return condensation_action
+
+        logger.debug(
+            f'Processing {len(condensed_history)} events from a total of {len(state.history)} events'
+        )
+
+        messages = self._get_messages(condensed_history)
         params: dict = {
             'messages': self.llm.format_messages_for_llm(messages),
         }
@@ -127,7 +145,7 @@ def step(self, state: State) -> Action:
             self.pending_actions.append(action)
         return self.pending_actions.popleft()
 
-    def _get_messages(self, state: State) -> list[Message]:
+    def _get_messages(self, events: list[Event]) -> list[Message]:
         """Constructs the message history for the LLM conversation.
 
         This method builds a structured conversation history by processing events from the state
@@ -143,7 +161,7 @@ def _get_messages(self, state: State) -> list[Message]:
         6. Adds environment reminders for non-function-calling mode
 
         Args:
-            state (State): The current state object containing conversation history and other metadata
+            events: The list of events to convert to messages
 
         Returns:
             list[Message]: A list of formatted messages ready for LLM consumption, including:
@@ -167,13 +185,6 @@ def _get_messages(self, state: State) -> list[Message]:
             with_caching=self.llm.is_caching_prompt_active()
         )
 
-        # Condense the events from the state.
-        events = self.condenser.condensed_history(state)
-
-        logger.debug(
-            f'Processing {len(events)} events from a total of {len(state.history)} events'
-        )
-
         # Use ConversationMemory to process events
         messages = self.conversation_memory.process_events(
             condensed_history=events,

openhands/controller/agent_controller.py

@@ -54,7 +54,7 @@
     MessageAction,
     NullAction,
 )
-from openhands.events.action.agent import RecallAction
+from openhands.events.action.agent import CondensationAction, RecallAction
 from openhands.events.event import Event
 from openhands.events.observation import (
     AgentCondensationObservation,
@@ -305,6 +305,8 @@ def should_step(self, event: Event) -> bool:
                 return True
             if isinstance(event, AgentDelegateAction):
                 return True
+            if isinstance(event, CondensationAction):
+                return True
             return False
         if isinstance(event, Observation):
             if (

openhands/core/schema/action.py

@@ -80,3 +80,6 @@ class ActionType(str, Enum):
 
     RECALL = 'recall'
     """Retrieves content from a user workspace, microagent, or other source."""
+
+    CONDENSATION = 'condensation'
+    """Condenses a list of events into a summary."""

openhands/events/action/agent.py

@@ -111,3 +111,87 @@ def __str__(self) -> str:
         ret = '**RecallAction**\n'
         ret += f'QUERY: {self.query[:50]}'
         return ret
+
+
+@dataclass
+class CondensationAction(Action):
+    """This action indicates a condensation of the conversation history is happening.
+
+    There are two ways to specify the events to be forgotten:
+    1. By providing a list of event IDs.
+    2. By providing the start and end IDs of a range of events.
+
+    In the second case, we assume that event IDs are monotonically increasing, and that _all_ events between the start and end IDs are to be forgotten.
+
+    Raises:
+        ValueError: If the optional fields are not instantiated in a valid configuration.
+    """
+
+    action: str = ActionType.CONDENSATION
+
+    forgotten_event_ids: list[int] | None = None
+    """The IDs of the events that are being forgotten (removed from the `View` given to the LLM)."""
+
+    forgotten_events_start_id: int | None = None
+    """The ID of the first event to be forgotten in a range of events."""
+
+    forgotten_events_end_id: int | None = None
+    """The ID of the last event to be forgotten in a range of events."""
+
+    summary: str | None = None
+    """An optional summary of the events being forgotten."""
+
+    summary_offset: int | None = None
+    """An optional offset to the start of the resulting view indicating where the summary should be inserted."""
+
+    def _validate_field_polymorphism(self) -> bool:
+        """Check if the optional fields are instantiated in a valid configuration."""
+        # For the forgotton events, there are only two valid configurations:
+        # 1. We're forgetting events based on the list of provided IDs, or
+        using_event_ids = self.forgotten_event_ids is not None
+        # 2. We're forgetting events based on the range of IDs.
+        using_event_range = (
+            self.forgotten_events_start_id is not None
+            and self.forgotten_events_end_id is not None
+        )
+
+        # Either way, we can only have one of the two valid configurations.
+        forgotten_event_configuration = using_event_ids ^ using_event_range
+
+        # We also need to check that if the summary is provided, so is the
+        # offset (and vice versa).
+        summary_configuration = (
+            self.summary is None and self.summary_offset is None
+        ) or (self.summary is not None and self.summary_offset is not None)
+
+        return forgotten_event_configuration and summary_configuration
+
+    def __post_init__(self):
+        if not self._validate_field_polymorphism():
+            raise ValueError('Invalid configuration of the optional fields.')
+
+    @property
+    def forgotten(self) -> list[int]:
+        """The list of event IDs that should be forgotten."""
+        # Start by making sure the fields are instantiated in a valid
+        # configuration. We check this whenever the event is initialized, but we
+        # can't make the dataclass immutable so we need to check it again here
+        # to make sure the configuration is still valid.
+        if not self._validate_field_polymorphism():
+            raise ValueError('Invalid configuration of the optional fields.')
+
+        if self.forgotten_event_ids is not None:
+            return self.forgotten_event_ids
+
+        # If we've gotten this far, the start/end IDs are not None.
+        assert self.forgotten_events_start_id is not None
+        assert self.forgotten_events_end_id is not None
+        return list(
+            range(self.forgotten_events_start_id, self.forgotten_events_end_id + 1)
+        )
+
+    @property
+    def message(self) -> str:
+        if self.summary:
+            return f'Summary: {self.summary}'
+        return f'Condenser is dropping the events: {self.forgotten}.'

openhands/events/serialization/action.py

@@ -8,6 +8,7 @@
     AgentRejectAction,
     AgentThinkAction,
     ChangeAgentStateAction,
+    CondensationAction,
     RecallAction,
 )
 from openhands.events.action.browse import BrowseInteractiveAction, BrowseURLAction
@@ -39,6 +40,7 @@
     RecallAction,
     ChangeAgentStateAction,
     MessageAction,
+    CondensationAction,
 )
 
 ACTION_TYPE_TO_CLASS = {action_class.action: action_class for action_class in actions}  # type: ignore[attr-defined]

openhands/memory/condenser/__init__.py

@@ -1,4 +1,15 @@
 import openhands.memory.condenser.impl  # noqa F401 (we import this to get the condensers registered)
-from openhands.memory.condenser.condenser import Condenser, get_condensation_metadata
+from openhands.memory.condenser.condenser import (
+    Condenser,
+    get_condensation_metadata,
+    View,
+    Condensation,
+)
 
-__all__ = ['Condenser', 'get_condensation_metadata', 'CONDENSER_REGISTRY']
+__all__ = [
+    'Condenser',
+    'get_condensation_metadata',
+    'CONDENSER_REGISTRY',
+    'View',
+    'Condensation',
+]