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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-puppy
-Version: 0.0.593
+Version: 0.0.595
 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.593 → code_puppy-0.0.595}/code_puppy/agents/_key_listeners.py

@@ -200,6 +200,38 @@ def get_active_handle() -> Optional[KeyListenerHandle]:
         return _active_handle
 
 
+def acquire_listener(
+    stop_event: threading.Event,
+    on_escape: Callable[[], None],
+    on_cancel_agent: Optional[Callable[[], None]] = None,
+) -> tuple[Optional[KeyListenerHandle], bool]:
+    """Atomically reuse the live active listener or spawn + register one.
+
+    The historical bug: three call sites each did ``get_active_handle()``
+    → ``spawn_key_listener()`` → ``set_active_handle()`` as separate steps,
+    so two components racing through that window could both spawn — two
+    cbreak readers on one stdin, keystrokes split between them.
+
+    Returns:
+        ``(handle, spawned)`` — ``spawned`` is False when an existing live
+        listener was reused (the caller must NOT stop it). ``handle`` is
+        ``None`` (with ``spawned=True``) when stdin isn't a TTY.
+    """
+    global _active_handle
+    with _active_handle_lock:
+        existing = _active_handle
+        if (
+            existing is not None
+            and existing.thread.is_alive()
+            and not existing.stop_event.is_set()
+        ):
+            return existing, False
+        handle = spawn_key_listener(stop_event, on_escape, on_cancel_agent)
+        if handle is not None:
+            _active_handle = handle
+        return handle, True
+
+
 # =============================================================================
 # Spawn
 # =============================================================================
