Add error handling for observation mode robustness

- Wrap process_event() call in state.py with try-except to ensure events are
  always added regardless of compliance check failures
- Add try-except in monitor.py check_event() and update_state() to handle
  exceptions from individual properties gracefully
- Add test_monitor_handles_buggy_property_gracefully test to verify buggy
  properties don't crash the monitor

This ensures observation mode is robust: events are always processed even if
compliance checking fails.

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

Author: openhands-agent

openhands-sdk/openhands/sdk/conversation/compliance/monitor.py

@@ -57,14 +57,22 @@ def check_event(self, event: LLMConvertibleEvent) -> list[ComplianceViolation]:
         violations: list[ComplianceViolation] = []
 
         for prop in self.properties:
-            violation = prop.check(event, self.state)
-            if violation is not None:
-                violations.append(violation)
-                logger.warning(
-                    "API compliance violation detected: %s - %s (event_id=%s)",
-                    violation.property_name,
-                    violation.description,
-                    violation.event_id,
+            try:
+                violation = prop.check(event, self.state)
+                if violation is not None:
+                    violations.append(violation)
+                    logger.warning(
+                        "API compliance violation detected: %s - %s (event_id=%s)",
+                        violation.property_name,
+                        violation.description,
+                        violation.event_id,
+                    )
+            except Exception as e:
+                logger.exception(
+                    "Error checking compliance property %s for event %s: %s",
+                    prop.name,
+                    event.id,
+                    e,
                 )
 
         return violations
@@ -78,7 +86,15 @@ def update_state(self, event: LLMConvertibleEvent) -> None:
             event: The event that was just processed.
         """
         for prop in self.properties:
-            prop.update_state(event, self.state)
+            try:
+                prop.update_state(event, self.state)
+            except Exception as e:
+                logger.exception(
+                    "Error updating state for property %s on event %s: %s",
+                    prop.name,
+                    event.id,
+                    e,
+                )
 
     def process_event(self, event: LLMConvertibleEvent) -> list[ComplianceViolation]:
         """Check an event and update state.

openhands-sdk/openhands/sdk/conversation/state.py

@@ -550,7 +550,12 @@ def add_event(self, event: Event) -> None:
         """
         # Check for compliance violations only for LLM-convertible events
         if isinstance(event, LLMConvertibleEvent):
-            self.compliance_monitor.process_event(event)
+            try:
+                self.compliance_monitor.process_event(event)
+            except Exception as e:
+                logger.exception(
+                    "Error checking compliance for event %s: %s", event.id, e
+                )
 
         # Add to event log regardless of violations (observation mode)
         self._events.append(event)

tests/sdk/conversation/compliance/test_monitor.py

@@ -4,6 +4,12 @@
     APIComplianceMonitor,
     InterleavedMessageProperty,
 )
+from openhands.sdk.conversation.compliance.base import (
+    APICompliancePropertyBase,
+    ComplianceState,
+    ComplianceViolation,
+)
+from openhands.sdk.event import LLMConvertibleEvent
 from tests.sdk.conversation.compliance.conftest import (
     make_action_event,
     make_observation_event,
@@ -147,3 +153,34 @@ def test_monitor_parallel_tool_calls():
     violations = monitor.process_event(make_user_message_event())
     assert len(violations) == 1
     assert "call_paris" in str(violations[0].context)
+
+
+def test_monitor_handles_buggy_property_gracefully():
+    """Monitor should handle exceptions in property checks gracefully.
+
+    A buggy property that raises an exception should not crash the monitor.
+    Instead, the exception is logged and processing continues. This ensures
+    observation mode is robust against buggy properties.
+    """
+
+    class BuggyProperty(APICompliancePropertyBase):
+        @property
+        def name(self) -> str:
+            return "buggy"
+
+        def check(
+            self,
+            event: LLMConvertibleEvent,
+            state: ComplianceState,
+        ) -> ComplianceViolation | None:
+            raise ValueError("Oops!")
+
+    monitor = APIComplianceMonitor(properties=[BuggyProperty()])
+
+    # Should not raise - the exception should be caught and logged
+    # We expect an empty list because the buggy property doesn't return a violation
+    # (it raises instead)
+    violations = monitor.process_event(make_user_message_event())
+
+    # The monitor should continue working despite the error
+    assert violations == []