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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-puppy
-Version: 0.0.591
+Version: 0.0.593
 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.593}/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.593}/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.593}/code_puppy/plugins/claude_code_oauth/auth_retry.py

@@ -15,12 +15,20 @@ and return ``True`` so the exception rides the **main agent retry loop**
 (``streaming_retry``) — the same delays, banners, error-logging, and
 attempt cap as a 429. The loop's ``max_attempts`` bounds us, so a dead
 refresh token can't spin forever.
+
+Recovery escalation ladder for Cloudflare HTML 400s specifically:
+refresh-token exchanges only buy temporary recovery (the edge starts
+flapping again minutes later), while a full interactive re-auth durably
+cures it. So the first CF400 gets the cheap refresh+retry; a recurrence
+within ``CLOUDFLARE_REAUTH_WINDOW_SECONDS`` escalates to the browser
+sign-in flow before retrying.
 """
 
 from __future__ import annotations
 
 import asyncio
 import logging
+import time
 from typing import Any, Callable, Iterator, Optional
 from weakref import WeakSet
 
@@ -34,6 +42,17 @@ logger = logging.getLogger(__name__)
 AUTH_STATUS_CODES = frozenset({401, 403})
 CLOUDFLARE_400_MARKERS = ("cloudflare", "400 bad request")
 
+# Cloudflare 400s are only *durably* cured by a full interactive re-auth
+# (field evidence: refresh-token exchanges buy temporary recovery, then the
+# edge starts flapping again; a browser sign-in stops it entirely). The
+# first CF400 gets the cheap refresh+retry. A recurrence within this window
+# proves refresh isn't curing it, so we escalate to the browser flow.
+CLOUDFLARE_REAUTH_WINDOW_SECONDS = 900.0  # 15 minutes
+
+# Monotonic timestamp of the last Cloudflare-400 recovery attempt.
+# Module-level: recurrence is a per-process pattern, not per-run.
+_last_cloudflare_event_at: float = 0.0
+
 # Live-client token updaters, registered when a claude_code model is built.
 # Weak references: entries vanish automatically when a model is torn down
 # (the client holds the only strong ref to its updater closure).
@@ -101,6 +120,25 @@ def is_claude_auth_error(exc: BaseException) -> bool:
     return False
 
 
+def is_cloudflare_error(exc: BaseException) -> bool:
+    """True when any link in the chain is specifically a Cloudflare 400."""
+    return any(
+        _is_cloudflare_400(link, _status_code_of(link))
+        for link in _iter_exception_chain(exc)
+    )
+
+
+def _run_full_reauthentication(model_name: str) -> Optional[str]:
+    """Launch the interactive browser OAuth flow; returns a token or None.
+
+    Lazy import: register_callbacks imports this module at load time, so a
+    top-level import here would be circular.
+    """
+    from .register_callbacks import _reauthenticate_after_expired_oauth
+
+    return _reauthenticate_after_expired_oauth(model_name)
+
+
 async def handle_retryable_exception(
     exception: Exception, *args: Any, **kwargs: Any
 ) -> bool:
@@ -126,15 +164,45 @@ async def handle_retryable_exception(
         )
         return False
 
+    # Cloudflare 400s that keep recurring are not cured by refresh-token
+    # exchanges (field-proven); only a full interactive re-auth stops them.
+    global _last_cloudflare_event_at
+    if is_cloudflare_error(exception):
+        now = time.monotonic()
+        recurring = (
+            _last_cloudflare_event_at > 0
+            and (now - _last_cloudflare_event_at) < CLOUDFLARE_REAUTH_WINDOW_SECONDS
+        )
+        _last_cloudflare_event_at = now
+        if recurring:
+            emit_warning(
+                "Cloudflare keeps rejecting requests and token refresh isn't "
+                "curing it — escalating to full browser re-authentication…"
+            )
+            token = await asyncio.to_thread(_run_full_reauthentication, model_name)
+            if token:
+                _broadcast_token(token)
+                _last_cloudflare_event_at = 0.0  # cured; future CF400s start fresh
+                emit_info("Claude Code re-authentication complete; retrying.")
+                return True
+            emit_warning(
+                "Re-authentication did not produce a usable token. "
+                "Run /claude-code-auth manually."
+            )
+            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.593}/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.593}/pyproject.toml

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