code-puppy 0.0.591__tar.gz → 0.0.592__tar.gz

{code_puppy-0.0.591 → code_puppy-0.0.592}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-puppy
-Version: 0.0.591
+Version: 0.0.592
 Summary: Code generation agent
 Project-URL: repository, https://github.com/mpfaffenberger/code_puppy
 Project-URL: HomePage, https://github.com/mpfaffenberger/code_puppy

{code_puppy-0.0.591 → code_puppy-0.0.592}/code_puppy/agents/_runtime.py

@@ -19,6 +19,7 @@ from __future__ import annotations
 import asyncio
 import signal
 import threading
+import time
 import uuid
 from contextlib import AsyncExitStack
 from typing import Any, Callable, Iterator, List, Optional, Sequence, Type, Union
@@ -297,6 +298,7 @@ def streaming_retry(
     max_attempts: int = 3,
     delays: Sequence[float] = (1, 2, 4),
     model_name: Optional[str] = None,
+    progress_window: float = 120.0,
 ) -> Callable[[Callable[[], Any]], Callable[[], Any]]:
     """Wrap a no-arg async callable with streaming-retry semantics.
 
@@ -311,36 +313,43 @@ def streaming_retry(
     ``agent_retryable_exception`` hook, so plugins can opt provider-specific
     failures (e.g. OAuth auth errors) into this same retry schedule.
     ``model_name`` is forwarded to the hook so plugins can scope themselves.
+
+    ``max_attempts`` caps *consecutive rapid* failures, not total failures
+    per run. An agent run wraps many model calls; a long run can hit several
+    unrelated provider blips spread across minutes of successful work. If an
+    attempt survives at least ``progress_window`` seconds before failing, it
+    clearly made progress, so the failure streak resets and the blip gets a
+    fresh retry budget. Only back-to-back quick failures — the actual
+    hopeless-loop signature — burn through the cap.
     """
     from code_puppy.error_logging import log_error
 
     def decorator(factory: Callable[[], Any]) -> Callable[[], Any]:
         async def runner() -> Any:
-            last_exc: Optional[Exception] = None
-            for attempt in range(max_attempts):
+            streak = 0  # consecutive rapid failures
+            while True:
+                attempt_started = time.monotonic()
                 try:
                     return await factory()
                 except Exception as exc:
+                    made_progress = (
+                        time.monotonic() - attempt_started >= progress_window
+                    )
                     if not should_retry_streaming(exc) and not await _plugin_says_retry(
-                        exc, model_name, attempt + 1, max_attempts
+                        exc, model_name, streak + 1, max_attempts
                     ):
                         raise
-                    last_exc = exc
+                    if made_progress:
+                        streak = 0
+                    streak += 1
                     log_error(
                         exc,
                         context=(
                             f"streaming_retry: transient exception on attempt "
-                            f"{attempt + 1}/{max_attempts}"
+                            f"{streak}/{max_attempts}"
                         ),
                     )
