Guard transport error extraction against broken containers

Co-authored-by: Shri Sukhani <shrisukhani@users.noreply.github.com>

Author: cursoragent

hyperbrowser/transport/error_utils.py

@@ -136,26 +136,36 @@ def _stringify_error_value(value: Any, *, _depth: int = 0) -> str:
         return value
     if isinstance(value, dict):
         for key in ("message", "error", "detail", "errors", "msg", "title", "reason"):
-            nested_value = value.get(key)
+            try:
+                nested_value = value.get(key)
+            except Exception:
+                continue
             if nested_value is not None:
                 return _stringify_error_value(nested_value, _depth=_depth + 1)
     if isinstance(value, (list, tuple)):
         max_list_items = 10
-        collected_messages = [
-            item_message
-            for item_message in (
-                _stringify_error_value(item, _depth=_depth + 1)
-                for item in value[:max_list_items]
-            )
-            if item_message
-        ]
+        try:
+            list_items = value[:max_list_items]
+        except Exception:
+            return _safe_to_string(value)
+        collected_messages = []
+        try:
+            for item in list_items:
+                item_message = _stringify_error_value(item, _depth=_depth + 1)
+                if item_message:
+                    collected_messages.append(item_message)
+        except Exception:
+            return _safe_to_string(value)
         if collected_messages:
             joined_messages = (
                 collected_messages[0]
                 if len(collected_messages) == 1
                 else "; ".join(collected_messages)
             )
-            remaining_items = len(value) - max_list_items
+            try:
+                remaining_items = len(value) - max_list_items
+            except Exception:
+                return joined_messages
             if remaining_items > 0:
                 return f"{joined_messages}; ... (+{remaining_items} more)"
             return joined_messages
@@ -183,7 +193,10 @@ def _fallback_message() -> str:
     extracted_message: str
     if isinstance(error_data, dict):
         for key in ("message", "error", "detail", "errors", "title", "reason"):
-            message = error_data.get(key)
+            try:
+                message = error_data.get(key)
+            except Exception:
+                continue
             if message is not None:
                 candidate_message = _stringify_error_value(message)
                 if candidate_message.strip():

tests/test_transport_error_utils.py

@@ -167,6 +167,26 @@ def json(self):
         raise ValueError("invalid json")
 
 
+class _BrokenGetErrorDict(dict):
+    def get(self, key, default=None):
+        _ = key
+        _ = default
+        raise RuntimeError("broken dict get")
+
+    def __str__(self) -> str:
+        return "broken-get-error-dict"
+
+
+class _BrokenSliceErrorList(list):
+    def __getitem__(self, key):
+        if isinstance(key, slice):
+            raise RuntimeError("broken slice")
+        return super().__getitem__(key)
+
+    def __str__(self) -> str:
+        return "broken-slice-error-list"
+
+
 def test_extract_request_error_context_uses_unknown_when_request_unset():
     method, url = extract_request_error_context(httpx.RequestError("network down"))
 
@@ -664,6 +684,24 @@ def test_extract_error_message_handles_unstringifiable_message_values():
     assert message == "<unstringifiable _UnstringifiableErrorValue>"
 
 
+def test_extract_error_message_handles_dict_get_failures():
+    message = extract_error_message(
+        _DummyResponse({"message": _BrokenGetErrorDict({"inner": object()})}),
+        RuntimeError("fallback detail"),
+    )
+
+    assert message == "broken-get-error-dict"
+
+
+def test_extract_error_message_handles_list_slice_failures():
+    message = extract_error_message(
+        _DummyResponse({"errors": _BrokenSliceErrorList([{"msg": "issue-1"}])}),
+        RuntimeError("fallback detail"),
+    )
+
+    assert message == "broken-slice-error-list"
+
+
 def test_extract_error_message_uses_fallback_for_blank_dict_message():
     message = extract_error_message(
         _DummyResponse({"message": "   "}), RuntimeError("fallback detail")