fix: address code review findings from HTTP 429/rate-limit and resilience work

- Anthropic connector: remove broad except Exception in Retry-After parsing
  and simplify extraction logic to use single headers.get() path
- Composite failure recovery: clarify recycle policy (fresh round keeps only
  current failed selector excluded) and remove unnecessary isinstance check
- Integration tests: add explicit assertions for recycle exclusion-state policy
- Unit tests: add direct coverage for Retry-After metadata extraction (numeric
  and non-numeric header values)

Author: Mateusz

src/connectors/anthropic.py

@@ -74,35 +74,31 @@
 _LLM_PROXY_CLIENT_HOST_KEY = "_llm_proxy_client_host"
 
 
-def _retry_after_metadata_from_httpx_headers(
-    headers: Any,
-) -> tuple[dict[str, Any], int | None]:
+def _retry_after_metadata_from_httpx_headers(
+    headers: Any,
+) -> tuple[dict[str, Any], int | None]:
     """Extract Retry-After for resilience (same ``details['headers']`` shape as OpenAI).
 
     ``RateLimitErrorHandler`` reads ``details['headers']['retry-after']`` when
     ``reset_at`` is not a usable wall-clock hint, so we populate that structure here.
     """
 
-    details: dict[str, Any] = {}
-    reset_hint: int | None = None
-    retry_after: str | None = None
-    try:
-        if hasattr(headers, "get"):
-            got = headers.get("retry-after")
-            if got is not None:
-                retry_after = str(got).strip()
-        if not retry_after:
-            for key, value in headers.items():
-                if str(key).lower() == "retry-after":
-                    retry_after = str(value).strip()
-                    break
-        if retry_after:
-            details["headers"] = {"retry-after": retry_after}
-            with contextlib.suppress(ValueError, TypeError):
-                reset_hint = int(retry_after.split(",")[0].strip())
-    except Exception:
-        return {}, None
-    return details, reset_hint
+    if not hasattr(headers, "get"):
+        return {}, None
+
+    retry_after_raw = headers.get("retry-after")
+    if retry_after_raw is None:
+        return {}, None
+
+    retry_after = str(retry_after_raw).strip()
+    if not retry_after:
+        return {}, None
+
+    details: dict[str, Any] = {"headers": {"retry-after": retry_after}}
+    reset_hint: int | None = None
+    with contextlib.suppress(ValueError, TypeError):
+        reset_hint = int(retry_after.split(",", 1)[0].strip())
+    return details, reset_hint
 
 
 def _message_tool_calls(msg: Any) -> list[Any] | None:

src/core/services/composite_failure_recovery_bridge.py

@@ -175,8 +175,9 @@ def _build_weighted_retry_request(
                 remaining.append(item)
 
         if not remaining:
-            # All branches were exhausted once; recycle candidates by keeping only
-            # the current failed selector excluded and retrying the rest.
+            # All branches were exhausted once; start a fresh recycle round.
+            # Keep only the currently failed selector excluded so all others
+            # become eligible again within the same hop budget window.
             excluded = [selected]
             excluded_set = {selected}
             remaining = [
@@ -256,7 +257,7 @@ def _is_weighted_reroll_eligible(exc: Exception) -> bool:
             status_code = getattr(exc, "status_code", None)
             if status_code in {401, 403, 499}:
                 return False
-            details = exc.details if isinstance(exc.details, dict) else {}
+            details = exc.details
             error_code = getattr(exc, "code", None)
             if not isinstance(error_code, str) or not error_code:
                 candidate = details.get("code")

tests/integration/core/services/test_weighted_routing_recycles_on_transient_400.py

@@ -451,6 +451,9 @@ def _rng() -> float:
     state = context.extensions["composite_routing_state"]
     assert isinstance(state, dict)
     assert state["selected_selector"] == "zai-coding-plan:glm-5.1"
+    # Recycle policy: after full exhaustion, only the immediately failed selector
+    # remains excluded so prior candidates become eligible again.
+    assert state["excluded_selectors"] == ["qwen-oauth:coder-model"]
     assert state["hop_count"] == 2
 
 
@@ -522,4 +525,5 @@ def _rng() -> float:
     state = context.extensions["composite_routing_state"]
     assert isinstance(state, dict)
     assert state["selected_selector"] == "zai-coding-plan:glm-5.1"
+    assert state["excluded_selectors"] == ["qwen-oauth:coder-model"]
     assert state["hop_count"] == 2

tests/unit/connectors/test_anthropic_error_handling.py

@@ -7,6 +7,30 @@
 from src.core.domain.chat import CanonicalChatRequest, ChatMessage
 
 
+def test_retry_after_metadata_from_headers() -> None:
+    """Retry-After extraction preserves header and parses numeric seconds."""
+    from src.connectors.anthropic import _retry_after_metadata_from_httpx_headers
+
+    details, reset_hint = _retry_after_metadata_from_httpx_headers(
+        httpx.Headers({"Retry-After": "42"})
+    )
+
+    assert details == {"headers": {"retry-after": "42"}}
+    assert reset_hint == 42
+
+
+def test_retry_after_metadata_handles_non_numeric_header() -> None:
+    """Non-numeric Retry-After is preserved while reset hint remains unset."""
+    from src.connectors.anthropic import _retry_after_metadata_from_httpx_headers
+
+    details, reset_hint = _retry_after_metadata_from_httpx_headers(
+        httpx.Headers({"Retry-After": "Wed, 21 Oct 2015 07:28:00 GMT"})
+    )
+
+    assert details == {"headers": {"retry-after": "Wed, 21 Oct 2015 07:28:00 GMT"}}
+    assert reset_hint is None
+
+
 @pytest.mark.asyncio
 async def test_anthropic_streaming_handles_error_events():
     """Test that Anthropic connector properly handles error events in streaming."""