߲j UdZddlZddlZddlZGddZej ZiZee efe d<dZ dZ de fd Zd e d e d e de fd Zde defdZde dzde fdZde fdZej&dde dzfdZdde dzde fdZy)u&Human-wait accounting for :mod:`tools.approval` (per session). Tracks wall-clock time the agent spends verifiably blocked on a HUMAN prompt (CLI approval prompt, gateway approval round-trip). The concurrent tool batch deadline in agent/tool_executor.py excludes this time so a slow human answer never times a batch out — but ONLY this time. Measuring at the source (rather than residency in the authorization gate, which is arbitrary code) is what keeps a wedged pre_tool_call plugin or a dead approval client from growing the exclusion 1:1 with wall clock and defeating the deadline entirely. Keyed by session so one gateway session's pending approval cannot extend a different session's batch deadline; state is process-global like the rest of the approval state, bounded by _HUMAN_WAIT_MAX_SESSIONS. NceZdZdZddZy)_HumanWaitStatependingwindow_startedcompleted_secondsNc.d|_d|_d|_y)Nrr)selfs >/home/ubuntu/.hermes/hermes-agent/tools/approval_human_wait.py__init__z_HumanWaitState.__init__!s ,0!$)returnN)__name__ __module__ __qualname__ __slots__r rr rrs BI%rr_human_wait_statesgN@rcNddlm}t|jtzS)uMax seconds a single window may contribute: approvals.timeout + margin. Every legitimate human wait self-terminates at ``approvals.timeout`` (the CLI prompt join and the gateway poll loop both enforce it), so a window that overstays this ceiling is itself wedged and must not keep extending a batch deadline. Also the bound on the authorization gate's serialization-lock acquire in agent/tool_executor.py, so the two cannot drift. Never call while holding ``_human_wait_lock`` — it reads the config cache. ``_get_approval_timeout`` caps at ``agent.deadline.MAX_SAFE_TIMEOUT_S`` so the value is always safe for ``Lock.acquire(timeout=...)`` / ``Thread.join(timeout=...)``.rapproval_context)toolsrfloat_get_approval_timeoutHUMAN_WAIT_MARGIN_Srs r human_wait_ceilingr0s"' !779 :=P PPrstartednowceilingc4ttd||z |S)zSeconds an open window contributes: elapsed, floored at 0, capped. Shared by the close-time accrual and the open-window read so the two clamps stay identical by construction.r )minmax)rr r!s r _clamped_window_secondsr%>s s3g & 00r session_keyctj|}|]ttD]8}tttkrn t|j dk(s2t|=:t x}t|<|S)aReturn (creating if needed) the wait state for *session_key*. Caller must hold ``_human_wait_lock``. Evicts idle entries (no pending waiter) insertion-order-first until the table is under the cap so an army of short-lived session keys cannot grow it without bound. Entries with an open window are never evicted (that would corrupt live accounting), so the cap is best-effort under 256+ concurrently-pending sessions.r)rgetlistlen_HUMAN_WAIT_MAX_SESSIONSrr)r&statekeys r _human_wait_stater.Esv  " "; /E }*+ ,C%&)AA!#&..!3&s+  , 3B2CC";/ Lrc6||Sddlm}|jS)Nrr)rrget_current_session_key)r&rs r _resolve_keyr1Ws &  3 3 55rlabelcz ddlmtj}||dfdS#t$rdcYSwxYw)zCallable that pings the agent's inactivity tracker (at most every ~10s) while a human wait is parked, so the gateway watchdog does not kill the agent while the user is still answering. No-op in minimal tool-only environments.r)touch_activity_if_duecyNrrrr z$activity_heartbeat..esr) last_touchstartcSr6r)r2r,r4sr r7z$activity_heartbeat..hs(6r)tools.environments.baser4 Exceptiontime monotonic)r2r r,r4s` @@r activity_heartbeatr?^s@A .. C -E 66 s + ::c #Kt|}tj}t5t |}|j dk(r||_|xj dz c_ddd dtj}t}t5tj|}|a|xj dzc_|j dk(r=|j *|xjt|j ||z c_ d|_dddy#1swYxYw#1swYyxYw#tj}t}t5tj|}|a|xj dzc_|j dk(r=|j *|xjt|j ||z c_ d|_dddw#1swYwxYwxYww)aMark the enclosed block as time spent blocked on a human prompt. Wrap ONLY code that is genuinely parked waiting for a user's answer (the CLI approval prompt, the gateway approval poll loop). The concurrent tool batch deadline excludes this time; wrapping anything else re-creates the hang where arbitrary wedged code pushes the deadline out forever. Overlapping windows for the same session coalesce (pending counter), so two serialized approval prompts don't double-count the same wall clock. See #79719. rN) r1r=r>_human_wait_lockr.rrrrr(rr%)r&r-r r,r!s r human_wait_windowrCks { #C .. C !#& ==A #&E    0 nn%&  0&**3/E  " ==A%++7//3J5K_K_adfm3nn/+/E( 0 0 0 0 nn%&  0&**3/E  " ==A%++7//3J5K_K_adfm3nn/+/E( 0 0 0sf&G 7DG (D*,$G A9D G DG D'#G *%GA9G GG GG c6t|}tj}t}t5t j |}| dddy|j}|j|t|j||z }|cdddS#1swYyxYw)uReturn total human-wait seconds recorded for the session: completed windows plus the currently open one (if any). Monotonically non-decreasing for the life of the process — except when an idle session's entry is evicted under cap pressure, which can only shrink a consumer's baseline delta to zero (the safe direction: the deadline fires sooner). Deadline consumers snapshot a baseline at batch start and use the delta. Each window's contribution is clamped to :func:`human_wait_ceiling` (belt-and-braces against the wedged-window hang). Each window's contribution is clamped to :func:`human_wait_ceiling`: every legitimate human wait self-terminates at ``approvals.timeout`` (both the CLI prompt join and the gateway poll loop enforce it), so a window that overstays that bound is itself wedged and must not keep extending a batch deadline (belt-and-braces for #79719). Nr ) r1r=r>rrBrr(rrr%)r&r-r r!r,totals r human_wait_secondsrFs { #C .. C "G "&&s+ =''    + ,U-A-A3P PEsB3BBr6)__doc__ contextlib threadingr=rLockrBrdictstr__annotations__r+rrrr%r.r1r?contextmanagerrCrFrrr rOs  %%"9>>#13Do-.3 QE Q1U111513?$6cDj6S6 7c 7  03: 0 0FC$J%r