-                    if attempt < max_attempts - 1:
-                        delay = delays[attempt] if attempt < len(delays) else delays[-1]
-                        emit_warning(
-                            f"\u26a1 Streaming interrupted, auto-retrying in {delay}s... "
-                            f"(attempt {attempt + 1}/{max_attempts})"
-                        )
-                        await asyncio.sleep(delay)
-                    else:
+                    if streak >= max_attempts:
                         log_error(
                             exc,
                             context=(
@@ -351,8 +360,15 @@ def streaming_retry(
                         emit_error(
                             f"\u274c Streaming failed after {max_attempts} attempts"
                         )
-            assert last_exc is not None  # loop always sets this before exiting
-            raise last_exc
+                        raise
+                    delay = (
+                        delays[streak - 1] if streak - 1 < len(delays) else delays[-1]
+                    )
+                    emit_warning(
+                        f"\u26a1 Streaming interrupted, auto-retrying in {delay}s... "
+                        f"(attempt {streak}/{max_attempts})"
+                    )
+                    await asyncio.sleep(delay)
 
         return runner
 

{code_puppy-0.0.591 → code_puppy-0.0.592}/code_puppy/claude_cache_client.py

@@ -440,8 +440,15 @@ class ClaudeCacheAsyncClient(httpx.AsyncClient):
                 if response.status_code == 400:
                     is_auth_error = await self._is_cloudflare_html_error(response)
                     if is_auth_error:
-                        logger.info(
-                            "Detected Cloudflare 400 error (likely auth-related), attempting token refresh"
+                        # cf-ray + request size make edge flaps diagnosable
+                        # (and reportable to Anthropic) from errors.log alone.
+                        request_body = self._extract_body_bytes(request) or b""
+                        logger.warning(
+                            "Detected Cloudflare HTML 400 (cf-ray=%s, "
+                            "request_bytes=%d, url=%s); attempting token refresh",
+                            response.headers.get("cf-ray"),
+                            len(request_body),
+                            request.url.path,
                         )
 
                 if is_auth_error:

{code_puppy-0.0.591 → code_puppy-0.0.592}/code_puppy/plugins/claude_code_oauth/auth_retry.py

@@ -127,14 +127,17 @@ async def handle_retryable_exception(
         return False
 
     emit_warning(
-        "Claude Code OAuth rejected the request — refreshing token before the retry…"
+        "Claude Code OAuth rejected the request — ensuring a fresh token "
+        "before the retry…"
     )
 
     # refresh_access_token does blocking network I/O; keep the loop free.
+    # (It has a built-in cooldown: if a refresh just happened, it reuses the
+    # still-warm token instead of burning another refresh-token rotation.)
     refreshed = await asyncio.to_thread(refresh_access_token, True)
     if refreshed:
         _broadcast_token(refreshed)
-        emit_info("Claude Code OAuth token refreshed.")
+        emit_info("Claude Code OAuth token ready; retrying.")
     else:
         # Still opt in: the HTTP client gets a fresh shot at recovery on the
         # next attempt (including its interactive reauthentication fallback).

{code_puppy-0.0.591 → code_puppy-0.0.592}/code_puppy/plugins/claude_code_oauth/utils.py

@@ -26,6 +26,14 @@ from .config import (
 TOKEN_REFRESH_BUFFER_SECONDS = 300
 MIN_REFRESH_BUFFER_SECONDS = 30
 
+# Cooldown for *forced* refreshes (seconds). Every refresh-token exchange
+# rotates the refresh token; hammering the endpoint during a flappy episode
+# (e.g. repeated Cloudflare 400s that a new token can't cure anyway) burns
+# through rotations for nothing and risks invalidating the token family.
+# If the stored tokens were refreshed within this window and are still
+# valid, force=True short-circuits to the existing access token.
+FORCE_REFRESH_COOLDOWN_SECONDS = 30
+
 logger = logging.getLogger(__name__)
 
 
@@ -213,6 +221,19 @@ def refresh_access_token(force: bool = False) -> Optional[str]:
     if not force and not is_token_expired(tokens):
         return tokens.get("access_token")
 
+    # Forced-refresh cooldown: a token minted seconds ago is as fresh as a
+    # new exchange would produce. Skip the rotation and reuse it.
+    if force and tokens.get("access_token") and not is_token_expired(tokens):
+        seconds_since_refresh = time.time() - float(tokens.get("refreshed_at") or 0)
+        if seconds_since_refresh < FORCE_REFRESH_COOLDOWN_SECONDS:
+            logger.info(
+                "Skipping forced token refresh (last refresh %.0fs ago, "
+                "cooldown %ds); reusing current access token",
+                seconds_since_refresh,
+                FORCE_REFRESH_COOLDOWN_SECONDS,
+            )
+            return tokens.get("access_token")
+
     refresh_token = tokens.get("refresh_token")
     if not refresh_token:
         logger.debug("No refresh_token available")
@@ -259,6 +280,7 @@ def refresh_access_token(force: bool = False) -> Optional[str]:
             if expires_in_value is not None:
                 tokens["expires_in"] = expires_in_value
                 tokens["expires_at"] = _calculate_expires_at(expires_in_value)
+            tokens["refreshed_at"] = time.time()
             if save_tokens(tokens):
                 update_claude_code_model_tokens(tokens["access_token"])
                 return tokens["access_token"]

{code_puppy-0.0.591 → code_puppy-0.0.592}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "code-puppy"
-version = "0.0.591"
+version = "0.0.592"
 description = "Code generation agent"
 readme = "README.md"
 requires-python = ">=3.11,<3.15"