Skip to content
TheChatArchiveThe Chat Archive
composer-2.5· unknownHugging Face ibragim-bad/swe_rebench_07_2026_trajectories

auth: spurious REFRESHGENERATIONS bump on early-cancel in coalescedrunrefreshcmd Summary…

  1. User

    auth: spurious _REFRESH_GENERATIONS bump on early-cancel in _coalesced_run_refresh_cmd

    Summary

    _coalesced_run_refresh_cmd in src/notebooklm/_auth/refresh.py (moved from src/notebooklm/auth.py in tier-10 PR-B-high #814, but the code is byte-identical to origin/main since tier-9 E #803) can bump _REFRESH_GENERATIONS[refresh_key] even when no real refresh happened, in a narrow cancel-before-await race.

    Reproducer (race condition)

    1. Caller invokes await _coalesced_run_refresh_cmd(refresh_key, path, profile) from the cancel-recovery loop in _fetch_tokens_with_refresh.
    2. Task is cancelled in the window between try: and the first with _REFRESH_STATE_LOCK: block inside _coalesced_run_refresh_cmd — so NO future is registered in _REFRESH_INFLIGHT_BY_LOOP[loop][refresh_key].
    3. Control jumps to except asyncio.CancelledError: in the caller.
    4. registry.get(refresh_key) returns None.
    5. The inner if inflight is None or inflight.done(): is taken; the if inflight is not None: block is skipped; subprocess_exc stays None; break.
    6. Outer if subprocess_exc is not None: is False, so no raise.
    7. Generation is bumped at the with _REFRESH_STATE_LOCK: ... max(existing, refresh_generation + 1) line, even though no subprocess ran.
    8. Then if caller_cancelled: raise asyncio.CancelledError().

    Impact

    A concurrent waiter on a different event loop sharing the same refresh_key would observe the phantom generation bump on its lock-re-acquire path, treat the storage as freshly-refreshed, and skip its own _run_refresh_cmd — proceeding to build_httpx_cookies_from_storage against STALE on-disk state.

    Bounded blast radius: the stale-storage caller will fail again on the next token fetch and trigger its own real refresh. No data corruption. But it's a wasted round-trip.

    Suggested fix (from CodeRabbit on PR #814)

    Track whether inflight was ever non-None during the cancel-recovery loop. Only bump generation if subprocess_exc is None AND observed_inflight is True. Or per the alternative suggestion: raise immediately when inflight is None at the top of the cancel handler (the subprocess never registered, so we can't be the leader-cancel-before-await case for an actually-running refresh).

    Why not fixed in PR #814

    That PR's scope was "extract verbatim from auth.py into _auth/refresh.py + facade-forward". Changing async semantics was explicitly out of scope (must_not_do). Filing here for a dedicated follow-up.

    References

    Interface

    No new interfaces are introduced.

  2. Assistant

    I'll inspect the refresh coalescing code and its cancel-recovery path to implement the fix.

  3. Assistant

    Implementing the fix: re-raise CancelledError when no inflight future was registered, and adding a regression test.

  4. Assistant

    Verifying the new test fails without the fix:

  5. Assistant

    The test reproduces the bug. Restoring the fix.

  6. Assistant

    Fixed the early-cancel phantom generation bump in _fetch_tokens_with_refresh's cancel-recovery loop.

    Fix (src/notebooklm/_auth/refresh.py)

    Split the inflight is None and inflight.done() branches in the CancelledError handler:

    • inflight is None — cancellation happened before _coalesced_run_refresh_cmd registered an in-flight future, so no subprocess ran. Re-raise CancelledError immediately instead of falling through to the success path.
    • inflight.done() — unchanged: inspect the settled future's terminal state as before.

    This matches the CodeRabbit alternative from PR #814: if no future was ever registered, we can't be in the leader-cancel-during-subprocess case.

    Regression test (tests/integration/concurrency/test_refresh_cmd_race.py)

    Added test_early_cancel_before_inflight_register_does_not_bump, which gates _coalesced_run_refresh_cmd before it can register a future, cancels the caller, and asserts _REFRESH_GENERATIONS stays at 0. Confirmed it fails on the old code (generation bumps to 1) and passes with the fix.

    All 5 tests in test_refresh_cmd_race.py pass.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.