Normalize sentinel and numeric-like method tokens

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

Author: cursoragent

README.md

@@ -187,7 +187,7 @@ Polling timeouts and repeated polling failures are surfaced as:
 
 `HyperbrowserPollingError` also covers stalled pagination (no page-batch progress during result collection).
 Transport-level request failures include HTTP method + URL context in error messages.
-URL-like fallback objects are stringified for transport diagnostics, bytes-like fallback methods/URLs are decoded when valid, and missing/malformed/sentinel URL inputs (for example `None`, booleans, invalid bytes, `null`/`undefined`/`true`/`false`/`nan`, or numeric-like values such as `123`/`1.5`/`1e6`) are normalized to `unknown URL`.
+Method-like fallback objects are stringified for diagnostics (with strict token validation), bytes-like fallback methods/URLs are decoded when valid, malformed/sentinel method inputs (for example `null`/`undefined`/`true`/`false`/`nan` or numeric-like values such as `1`/`1.5`/`1e3`) are normalized to `UNKNOWN`, and missing/malformed/sentinel URL inputs (for example `None`, booleans, invalid bytes, `null`/`undefined`/`true`/`false`/`nan`, or numeric-like values such as `123`/`1.5`/`1e6`) are normalized to `unknown URL`.
 
 ```python
 from hyperbrowser import Hyperbrowser

hyperbrowser/transport/error_utils.py

@@ -9,9 +9,26 @@
 _NUMERIC_LIKE_URL_PATTERN = re.compile(
     r"^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?$"
 )
+_NUMERIC_LIKE_METHOD_PATTERN = re.compile(
+    r"^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?$"
+)
 _MAX_ERROR_MESSAGE_LENGTH = 2000
 _MAX_REQUEST_URL_DISPLAY_LENGTH = 1000
 _MAX_REQUEST_METHOD_LENGTH = 50
+_INVALID_METHOD_SENTINELS = {
+    "none",
+    "null",
+    "undefined",
+    "true",
+    "false",
+    "nan",
+    "inf",
+    "+inf",
+    "-inf",
+    "infinity",
+    "+infinity",
+    "-infinity",
+}
 _INVALID_URL_SENTINELS = {
     "none",
     "null",
@@ -47,6 +64,12 @@ def _normalize_request_method(method: Any) -> str:
     if not isinstance(raw_method, str) or not raw_method.strip():
         return "UNKNOWN"
     normalized_method = raw_method.strip().upper()
+    lowered_method = normalized_method.lower()
+    if (
+        lowered_method in _INVALID_METHOD_SENTINELS
+        or _NUMERIC_LIKE_METHOD_PATTERN.fullmatch(normalized_method)
+    ):
+        return "UNKNOWN"
     if len(normalized_method) > _MAX_REQUEST_METHOD_LENGTH:
         return "UNKNOWN"
     if not _HTTP_METHOD_TOKEN_PATTERN.fullmatch(normalized_method):

tests/test_transport_error_utils.py

@@ -310,6 +310,32 @@ def test_format_request_failure_message_normalizes_non_string_fallback_values():
     assert message == "Request UNKNOWN unknown URL failed"
 
 
+@pytest.mark.parametrize("sentinel_method", ["null", "undefined", "true", "false"])
+def test_format_request_failure_message_normalizes_sentinel_fallback_methods(
+    sentinel_method: str,
+):
+    message = format_request_failure_message(
+        httpx.RequestError("network down"),
+        fallback_method=sentinel_method,
+        fallback_url="https://example.com/fallback",
+    )
+
+    assert message == "Request UNKNOWN https://example.com/fallback failed"
+
+
+@pytest.mark.parametrize("numeric_like_method", ["1", "1.5", "-1.25", "+2", ".75", "1e3"])
+def test_format_request_failure_message_normalizes_numeric_like_fallback_methods(
+    numeric_like_method: str,
+):
+    message = format_request_failure_message(
+        httpx.RequestError("network down"),
+        fallback_method=numeric_like_method,
+        fallback_url="https://example.com/fallback",
+    )
+
+    assert message == "Request UNKNOWN https://example.com/fallback failed"
+
+
 def test_format_request_failure_message_supports_ascii_bytes_method_values():
     message = format_request_failure_message(
         httpx.RequestError("network down"),
@@ -525,6 +551,30 @@ def test_format_generic_request_failure_message_normalizes_non_string_method_val
     assert message == "Request UNKNOWN https://example.com/path failed"
 
 
+@pytest.mark.parametrize("sentinel_method", ["null", "undefined", "true", "false"])
+def test_format_generic_request_failure_message_normalizes_sentinel_method_values(
+    sentinel_method: str,
+):
+    message = format_generic_request_failure_message(
+        method=sentinel_method,
+        url="https://example.com/path",
+    )
+
+    assert message == "Request UNKNOWN https://example.com/path failed"
+
+
+@pytest.mark.parametrize("numeric_like_method", ["1", "1.5", "-1.25", "+2", ".75", "1e3"])
+def test_format_generic_request_failure_message_normalizes_numeric_like_method_values(
+    numeric_like_method: str,
+):
+    message = format_generic_request_failure_message(
+        method=numeric_like_method,
+        url="https://example.com/path",
+    )
+
+    assert message == "Request UNKNOWN https://example.com/path failed"
+
+
 def test_format_generic_request_failure_message_supports_stringifiable_method_values():
     class _MethodLike:
         def __str__(self) -> str:

tests/test_transport_response_handling.py

@@ -67,6 +67,34 @@ def test_sync_handle_response_with_request_error_normalizes_method_casing():
         transport.close()
 
 
+def test_sync_handle_response_with_request_error_normalizes_sentinel_method():
+    transport = SyncTransport(api_key="test-key")
+    try:
+        with pytest.raises(
+            HyperbrowserError,
+            match="Request UNKNOWN https://example.com/network failed",
+        ):
+            transport._handle_response(
+                _RequestErrorResponse("null", "https://example.com/network")
+            )
+    finally:
+        transport.close()
+
+
+def test_sync_handle_response_with_request_error_normalizes_numeric_like_method():
+    transport = SyncTransport(api_key="test-key")
+    try:
+        with pytest.raises(
+            HyperbrowserError,
+            match="Request UNKNOWN https://example.com/network failed",
+        ):
+            transport._handle_response(
+                _RequestErrorResponse("1e3", "https://example.com/network")
+            )
+    finally:
+        transport.close()
+
+
 def test_async_handle_response_with_non_json_success_body_returns_status_only():
     async def run() -> None:
         transport = AsyncTransport(api_key="test-key")
@@ -117,6 +145,40 @@ async def run() -> None:
     asyncio.run(run())
 
 
+def test_async_handle_response_with_request_error_normalizes_sentinel_method():
+    async def run() -> None:
+        transport = AsyncTransport(api_key="test-key")
+        try:
+            with pytest.raises(
+                HyperbrowserError,
+                match="Request UNKNOWN https://example.com/network failed",
+            ):
+                await transport._handle_response(
+                    _RequestErrorResponse("undefined", "https://example.com/network")
+                )
+        finally:
+            await transport.close()
+
+    asyncio.run(run())
+
+
+def test_async_handle_response_with_request_error_normalizes_numeric_like_method():
+    async def run() -> None:
+        transport = AsyncTransport(api_key="test-key")
+        try:
+            with pytest.raises(
+                HyperbrowserError,
+                match="Request UNKNOWN https://example.com/network failed",
+            ):
+                await transport._handle_response(
+                    _RequestErrorResponse("1.5", "https://example.com/network")
+                )
+        finally:
+            await transport.close()
+
+    asyncio.run(run())
+
+
 def test_sync_handle_response_with_request_error_without_request_context():
     transport = SyncTransport(api_key="test-key")
     try: