argus-code-review 0.3.2__tar.gz → 0.3.4__tar.gz

{argus_code_review-0.3.2 → argus_code_review-0.3.4}/CHANGELOG.md

@@ -7,6 +7,22 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.3.4] - 2026-10-23
+
+### Fixed
+
+- Gemini requests now retry HTTP 500/502/503/504 in place at every turn (up to three attempts with exponential jitter), retaining the conversation and without replaying tools. The outer session timeout still bounds the total work. The quota-aware whole-session turn-0 retry remains for 429s and transport errors, but a 5xx the SDK has already retried (three attempts) is not restarted, so a persistent 5xx costs at most three requests per turn; 429s are excluded from the SDK's status-only retry policy so daily-quota errors still fail fast.
+- Failed Gemini sessions preserve cost and tool accounting from completed turns, and include the failed turn index in their short failure detail.
+- Reviewer failure details now reach degraded-coverage reports instead of disappearing after the runner. Only canonical provider codes/statuses, standard HTTP reason phrases (such as `502 Bad Gateway`) and httpx transport error names are rendered; raw provider messages are never included. The cause precedes the reviewer-area name so it remains visible to consumers that truncate descriptions to 200 characters. Existing failure-reason values and database constraints are unchanged.
+- The model-registry check in the cross-cutting and lite prompts now applies to the repository under review instead of naming one specific package's constants. A package that has no registry of its own is no longer told it must use someone else's, and a legitimately overridden model value is not flagged. The em-dash character rule, which was one project's prose convention rather than a general review criterion, is removed from the shared prompt.
+
+## [0.3.3] - 2026-10-22
+
+### Changed
+
+- Gemini reviewer sessions now retry ONCE on a transient failure (HTTP 429/500/502/503/504, `RESOURCE_EXHAUSTED`/`UNAVAILABLE`/`DEADLINE_EXCEEDED`/`INTERNAL`, or an httpx timeout/connect/read/remote-protocol error) that happens before the model returned any response. The cooldown depends on the error: 45-60 s jitter for 429/`RESOURCE_EXHAUSTED` (per-minute quota windows), 5-10 s for 5xx and network errors; a server `Retry-After`/`retryDelay` >= 5 s is honored; never more than 60 s. A daily-quota 429 (`PerDay` quota or a retry delay over 120 s) and auth, permission, bad-request and not-found errors are never retried. Overridable via `ARGUS_GEMINI_RETRY_RATE_LIMIT_{MIN,MAX}_S`, `ARGUS_GEMINI_RETRY_COOLDOWN_{MIN,MAX}_S` and `ARGUS_GEMINI_RETRY_MAX_WAIT_S`.
+- A failed Gemini session now logs a WARNING with the exception type, HTTP code/status and a scrubbed, 300-character-truncated message, and `SessionResult.failure_detail` carries a short label such as `429 RESOURCE_EXHAUSTED`. `failure_reason` stays `worker_crashed`; degraded-coverage note text is unchanged. The existing ERROR log for a failed `generate_content` call is also scrubbed of key-shaped strings.
+
 ## [0.3.2] - 2026-10-21
 
 ### Added
@@ -441,7 +457,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   packaged set.
 - `argus --version`, `argus prompts list`, and `argus prompts export`.
 
-[Unreleased]: https://github.com/redesignhealth/argus-review/compare/v0.3.1...HEAD
+[Unreleased]: https://github.com/redesignhealth/argus-review/compare/v0.3.4...HEAD
+[0.3.4]: https://github.com/redesignhealth/argus-review/compare/v0.3.3...v0.3.4
+[0.3.3]: https://github.com/redesignhealth/argus-review/compare/v0.3.2...v0.3.3
 [0.3.2]: https://github.com/redesignhealth/argus-review/compare/v0.3.1...v0.3.2
 [0.3.1]: https://github.com/redesignhealth/argus-review/compare/v0.3.0...v0.3.1
 [0.3.0]: https://github.com/redesignhealth/argus-review/compare/v0.2.11...v0.3.0

{argus_code_review-0.3.2 → argus_code_review-0.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: argus-code-review
-Version: 0.3.2
+Version: 0.3.4
 Summary: Self-orchestrated PR review agent using LangGraph + Claude Agent SDK
 Project-URL: Repository, https://github.com/redesignhealth/argus-review
 Project-URL: Issues, https://github.com/redesignhealth/argus-review/issues

{argus_code_review-0.3.2 → argus_code_review-0.3.4}/argus/gemini_runner.py

@@ -144,7 +144,10 @@ from __future__ import annotations
 import asyncio
 import json
 import logging
+import os
+import random
 import re
+from dataclasses import dataclass, field
 from datetime import datetime, timezone
 from typing import Any
 
@@ -208,6 +211,213 @@ _FORCE_TOOL_CONFIG = types.ToolConfig(
 # uncaught.
 _HTTP_TIMEOUT_FRACTION = 0.8
 
+# ---------------------------------------------------------------------------
+# One-shot retry of transient Gemini failures
+# ---------------------------------------------------------------------------
+# A session is retried AT MOST ONCE, and only when it failed with a transient
+# error (HTTP 429/500/502/503/504, RESOURCE_EXHAUSTED/UNAVAILABLE/
+# DEADLINE_EXCEEDED/INTERNAL, or an httpx timeout/connect/read/remote-protocol
+# error) before the model returned ANY response (i.e. on turn 0), so the retry
+# restarts the session cleanly from the beginning. Later failures are not
+# restarted; the SDK retries only individual 5xx requests (see
+# `_HTTP_RETRY_ATTEMPTS`), and a 5xx it already retried is not restarted again,
+# so the restart covers 429 and transport errors only. The cooldown depends on the error kind (see `_retry_decision`):
+# 45-60 s jitter for 429/RESOURCE_EXHAUSTED (per-minute quota windows), 5-10 s
+# for 5xx/network errors; a server Retry-After/retryDelay >= 5 s is honored;
+# never more than 60 s. Daily-quota 429s are not retried. Overridable via
+# ARGUS_GEMINI_RETRY_RATE_LIMIT_{MIN,MAX}_S, ARGUS_GEMINI_RETRY_COOLDOWN_{MIN,MAX}_S
+# and ARGUS_GEMINI_RETRY_MAX_WAIT_S (read per call, so tests can set them to 0).
+# The 60 s worst case is far inside ARGUS_SESSION_TIMEOUT (default 1500 s), and
+# the retry is skipped if <25% of that timeout remains.
+_RETRY_RATE_LIMIT_MIN_S = 45.0  # 429 / RESOURCE_EXHAUSTED: per-minute windows
+_RETRY_RATE_LIMIT_MAX_S = 60.0
+_RETRY_SHORT_MIN_S = 5.0  # 5xx / UNAVAILABLE / DEADLINE_EXCEEDED / network
+_RETRY_SHORT_MAX_S = 10.0
+_RETRY_MAX_WAIT_S = 60.0  # hard cap on any single wait, incl. a server Retry-After
+_RETRY_AFTER_MIN_S = 5.0  # a server delay below this is ignored (jitter used)
+# A server-suggested delay above this means the quota window is not a
+# per-minute one (minutes/hours): fail fast rather than retry.
+_RETRY_GIVEUP_DELAY_S = 120.0
+# Do not retry when less than this fraction of the session timeout remains
+# (e.g. the first attempt already burned its HTTP timeout).
+_RETRY_MIN_REMAINING_FRACTION = 0.25
+_TRANSIENT_HTTP_CODES = frozenset({429, 500, 502, 503, 504})
+_TRANSIENT_STATUSES = frozenset(
+    {"RESOURCE_EXHAUSTED", "UNAVAILABLE", "DEADLINE_EXCEEDED", "INTERNAL"}
+)
+_TRANSIENT_HTTPX = (
+    httpx.TimeoutException,
+    httpx.ConnectError,
+    httpx.ReadError,
+    httpx.RemoteProtocolError,
+)
+
+# SDK-level per-request retry of 5xx at any turn; the request is re-sent
+# unchanged, so no tools are replayed. 429s stay in _retry_decision because the
+# SDK cannot tell daily quota from per-minute limits or honor Retry-After.
+_HTTP_RETRY_ATTEMPTS = 3  # including the initial call
+_HTTP_RETRY_STATUS_CODES = (500, 502, 503, 504)
+_HTTP_RETRY_INITIAL_DELAY_S = 2.0
+_HTTP_RETRY_MAX_DELAY_S = 20.0
+_DETAIL_MAX_CHARS = 300
+_SECRET_RE = re.compile(
+    r"(AIza[0-9A-Za-z_\-]{20,}|(?i:(?:api[_-]?key|key|token)=)[^&\s\"']+|"
+    r"(?i:bearer\s+)[A-Za-z0-9._\-]+|sk-[A-Za-z0-9_\-]{16,})"
+)
+
+
+def _env_float(name: str, default: float) -> float:
+    raw = os.environ.get(name)
+    if raw is None or raw == "":
+        return default
+    try:
+        return max(0.0, float(raw))
+    except ValueError:
+        return default
+
+
+@dataclass
+class _Progress:
+    """Mutable per-session state shared between attempts and the failure handler."""
+
+    responses: int = 0  # successful generate_content responses received
+    last_turn: int | None = None  # 0-based index of the turn that last ran
+    retried: bool = False
+    retry_wait_s: float = 0.0
+    # Usage accrued so far, so a session that dies mid-flight still reports it.
+    prompt_tokens: int = 0
+    cached_tokens: int = 0
+    candidates_tokens: int = 0
+    thoughts_tokens: int = 0
+    tool_use_prompt_tokens: int = 0
+    tool_calls: list[str] = field(default_factory=list)
+
+    @property
+    def input_tokens(self) -> int:
+        # Gemini's prompt_token_count already includes the cached portion, so
+        # subtract it to avoid billing it at both input and cache-read rates.
+        # Tool-result tokens are billed as input.
+        return max(self.prompt_tokens - self.cached_tokens, 0) + self.tool_use_prompt_tokens
+
+    @property
+    def output_tokens(self) -> int:
+        # Thinking tokens are a separate additive bucket billed as output.
+        return self.candidates_tokens + self.thoughts_tokens
+
+    def cost_usd(self, model: str) -> float:
+        if self.responses == 0:
+            return 0.0
+        return estimate_cost_usd(
+            model=model,
+            input_tokens=self.input_tokens,
+            output_tokens=self.output_tokens,
+            cached_input_tokens=self.cached_tokens,
+        )
+
+
+def _scrub(text: str) -> str:
+    """Redact anything key-shaped and truncate for logging."""
+    text = _SECRET_RE.sub("***", text).replace("\n", " ")
+    return text[:_DETAIL_MAX_CHARS]
+
+
+def _error_code_status(exc: BaseException) -> tuple[int | None, str | None]:
+    """Best-effort (HTTP code, status string) for an SDK/transport exception."""
+    if isinstance(exc, genai_errors.APIError):
+        code = getattr(exc, "code", None)
+        status = getattr(exc, "status", None)
+        return (
+            code if isinstance(code, int) else None,
+            status if isinstance(status, str) else None,
+        )
+    if isinstance(exc, httpx.HTTPStatusError):
+        return exc.response.status_code, None
+    return None, None
+
+
+def _is_transient_error(exc: BaseException) -> bool:
+    code, status = _error_code_status(exc)
+    if code in _TRANSIENT_HTTP_CODES or (status or "").upper() in _TRANSIENT_STATUSES:
+        return True
+    if isinstance(exc, (genai_errors.APIError, httpx.HTTPStatusError)):
+        return False  # a definite API answer that is not transient (400/401/403/404...)
+    return isinstance(exc, _TRANSIENT_HTTPX)
+
+
+def _retry_after_seconds(exc: BaseException) -> float | None:
+    """Server-suggested delay from a Retry-After header or RetryInfo.retryDelay."""
+    response = getattr(exc, "response", None)
+    headers = getattr(response, "headers", None)
+    try:
+        raw = headers.get("retry-after") if headers is not None else None
+        if raw is not None:
+            return max(0.0, float(raw))
+    except (TypeError, ValueError, AttributeError):
+        pass
+    details = getattr(exc, "details", None)
+    err = details.get("error", details) if isinstance(details, dict) else None
+    items = err.get("details") if isinstance(err, dict) else None
+    for item in items if isinstance(items, list) else []:
+        delay = item.get("retryDelay") if isinstance(item, dict) else None
+        if isinstance(delay, str) and delay.endswith("s"):
+            try:
+                return max(0.0, float(delay[:-1]))
+            except ValueError:
+                pass
+    return None
+
+
+def _is_daily_quota(exc: BaseException, server_delay: float | None) -> bool:
+    """True when a 429 reports a per-day quota or a many-minutes retry delay."""
+    if server_delay is not None and server_delay > _RETRY_GIVEUP_DELAY_S:
+        return True
+    return bool(re.search(r"per\s*day|perday", str(exc), re.IGNORECASE))
+
+
+def _retry_decision(exc: BaseException) -> tuple[str, float] | None:
+    """``(kind, wait_seconds)`` if ``exc`` should be retried once, else ``None``.
+
+    Kinds: ``rate_limit`` (429/RESOURCE_EXHAUSTED, 45-60 s jitter),
+    ``server`` (5xx/UNAVAILABLE/DEADLINE_EXCEEDED/INTERNAL) and ``network``
+    (5-10 s jitter). A server Retry-After/retryDelay >= 5 s replaces the
+    jittered value; the wait never exceeds 60 s. A daily-quota 429 is never
+    retried.
+    """
+    if not _is_transient_error(exc):
+        return None
+    code, status = _error_code_status(exc)
+    if isinstance(exc, genai_errors.ServerError) and code in _HTTP_RETRY_STATUS_CODES:
+        return None  # the SDK already retried this request; a restart would repeat it
+    server_delay = _retry_after_seconds(exc)
+    if code == 429 or (status or "").upper() == "RESOURCE_EXHAUSTED":
+        if _is_daily_quota(exc, server_delay):
+            return None
+        kind = "rate_limit"
+        lo = _env_float("ARGUS_GEMINI_RETRY_RATE_LIMIT_MIN_S", _RETRY_RATE_LIMIT_MIN_S)
+        hi = _env_float("ARGUS_GEMINI_RETRY_RATE_LIMIT_MAX_S", _RETRY_RATE_LIMIT_MAX_S)
+    else:
+        kind = "server" if code is not None or status else "network"
+        lo = _env_float("ARGUS_GEMINI_RETRY_COOLDOWN_MIN_S", _RETRY_SHORT_MIN_S)
+        hi = _env_float("ARGUS_GEMINI_RETRY_COOLDOWN_MAX_S", _RETRY_SHORT_MAX_S)
+    cap = _env_float("ARGUS_GEMINI_RETRY_MAX_WAIT_S", _RETRY_MAX_WAIT_S)
+    wait = random.uniform(lo, max(lo, hi))  # noqa: S311 - jitter, not security
+    if server_delay is not None and server_delay >= _RETRY_AFTER_MIN_S:
+        wait = server_delay
+    return kind, min(wait, cap)
+
+
+def _failure_detail(exc: BaseException) -> str:
+    """Short, key-free label such as ``429 RESOURCE_EXHAUSTED`` or ``ConnectError``."""
+    code, status = _error_code_status(exc)
+    detail = " ".join(p for p in (str(code) if code is not None else "", status or "") if p)
+    detail = detail or type(exc).__name__
+    if (code == 429 or (status or "").upper() == "RESOURCE_EXHAUSTED") and _is_daily_quota(
+        exc, _retry_after_seconds(exc)
+    ):
+        detail += " (daily quota)"
+    return detail
+
+
 # Matches the fenced-json extraction argus.helpers.parse_review_result
 # already applies for the Claude path.
 _FENCED_JSON_RE = re.compile(r"```(?:json)?\s*(\{.*?\})\s*```", re.DOTALL)
@@ -599,6 +809,7 @@ async def _run_turns(
     repo_root: str,
     timeout_s: float,
     started_at: datetime,
+    progress: _Progress,
 ) -> SessionResult:
     """The actual tool-calling loop. Returns ``failure_reason="turn_budget_exhausted"``
     when the loop ran out of turns without a ``finish_review`` call, else
@@ -665,6 +876,16 @@ async def _run_turns(
             label=label,
         )
 
+        # Retry only model calls, not detached synchronous cache creation.
+        request_http_options = types.HttpOptions(
+            retry_options=types.HttpRetryOptions(
+                attempts=_HTTP_RETRY_ATTEMPTS,
+                initial_delay=_HTTP_RETRY_INITIAL_DELAY_S,
+                max_delay=_HTTP_RETRY_MAX_DELAY_S,
+                http_status_codes=list(_HTTP_RETRY_STATUS_CODES),
+            )
+        )
+
         def _build_config(cache_name: str | None) -> types.GenerateContentConfig:
             # Gemini constraint (confirmed against the live API, not just
             # documentation): a request using `cached_content=` must NOT
@@ -678,11 +899,14 @@ async def _run_turns(
             # `CreateCachedContentConfig.tool_config`), so the cached
             # branch here sends `cached_content` alone.
             if cache_name:
-                return types.GenerateContentConfig(cached_content=cache_name)
+                return types.GenerateContentConfig(
+                    cached_content=cache_name, http_options=request_http_options
+                )
             return types.GenerateContentConfig(
                 system_instruction=system_prompt,
                 tools=gemini_tools,
                 tool_config=_FORCE_TOOL_CONFIG,
+                http_options=request_http_options,
             )
 
         config = _build_config(cached_content_name)
@@ -691,19 +915,14 @@ async def _run_turns(
             types.Content(role="user", parts=[types.Part.from_text(text=user_message)])
         ]
 
-        tool_calls: list[str] = []
         files_explored: list[str] = []
         exhausted = False
-        usage_prompt_total = 0
-        usage_candidates_total = 0
-        usage_cached_total = 0
-        usage_thoughts_total = 0
-        usage_tool_use_prompt_total = 0
 
         _mid_budget_nudge_turn = _compute_mid_budget_nudge_turn(_MAX_TURNS_GEMINI)
 
         with review_tools.review_session(repo_root) as findings_sink:
             for _turn in range(_MAX_TURNS_GEMINI):
+                progress.last_turn = _turn
                 if (
                     _turn == _MAX_TURNS_GEMINI - _NUDGE_TURNS_BEFORE_BUDGET
                     and contents[-1].parts is not None
@@ -736,8 +955,7 @@ async def _run_turns(
                             entry.role if entry else "unknown",
                             model,
                             _turn,
-                            exc,
-                            exc_info=True,
+                            _scrub(str(exc)),
                         )
                         raise
                     logger.warning(
@@ -760,21 +978,16 @@ async def _run_turns(
                         model=model, contents=contents, config=config
                     )
 
+                progress.responses += 1
                 usage = response.usage_metadata
                 if usage is not None:
-                    usage_prompt_total += usage.prompt_token_count or 0
-                    usage_candidates_total += usage.candidates_token_count or 0
-                    usage_cached_total += usage.cached_content_token_count or 0
-                    # thoughts_token_count (thinking-mode output) and
-                    # tool_use_prompt_token_count (tool-result tokens fed
-                    # back to the model) are both billable and both
-                    # separate additive buckets, per
-                    # GenerateContentResponseUsageMetadata's own docstring
-                    # (total_token_count = prompt + candidates +
-                    # tool_use_prompt + thoughts) -- NOT already folded
-                    # into prompt_token_count/candidates_token_count.
-                    usage_thoughts_total += usage.thoughts_token_count or 0
-                    usage_tool_use_prompt_total += usage.tool_use_prompt_token_count or 0
+                    # thoughts and tool-use prompt tokens are billable, separate
+                    # additive buckets (not folded into prompt/candidates counts).
+                    progress.prompt_tokens += usage.prompt_token_count or 0
+                    progress.candidates_tokens += usage.candidates_token_count or 0
+                    progress.cached_tokens += usage.cached_content_token_count or 0
+                    progress.thoughts_tokens += usage.thoughts_token_count or 0
+                    progress.tool_use_prompt_tokens += usage.tool_use_prompt_token_count or 0
 
                 function_calls = response.function_calls or []
                 if not function_calls:
@@ -828,7 +1041,7 @@ async def _run_turns(
                 for call in function_calls:
                     name = call.name or ""
                     args = dict(call.args or {})
-                    tool_calls.append(name)
+                    progress.tool_calls.append(name)
                     output, is_error = await asyncio.to_thread(_execute_tool_call, name, args)
                     if is_error and name != "finish_review":
                         logger.warning("Tool call failed [%s]: %s", name, output[:200])
@@ -860,35 +1073,19 @@ async def _run_turns(
             result_text = _build_result_text(findings_sink, files_explored)
 
         finished_at = datetime.now(timezone.utc)
-        unique_tool_names = sorted(set(tool_calls))
-
-        # Gemini's prompt_token_count already INCLUDES the cached portion
-        # (unlike Anthropic's fully-separate input/cache-read counters,
-        # which is the convention estimate_cost_usd's cached_input_tokens
-        # documents) -- so the cached amount must be subtracted out of the
-        # uncached input count here, or it would be billed at both the full
-        # input rate AND the cache-read rate. tool_use_prompt tokens are
-        # billed at the input rate (added in); thoughts tokens are billed
-        # at the output rate (added in) -- see the accumulation loop above.
-        input_tokens = max(usage_prompt_total - usage_cached_total, 0) + usage_tool_use_prompt_total
-        output_tokens = usage_candidates_total + usage_thoughts_total
-        cost_usd = estimate_cost_usd(
-            model=model,
-            input_tokens=input_tokens,
-            output_tokens=output_tokens,
-            cached_input_tokens=usage_cached_total,
-        )
+        unique_tool_names = sorted(set(progress.tool_calls))
+        cost_usd = progress.cost_usd(model)
 
-        tools_str = f" (tools: {', '.join(unique_tool_names)})" if tool_calls else ""
+        tools_str = f" (tools: {', '.join(unique_tool_names)})" if progress.tool_calls else ""
         logger.info(
             "Gemini agent done [%s]: %d tool calls%s, cost=$%.4f input_tokens=%d cached_tokens=%d output_tokens=%d",
             label or "unlabeled",
-            len(tool_calls),
+            len(progress.tool_calls),
             tools_str,
             cost_usd,
-            input_tokens,
-            usage_cached_total,
-            output_tokens,
+            progress.input_tokens,
+            progress.cached_tokens,
+            progress.output_tokens,
         )
 
         return SessionResult(
@@ -897,7 +1094,7 @@ async def _run_turns(
             duration_seconds=(finished_at - started_at).total_seconds(),
             started_at=started_at,
             finished_at=finished_at,
-            tool_call_count=len(tool_calls),
+            tool_call_count=len(progress.tool_calls),
             tool_names=unique_tool_names,
             # No Context7 MCP integration in scope for this runner (see module
             # docstring) -- always 0, never derived from tool_calls.
@@ -922,6 +1119,35 @@ async def _run_turns(
         )
 
 
+async def _run_turns_with_retry(
+    *, progress: _Progress, timeout_s: float, **kwargs: Any
+) -> SessionResult:
+    """``_run_turns`` with at most one retry of a transient turn-0 failure."""
+    label = kwargs.get("label") or "unlabeled"
+    t0 = asyncio.get_running_loop().time()
+    try:
+        return await _run_turns(timeout_s=timeout_s, progress=progress, **kwargs)
+    except (genai_errors.APIError, httpx.HTTPError) as exc:
+        remaining = timeout_s - (asyncio.get_running_loop().time() - t0)
+        decision = _retry_decision(exc) if progress.responses == 0 else None
+        if decision is None or remaining < timeout_s * _RETRY_MIN_REMAINING_FRACTION:
+            raise
+        kind, wait = decision
+        if wait >= remaining:
+            raise
+        progress.retried = True
+        progress.retry_wait_s = wait
+        logger.info(
+            "gemini session [%s] retrying after %s (kind=%s) in %.1fs",
+            label,
+            _failure_detail(exc),
+            kind,
+            wait,
+        )
+        await asyncio.sleep(wait)
+    return await _run_turns(timeout_s=timeout_s, progress=progress, **kwargs)
+
+
 def _redact_gemini_inputs(inputs: dict[str, Any], **_: Any) -> dict[str, Any]:
     """LangSmith ``process_inputs`` hook: redact credentials from Settings."""
     if not isinstance(inputs, dict):
@@ -988,9 +1214,11 @@ async def run_session_gemini(
     )
 
     started_at = datetime.now(timezone.utc)
+    progress = _Progress()
     try:
         return await asyncio.wait_for(
-            _run_turns(
+            _run_turns_with_retry(
+                progress=progress,
                 entry=entry,
                 model=model,
                 system_prompt=system_prompt,
@@ -1006,19 +1234,21 @@ async def run_session_gemini(
     except (TimeoutError, httpx.TimeoutException) as exc:
         finished_at = datetime.now(timezone.utc)
         logger.warning(
-            "Gemini session [%s] timed out after %ss (%s)",
+            "Gemini session [%s] timed out after %ss (%s), %d turn(s) and %d tool call(s) done",
             label or "unlabeled",
             effective_timeout_s,
             type(exc).__name__,
+            progress.responses,
+            len(progress.tool_calls),
         )
         return SessionResult(
             result_text="",
-            cost_usd=0.0,
+            cost_usd=progress.cost_usd(model),
             duration_seconds=(finished_at - started_at).total_seconds(),
             started_at=started_at,
             finished_at=finished_at,
-            tool_call_count=0,
-            tool_names=[],
+            tool_call_count=len(progress.tool_calls),
+            tool_names=sorted(set(progress.tool_calls)),
             context7_call_count=0,
             model=model,
             failure_reason="timeout",
@@ -1057,22 +1287,28 @@ async def run_session_gemini(
         # identically here, even though this runner has no literal
         # subprocess "worker" the way the Claude Agent SDK path does.
         finished_at = datetime.now(timezone.utc)
+        detail = _failure_detail(exc)
+        if progress.last_turn is not None:
+            detail = f"{detail}, turn {progress.last_turn}"
         logger.warning(
-            "Gemini session [%s] failed with a non-timeout error after %.1fs (%s: %s)",
+            "Gemini session [%s] failed after %.1fs (%s, %s%s): %s",
             label or "unlabeled",
             (finished_at - started_at).total_seconds(),
             type(exc).__name__,
-            exc,
+            detail,
+            ", after one retry" if progress.retried else "",
+            _scrub(str(exc)),
         )
         return SessionResult(
             result_text="",
-            cost_usd=0.0,
+            cost_usd=progress.cost_usd(model),
             duration_seconds=(finished_at - started_at).total_seconds(),
             started_at=started_at,
             finished_at=finished_at,
-            tool_call_count=0,
-            tool_names=[],
+            tool_call_count=len(progress.tool_calls),
+            tool_names=sorted(set(progress.tool_calls)),
             context7_call_count=0,
             model=model,
             failure_reason="worker_crashed",
+            failure_detail=detail,
         )

{argus_code_review-0.3.2 → argus_code_review-0.3.4}/argus/helpers.py

@@ -11,6 +11,8 @@ import re
 from pathlib import Path
 from typing import Any
 
+import httpx
+
 from argus.models import Finding, ReviewResponse, RiskLevel, Severity, Verdict
 from argus.pipeline_models import RawFinding, SystemReviewResult
 
@@ -145,6 +147,31 @@ def collect_reviewed_files(results: list[SystemReviewResult]) -> set[str]:
     return reviewed
 
 
+def _concrete_subclass_names(base: type[BaseException]) -> set[str]:
+    names = {base.__name__}
+    for sub in base.__subclasses__():
+        names |= _concrete_subclass_names(sub)
+    return names
+
+
+# Only canonical provider codes/statuses, HTTP reason phrases and transport
+# exception names may be rendered into reports, never arbitrary exception text
+# or payloads. Transport names come from httpx itself so they cannot drift.
+_TRANSPORT_ERROR_NAMES = sorted(
+    _concrete_subclass_names(httpx.TransportError) | {"HTTPStatusError"}
+)
+_CANONICAL_FAILURE_DETAIL_RE = re.compile(
+    r"(?:[1-5][0-9]{2}(?: (?:INTERNAL|UNAVAILABLE|RESOURCE_EXHAUSTED|"
+    r"DEADLINE_EXCEEDED|UNAUTHENTICATED|PERMISSION_DENIED|INVALID_ARGUMENT|"
+    r"NOT_FOUND|FAILED_PRECONDITION|UNKNOWN|CANCELLED|ABORTED|OUT_OF_RANGE|"
+    r"UNIMPLEMENTED|DATA_LOSS|"
+    # HTTP reason phrase (non-JSON error body), e.g. "Bad Gateway"; <= 40 chars.
+    r"(?=[A-Za-z ]{1,40}(?![A-Za-z ]))[A-Z][a-z]+(?: [A-Z][a-z]+)*))?|"
+    r"(?:" + "|".join(_TRANSPORT_ERROR_NAMES) + r"|ServerError|ClientError|APIError))"
+    r"(?: \(daily quota\))?(?:, turn [0-9]+)?"
+)
+
+
 def failed_reviewer_labels(results: list[SystemReviewResult]) -> list[tuple[str, str]]:
     """Return ``(system_group, failure_reason)`` pairs for reviewers that did
     not complete normally, in the order they appear in ``results``.
@@ -159,10 +186,13 @@ def failed_reviewer_labels(results: list[SystemReviewResult]) -> list[tuple[str,
     """
     labels: list[tuple[str, str]] = []
     for result in results:
-        reason = result.failure_reason
+        reason: str | None = result.failure_reason
         if reason is None and result.timed_out:
             reason = "timeout"
         if reason is not None:
+            detail = result.failure_detail
+            if detail and _CANONICAL_FAILURE_DETAIL_RE.fullmatch(detail):
+                reason = f"{reason}: {detail}"
             labels.append((result.system_group, reason))
     return labels
 
@@ -272,15 +302,16 @@ def build_degraded_coverage_findings(
     """
     findings: list[Finding] = []
     for label, reason in failed_labels:
+        reason_code, _, detail = reason.partition(": ")
         is_precheck = label.startswith("precheck:")
         subject = "Precheck scanner" if is_precheck else "Reviewer session"
-        is_missing = reason == _SCANNER_NOT_INSTALLED_REASON
+        is_missing = reason_code == _SCANNER_NOT_INSTALLED_REASON
         # Distinct wording from a crash/timeout: the reviewer was alive and
         # exploring, it just never reached finish_review.
-        is_exhausted = reason == "turn_budget_exhausted"
+        is_exhausted = reason_code == "turn_budget_exhausted"
         if is_missing:
             reason_desc = "is not installed"
-        elif reason == "timeout":
+        elif reason_code == "timeout":
             reason_desc = "timed out"
         elif is_exhausted:
             reason_desc = "ran out of turns before finishing"
@@ -302,16 +333,22 @@ def build_degraded_coverage_findings(
                 f"Re-run the review or manually inspect the changes in '{label}' "
                 f"to ensure potential issues were not missed due to {reason}."
             )
+        if detail:
+            # Cause first: API/MCP summaries may clip at 200 chars, and the
+            # area name is unbounded model output.
+            description = f"{subject} {reason_desc}. Area: '{label}'. Coverage is degraded."
+        else:
+            description = (
+                f"{subject} '{label}' {reason_desc} and produced no findings. "
+                "Coverage for this area is degraded."
+            )
         findings.append(
             Finding(
                 severity=Severity.SUGGESTION,
                 category="coverage-gap",
                 file=None,
                 line=None,
-                description=(
-                    f"{subject} '{label}' {reason_desc} and produced no findings. "
-                    "Coverage for this area is degraded."
-                ),
+                description=description,
                 suggestion=suggestion,
             )
         )

{argus_code_review-0.3.2 → argus_code_review-0.3.4}/argus/pipeline_models.py

@@ -168,6 +168,14 @@ class SystemReviewResult(BaseModel):
         default=False,
         description="True when failure_reason == 'timeout'; kept for back-compat.",
     )
+    failure_detail: str | None = Field(
+        default=None,
+        description=(
+            "Short, key-free cause for failure_reason (e.g. '503 UNAVAILABLE, turn 45'), "
+            "copied from the runner's SessionResult. Report/degraded-coverage text only -- "
+            "not persisted to agent_runs and never parsed for control flow."
+        ),
+    )
 
     @model_validator(mode="before")
     @classmethod