@@ -329,14 +361,24 @@ def _wait_while_suspended(
     Sets ``released_event`` (when given) to confirm we've parked. Polls
     every 50ms so we still respond to stop in a reasonable time.
 
+    The ack is LEVEL-triggered — re-asserted every lap — not edge-
+    triggered at park entry only. Rationale: back-to-back suspensions
+    (e.g. ``/resume``: one scope around ``handle_command``, another
+    around the picker) can resume+re-suspend within one 50ms poll lap.
+    The re-suspend clears ``released_event`` while we're STILL parked in
+    this loop (``suspend_event`` never read as clear), so an entry-only
+    ack would never be re-set and the new suspend would falsely time
+    out ("Key listener did not release stdin in time") even though
+    stdin was released the whole time.
+
     NOTE: we deliberately wait on ``stop_event`` (which is unset) rather
     than ``suspend_event`` (which IS set while we're parked here — waiting
     on it returns immediately and busy-spins, hogging the GIL and making
     raw-mode input prompts feel laggy while the listener is suspended).
     """
-    if released_event is not None:
-        released_event.set()
     while suspend_event.is_set() and not stop_event.is_set():
+        if released_event is not None:
+            released_event.set()
         stop_event.wait(timeout=0.05)
 
 
@@ -656,9 +698,18 @@ def suspended_key_listener(timeout: float = 1.0) -> Iterator[None]:
         if _suspend_depth == 1 and handle is not None:
             is_outermost = True
     if is_outermost:
-        # Best-effort suspend; if it doesn't release in time we just
-        # carry on quietly rather than spamming the user with a warning.
-        handle.suspend(timeout=timeout)
+        # A silently-failed suspend means the caller launches its own stdin
+        # reader (prompt_toolkit, input()) while the listener is STILL in
+        # cbreak mode — two readers, keystrokes split between them. Give
+        # the listener one extended grace period, then warn loudly so the
+        # flakiness is at least diagnosable instead of "sometimes my keys
+        # vanish".
+        if not handle.suspend(timeout=timeout):
+            if not handle.released_event.wait(timeout=2.0):
+                emit_warning(
+                    "Key listener did not release stdin in time; "
+                    "input may be flaky until this prompt closes."
+                )
     try:
         yield
     finally:
@@ -671,6 +722,7 @@ def suspended_key_listener(timeout: float = 1.0) -> Iterator[None]:
 
 __all__ = [
     "KeyListenerHandle",
+    "acquire_listener",
     "get_active_handle",
     "get_line_editor",
     "set_active_handle",

{code_puppy-0.0.593 → code_puppy-0.0.595}/code_puppy/agents/_runtime.py

@@ -19,7 +19,6 @@ 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
@@ -82,7 +81,6 @@ from code_puppy.agents._run_signals import (
 from code_puppy.agents.event_stream_handler import event_stream_handler
 from code_puppy.callbacks import (
     on_agent_exception,
-    on_agent_retryable_exception,
     on_agent_run_cancel,
     on_agent_run_context,
     on_agent_run_end,
@@ -268,37 +266,9 @@ def should_retry_streaming(exc: Exception) -> bool:
     return any(_is_retryable_one(e) for e in _walk_cause_chain(exc))
 
 
-async def _plugin_says_retry(
-    exc: Exception,
-    model_name: Optional[str],
-    attempt: int,
-    max_attempts: int,
-) -> bool:
-    """Ask ``agent_retryable_exception`` hooks whether ``exc`` is retryable.
-
-    Gives plugins a chance to (a) classify provider-specific failures the
-    core classifier can't know about and (b) perform recovery work (e.g. an
-    OAuth token refresh) before the retry fires. Any truthy result means
-    retry. Hook machinery failures are swallowed: a broken plugin must never
-    turn a genuine error into a hang, nor a retryable blip into a crash.
-    """
-    try:
-        results = await on_agent_retryable_exception(
-            exc,
-            model_name=model_name,
-            attempt=attempt,
-            max_attempts=max_attempts,
-        )
-    except Exception:  # pragma: no cover - defensive
-        return False
-    return any(bool(r) for r in results)
-
-
 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.
 
@@ -308,48 +278,34 @@ def streaming_retry(
     get the exception type, message, traceback, and which attempt it was. The
     on-disk log is the only way to measure the upstream-blip rate after the
     classifier silently absorbs it.
-
-    Exceptions the built-in classifier rejects get one more chance via the
-    ``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:
-            streak = 0  # consecutive rapid failures
-            while True:
-                attempt_started = time.monotonic()
+            last_exc: Optional[Exception] = None
+            for attempt in range(max_attempts):
                 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, streak + 1, max_attempts
-                    ):
+                    if not should_retry_streaming(exc):
                         raise
-                    if made_progress:
-                        streak = 0
-                    streak += 1
+                    last_exc = exc
                     log_error(
                         exc,
                         context=(
                             f"streaming_retry: transient exception on attempt "
-                            f"{streak}/{max_attempts}"
+                            f"{attempt + 1}/{max_attempts}"
                         ),
                     )
-                    if 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:
                         log_error(
                             exc,
                             context=(
@@ -360,15 +316,8 @@ def streaming_retry(
                         emit_error(
                             f"\u274c Streaming failed after {max_attempts} attempts"
                         )
-                        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)
+            assert last_exc is not None  # loop always sets this before exiting
+            raise last_exc
 
         return runner
 
@@ -482,6 +431,16 @@ def _collect_exceptions(
 # ---- The main entry point ---------------------------------------------------
 
 
+# Depth of in-flight ``run_with_mcp`` calls. Only touched from the main
+# event loop's thread (every run is awaited on the same loop), so a plain
+# int is race-free. Depth > 0 at entry means a NESTED run — e.g. the
+# shell_safety plugin assessing a command while the primary agent runs.
+# Nested runs must NOT touch process-wide interactive state: the
+# PauseController (it would drain the user's queued steers!), the SIGINT
+# handler, the shell cancel bridge, or the key-listener cancel hotkey.
+_active_run_depth = 0
+
+
 async def run_with_mcp(
     agent: Any,
     prompt: str,
@@ -491,13 +450,48 @@ async def run_with_mcp(
     output_type: Optional[Type[Any]] = None,
     **kwargs: Any,
 ) -> Any:
-    """Run ``agent`` against ``prompt`` with full MCP + cancellation support."""
+    """Run ``agent`` against ``prompt`` with full MCP + cancellation support.
+
+    Thin depth-tracking wrapper: nested calls (a run started while another
+    run is already in flight on this loop) skip the interactive-state
+    plumbing — see ``_active_run_depth``.
+    """
+    global _active_run_depth
+    is_nested_run = _active_run_depth > 0
+    _active_run_depth += 1
+    try:
+        return await _run_with_mcp_impl(
+            agent,
+            prompt,
+            attachments=attachments,
+            link_attachments=link_attachments,
+            output_type=output_type,
+            is_nested_run=is_nested_run,
+            **kwargs,
+        )
+    finally:
+        _active_run_depth -= 1
+
+
+async def _run_with_mcp_impl(
+    agent: Any,
+    prompt: str,
+    *,
+    attachments: Optional[Sequence[BinaryContent]] = None,
+    link_attachments: Optional[Sequence[Union[ImageUrl, DocumentUrl]]] = None,
+    output_type: Optional[Type[Any]] = None,
+    is_nested_run: bool = False,
+    **kwargs: Any,
+) -> Any:
+    """Body of :func:`run_with_mcp` (depth bookkeeping lives in the wrapper)."""
 
     # Scrub any stale PauseController state from a previously-cancelled run
     # BEFORE we touch the prompt or build the agent. The controller is a
     # process-wide singleton; without this guard a leftover steer queue
-    # would silently poison this run.
-    reset_pause_state_at_run_start()
+    # would silently poison this run. NEVER from a nested run: the "stale"
+    # steers it would drain are the OUTER run's live ones.
+    if not is_nested_run:
+        reset_pause_state_at_run_start()
 
     prompt = _sanitize_prompt(prompt)
     group_id = str(uuid.uuid4())
@@ -542,7 +536,7 @@ async def run_with_mcp(
         # the non-streaming fallback render.
         skip_fallback_render = on_should_skip_fallback_render(agent)
 
-        @streaming_retry(model_name=agent.get_model_name())
+        @streaming_retry()
         async def _call() -> Any:
             return await pydantic_agent.run(
                 prompt_to_use,
@@ -582,7 +576,7 @@ async def run_with_mcp(
         # between ``agent.run()`` calls below — additive, won't interrupt
         # in-progress work.
         async def _follow_up_run(follow_up_prompt: Any) -> Any:
-            @streaming_retry(model_name=agent.get_model_name())
+            @streaming_retry()
             async def _call_follow_up() -> Any:
                 return await pydantic_agent.run(
                     follow_up_prompt,
@@ -766,10 +760,12 @@ async def run_with_mcp(
     # Bridge the cancel callback to the shell SIGINT handler so a single
     # Ctrl+C while shells are running stops the whole agent/sub-agent swarm
     # (kill shells, then cancel every task) instead of only killing the
-    # current batch of shells.
+    # current batch of shells. Nested runs must not clobber the outer
+    # run's bridge (clear_agent_cancel in their finally would disarm it).
     from code_puppy.tools import command_runner as _command_runner
 
-    _command_runner.register_agent_cancel(schedule_agent_cancel)
+    if not is_nested_run:
+        _command_runner.register_agent_cancel(schedule_agent_cancel)
 
     def keyboard_interrupt_handler(_sig, _frame):
         # Let input() handle its own KeyboardInterrupt if we're mid-prompt.
@@ -820,27 +816,25 @@ async def run_with_mcp(
     run_usage_output_tokens: Optional[int] = None
 
     try:
-        if cancel_agent_uses_signal():
-            original_handler = signal.signal(signal.SIGINT, keyboard_interrupt_handler)
-            cancel_cb: Optional[Callable[[], None]] = None  # SIGINT owns cancel
-        else:
-            original_handler = signal.signal(signal.SIGINT, graceful_sigint_handler)
-            cancel_cb = schedule_agent_cancel
-        # Key listener: with the persistent prompt (Phase A) a REPL-
-        # lifetime listener already owns stdin — just arm the per-run
-        # cancel hotkey on it. Otherwise (headless -r, classic prompt,
-        # embeds) spawn a per-run listener exactly as before.
-        existing_handle = _key_listeners.get_active_handle()
-        if (
-            existing_handle is not None
-            and existing_handle.thread.is_alive()
-            and not existing_handle.stop_event.is_set()
-        ):
-            using_persistent_listener = True
-            _key_listeners.set_cancel_handler(cancel_cb)
-        else:
+        # Nested runs (e.g. shell_safety mid-run) leave the SIGINT handler
+        # and cancel hotkey alone — the outer run owns them, and cancelling
+        # the outer task propagates into this awaited one anyway.
+        if not is_nested_run:
+            if cancel_agent_uses_signal():
+                original_handler = signal.signal(
+                    signal.SIGINT, keyboard_interrupt_handler
+                )
+                cancel_cb: Optional[Callable[[], None]] = None  # SIGINT owns cancel
+            else:
+                original_handler = signal.signal(signal.SIGINT, graceful_sigint_handler)
+                cancel_cb = schedule_agent_cancel
+            # Key listener: with the persistent prompt (Phase A) a REPL-
+            # lifetime listener already owns stdin — just arm the per-run
+            # cancel hotkey on it. Otherwise (headless -r, classic prompt,
+            # embeds) spawn a per-run listener. ``acquire_listener`` makes
+            # the reuse-or-spawn decision atomic (no double-reader race).
             key_listener_stop_event = threading.Event()
-            key_listener_handle = _key_listeners.spawn_key_listener(
+            handle, spawned = _key_listeners.acquire_listener(
                 key_listener_stop_event,
                 # Ctrl+X: command_runner installs a dynamic handler via
                 # _key_listeners.set_escape_handler() while shell commands
@@ -848,10 +842,11 @@ async def run_with_mcp(
                 on_escape=lambda: None,
                 on_cancel_agent=cancel_cb,
             )
-            # Publish the handle so other stdin consumers (prompt_toolkit
-            # menus, TUIs) can suspend/resume the listener while they take
-            # over stdin.
-            _key_listeners.set_active_handle(key_listener_handle)
+            if spawned:
+                key_listener_handle = handle
+            else:
+                using_persistent_listener = True
+                _key_listeners.set_cancel_handler(cancel_cb)
 
         result = await agent_task
         run_success = True
@@ -868,22 +863,27 @@ async def run_with_mcp(
     except asyncio.CancelledError:
         run_response_text = ""
         agent_task.cancel()
-        drain_pause_state_on_cancel()
+        # Nested runs never drain: the pending steers belong to the outer
+        # run, whose own cancel path (or run end) handles them.
+        if not is_nested_run:
+            drain_pause_state_on_cancel()
     except KeyboardInterrupt:
         run_response_text = ""
         if not agent_task.done():
             agent_task.cancel()
-        drain_pause_state_on_cancel()
+        if not is_nested_run:
+            drain_pause_state_on_cancel()
     except Exception as e:
         run_error = e
         raise
     finally:
-        try:
-            from code_puppy.tools import command_runner as _command_runner
+        if not is_nested_run:
+            try:
+                from code_puppy.tools import command_runner as _command_runner
 
-            _command_runner.clear_agent_cancel()
-        except Exception:
-            pass
+                _command_runner.clear_agent_cancel()
+            except Exception:
+                pass
         try:
             await on_agent_run_end(
                 agent_name=agent.name,

{code_puppy-0.0.593 → code_puppy-0.0.595}/code_puppy/callbacks.py

@@ -8,7 +8,6 @@ PhaseType = Literal[
     "shutdown",
     "invoke_agent",
     "agent_exception",
-    "agent_retryable_exception",
     "version_check",
     "edit_file",
     "create_file",
@@ -64,7 +63,6 @@ _callbacks: Dict[PhaseType, List[CallbackFunc]] = {
     "shutdown": [],
     "invoke_agent": [],
     "agent_exception": [],
-    "agent_retryable_exception": [],
     "version_check": [],
     "edit_file": [],
     "create_file": [],
@@ -330,23 +328,6 @@ async def on_agent_exception(exception: Exception, *args, **kwargs) -> List[Any]
     return await _trigger_callbacks("agent_exception", exception, *args, **kwargs)
 
 
-async def on_agent_retryable_exception(
-    exception: Exception, *args, **kwargs
-) -> List[Any]:
-    """Ask plugins whether an exception the core classifier rejected is retryable.
-
-    Fired from the main agent retry loop (``streaming_retry``) when
-    ``should_retry_streaming`` says an exception is NOT transient. Plugins
-    receive ``(exception, model_name=..., attempt=..., max_attempts=...)`` and
-    may perform recovery work (e.g. refreshing an OAuth token) before
-    answering. Any truthy result opts the exception into the standard retry
-    schedule (delays, banner, error-log, attempt cap).
-    """
-    return await _trigger_callbacks(
-        "agent_retryable_exception", exception, *args, **kwargs
-    )
-
-
 async def on_version_check(*args, **kwargs) -> List[Any]:
     return await _trigger_callbacks("version_check", *args, **kwargs)
 

{code_puppy-0.0.593 → code_puppy-0.0.595}/code_puppy/claude_cache_client.py

@@ -440,15 +440,8 @@ class ClaudeCacheAsyncClient(httpx.AsyncClient):
                 if response.status_code == 400:
                     is_auth_error = await self._is_cloudflare_html_error(response)
                     if is_auth_error:
-                        # 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,
+                        logger.info(
+                            "Detected Cloudflare 400 error (likely auth-related), attempting token refresh"
                         )
 
                 if is_auth_error:

{code_puppy-0.0.593 → code_puppy-0.0.595}/code_puppy/messaging/run_ui.py

@@ -148,6 +148,10 @@ def stop_run_ui() -> None:
             # The UI outlives the run — just drop back to idle routing.
             _run_active = False
             _clear_status_row()
+            # Self-heal: if the REPL-lifetime listener died mid-run (its
+            # thread crashed, or a per-run listener replaced-then-stopped
+            # it), typing at the idle prompt would be dead forever.
+            _ensure_persistent_listener_locked()
             return
         editor = _editor
         _editor = None
@@ -403,17 +407,52 @@ def _spawn_persistent_listener() -> None:
         from code_puppy.agents import _key_listeners
     except ImportError:
         return  # no listener infra: prompt still works via nothing-to-feed
-    if _key_listeners.get_active_handle() is not None:
-        return  # someone else owns stdin already
     stop_event = threading.Event()
-    handle = _key_listeners.spawn_key_listener(stop_event, on_escape=lambda: None)
-    if handle is None:
+    # Atomic reuse-or-spawn: if someone else already owns stdin we back
+    # off (spawned=False) and deliberately do NOT record their handle as
+    # ours — stop_persistent_ui must never stop a listener it didn't spawn.
+    handle, spawned = _key_listeners.acquire_listener(
+        stop_event, on_escape=lambda: None
+    )
+    if handle is None or not spawned:
         return
-    _key_listeners.set_active_handle(handle)
     with _lock:
         _listener_handle = handle
 
 
+def _ensure_persistent_listener_locked() -> None:
+    """Respawn the persistent listener if it died. Caller holds ``_lock``.
+
+    Never raises — this runs on ``finally`` teardown paths.
+    """
+    global _listener_handle
+    handle = _listener_handle
+    if (
+        handle is not None
+        and handle.thread.is_alive()
+        and not handle.stop_event.is_set()
+    ):
+        return  # healthy
+    try:
+        from code_puppy.agents import _key_listeners
+    except ImportError:
+        return
+    try:
+        # Drop the stale registration (if it's still ours) so
+        # acquire_listener doesn't refuse to spawn over a corpse.
+        if handle is not None and _key_listeners.get_active_handle() is handle:
+            _key_listeners.set_active_handle(None)
+        _listener_handle = None
+        stop_event = threading.Event()
+        new_handle, spawned = _key_listeners.acquire_listener(
+            stop_event, on_escape=lambda: None
+        )
+        if new_handle is not None and spawned:
+            _listener_handle = new_handle
+    except Exception:
+        logger.debug("persistent listener respawn failed", exc_info=True)
+
+
 # =============================================================================
 # Slash-command consumer (Phase 5)
 # =============================================================================

{code_puppy-0.0.593 → code_puppy-0.0.595}/code_puppy/plugins/claude_code_oauth/README.md

@@ -156,10 +156,6 @@ claude_code_oauth/
 
 - The plugin assumes Anthropic continues to expose the shared `claude-cli` OAuth client
 - Tokens are refreshed on subsequent API calls if the service returns refresh tokens
-- Auth failures (401/403, or Cloudflare HTML 400s) that escape the HTTP client's
-  per-request refresh trigger an automatic token refresh and ride the main agent
-  retry loop via the `agent_retryable_exception` hook (see `auth_retry.py`) —
-  same delays and attempt cap as a 429, so users aren't interrupted
 - Models are prefixed with `claude-code-` to avoid collisions with other Anthropic models
 
 ## Contributing

{code_puppy-0.0.593 → code_puppy-0.0.595}/code_puppy/plugins/claude_code_oauth/register_callbacks.py

@@ -23,7 +23,6 @@ from code_puppy.provider_identity import (
 )
 
 from ..oauth_puppy_html import oauth_failure_html, oauth_success_html
-from .auth_retry import handle_retryable_exception, register_runtime_token_updater
 from .config import CLAUDE_CODE_OAUTH_CONFIG, get_token_storage_path
 from .fast_mode import (
     FAST_SETTING_KEY,
@@ -457,9 +456,6 @@ def _create_claude_code_model(model_name: str, model_config: Dict, config: Dict)
             custom_endpoint["api_key"] = access_token
 
     client.set_token_update_callback(_update_runtime_token)
-    # Also track the updater so agent-level auth-retry (auth_retry.py) can
-    # broadcast a refreshed token into this live client before re-running.
-    register_runtime_token_updater(_update_runtime_token)
     patch_anthropic_client_messages(anthropic_client)
     # Fast mode wrapper sits outside cache-control injector and re-reads
     # the setting on every call so /claude-code-fast takes effect live.
@@ -548,7 +544,6 @@ async def _on_agent_run_end(
             logger.debug("Error stopping token refresh heartbeat: %s", exc)
 
 
-register_callback("agent_retryable_exception", handle_retryable_exception)
 register_callback("custom_command_help", _custom_help)
 register_callback("custom_command", _handle_custom_command)
 register_callback("register_model_type", _register_model_types)

{code_puppy-0.0.593 → code_puppy-0.0.595}/code_puppy/plugins/claude_code_oauth/utils.py

@@ -26,14 +26,6 @@ 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__)
 
 
@@ -221,19 +213,6 @@ 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")
@@ -280,7 +259,6 @@ 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"]