Simplify: move duplicate observation deduplication to events_to_messages

Instead of adding a new transform() method to ViewPropertyBase and a
new ToolResultUniquenessProperty class, handle the deduplication of
consecutive observations with the same tool_call_id directly in the
events_to_messages() function.

This is simpler because:
- events_to_messages already handles a similar case (batching ActionEvents
  with the same llm_response_id)
- No new abstraction needed in the view property system
- The deduplication happens at message conversion time, which is where
  the constraint matters (Anthropic API message format)

The fix still handles the original bug: when a runtime restart creates
an AgentErrorEvent for an "unmatched" action, but the tool then
completes and creates an ObservationEvent with the same tool_call_id,
only the ObservationEvent is kept (it has the actual result).

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

Author: openhands-agent

openhands-sdk/openhands/sdk/context/view/properties/__init__.py

@@ -6,16 +6,12 @@
 from openhands.sdk.context.view.properties.tool_loop_atomicity import (
     ToolLoopAtomicityProperty,
 )
-from openhands.sdk.context.view.properties.tool_result_uniqueness import (
-    ToolResultUniquenessProperty,
-)
 
 
 ALL_PROPERTIES: list[ViewPropertyBase] = [
     BatchAtomicityProperty(),
     ToolCallMatchingProperty(),
     ToolLoopAtomicityProperty(),
-    ToolResultUniquenessProperty(),
 ]
 """A list of all existing properties."""
 
@@ -24,6 +20,5 @@
     "BatchAtomicityProperty",
     "ToolCallMatchingProperty",
     "ToolLoopAtomicityProperty",
-    "ToolResultUniquenessProperty",
     "ALL_PROPERTIES",
 ]

openhands-sdk/openhands/sdk/context/view/properties/base.py

@@ -43,27 +43,6 @@ def enforce(
             the current view to enforce the property.
         """
 
-    def transform(
-        self,
-        current_view_events: list[LLMConvertibleEvent],  # noqa: ARG002
-        all_events: Sequence[Event],  # noqa: ARG002
-    ) -> dict[EventID, LLMConvertibleEvent]:
-        """Transform events in the view by replacing them with modified versions.
-
-        This method allows properties to merge or modify events rather than just
-        removing them. The default implementation returns an empty dict (no transforms).
-
-        Args:
-            current_view_events: The sequence of events currently in the view.
-            all_events: A list of all Event objects in the conversation.
-
-        Returns:
-            A mapping from original EventID to the replacement LLMConvertibleEvent.
-            Events whose IDs appear as keys will be replaced with the corresponding
-            values. The replacement events should have new unique IDs.
-        """
-        return {}
-
     @abstractmethod
     def manipulation_indices(
         self,

openhands-sdk/openhands/sdk/context/view/properties/tool_result_uniqueness.py

@@ -103,27 +103,12 @@ def enforce_properties(
         Since enforcement is intended as a fallback to inductively maintaining the
         properties via the associated manipulation indices, any time a property must be
         enforced a warning is logged.
-
-        Properties can also transform events (e.g., merge multiple events into one)
-        via the transform() method. Transformations are applied before enforcement.
         """
         for property in ALL_PROPERTIES:
-            # First apply any transformations (e.g., merging events)
-            transforms = property.transform(current_view_events, all_events)
-            if transforms:
-                logger.warning(
-                    f"Property {property.__class__.__name__} transformed "
-                    f"{len(transforms)} events."
-                )
-                current_view_events = [
-                    transforms.get(event.id, event) for event in current_view_events
-                ]
-
-            # Then enforce by removing events
             events_to_forget = property.enforce(current_view_events, all_events)
             if events_to_forget:
                 logger.warning(
-                    f"Property {property.__class__.__name__} enforced, "
+                    f"Property {property.__class__} enforced, "
                     f"{len(events_to_forget)} events dropped."
                 )
                 return View.enforce_properties(