`gj5^UdZddlmZddlZddlZddlZddlZddlZddlZddl Z ddl m Z eje Ze jZdaded<e j&Zdaded<dad Zd aehd Zddd Zdd ZddZddZddZddZ d dddZ!ddZ"d dZ#d dZ$d dZ%y)!uWLocal-environment toolchain probe for the system prompt. When the terminal backend is local (the agent's tools run on the same machine as Hermes itself), we surface a single deterministic line about Python tooling state so models don't have to discover it by hitting walls. Common failure modes this addresses: * Hermes ships under one Python (e.g. 3.11 in a bundled venv) while the user's login shell has a different one (e.g. 3.12 system). ``pip`` resolved from PATH may not match ``python3 -m pip``. * The bundled-venv Python has no pip module installed → ``python3 -m pip`` returns ``No module named pip``. * The system Python is PEP-668 externally-managed → naive ``pip install`` fails with ``error: externally-managed-environment``. The probe is cheap (a handful of subprocess calls, ~50ms total), cached for the lifetime of the process, and emits **at most one short line** when something non-default is detected. When the environment looks normal (python3+pip both present and matched, no PEP 668), it emits nothing — no token cost. Remote terminal backends (docker, modal, ssh, …) are skipped: the host's Python state is irrelevant when tools run inside a sandbox. The sandbox has its own existing probe (``_probe_remote_backend``) in ``agent/prompt_builder.py``. Toggle via ``agent.environment_probe`` in config.yaml (default True). ) annotationsN)Optional Optional[str] _CACHED_LINEzOptional[threading.Thread] _PROBE_THREADg$@F>sshmodaldockerdaytona singularity managed_modalc  tj5}tj5} tj||||dtj}|j d|j d|jjddj}|jjddj}|j||fcdddcdddS#tj $rYddddddywxYw#1swYnxYwdddy#1swYyxYw#t$rYyt$r}d d d |fcYd}~Sd}~wwxYw) uRun a short subprocess. Returns (returncode, stdout, stderr). Failures (binary missing, timeout, OSError) return (-1, "", ""). Output is captured through temporary files rather than ``capture_output`` pipes so ``timeout`` bounds the *whole* call — even on native Windows. A console-script launcher (e.g. ``pip.exe``) can spawn a descendant that inherits the captured stdout/stderr handles and outlives its parent. With OS pipes, the reader threads inside ``subprocess.communicate()`` then block until that descendant closes the write end — which the timeout does *not* cover, because killing the direct child leaves the grandchild holding the pipe. A whole warm probe could hang for ~28 min this way while holding ``_CACHE_LOCK``, wedging every new session's system-prompt build. Temp files have no reader threads, so ``wait()`` only ever waits on the direct child; a lingering grandchild holding the handle can't block us, and the probe genuinely fails open on timeout. F)stdoutstderrtimeoutcheckstdinN)rrzutf-8replace)rrz not foundrrz oserror: ) tempfile TemporaryFile subprocessrunDEVNULLTimeoutExpiredseekreaddecodestrip returncodeFileNotFoundErrorOSError)cmdrout_ferr_fresultouterrexcs B/root/.hermes/venv/lib/python3.12/site-packages/tools/env_probe.py_runr,OsD&)  # # % /0F0F0H /E )#  #$,,  JJqM JJqM**,%%gy9??AC**,%%gy9??AC$$c3.! / / /,, )( / / / ) / / / / /" #" )23%((()sD?D3D)C5B D" D3+ D?5DD D3D?DDD' #D3*D?3D<8D?<D?? E$ E$EE$E$cftj|syt|ddg\}}}|dk(r|r|Sy)zFReturn a short version string like ``3.12.4`` for ``binary``, or None.N-cz`import sys; print(f'{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}')rshutilwhichr,)binaryrcr(r)s r+_python_version_ofr4zsC << (JKLLBS Qw3 c^tj|syt|dddg\}}}|dk(S)z/True if `` -m pip --version`` succeeds.Fz-mpip --versionrr/)r2r3_out_errs r+_has_pip_moduler;s3 << 64 <=NBd 7Nr5ctj|syd}t|d|g\}}}|dk(xr|jdk(S)zTrue when ````'s install location is PEP-668 externally-managed. Looks for ``EXTERNALLY-MANAGED`` next to the stdlib (the marker file Debian/Ubuntu drop in to gate naive ``pip install``). Fzimport sys, os;stdlib = os.path.dirname(os.__file__);marker = os.path.join(stdlib, 'EXTERNALLY-MANAGED');print('yes' if os.path.exists(marker) else 'no')r.ryes)r0r1r,r )r2coder3r(r:s r+_detect_pep668r?sP <<  ; &$-.MBT 7 +syy{e++r5ctjdsytddg\}}}|dk7s|syd|vr:|jdr) |j ddd}|ddj Sy#t tf$rYywxYw) zIf ``pip`` is on PATH, return the Python version it's bound to. ``pip --version`` output looks like:: pip 24.0 from /usr/lib/python3/dist-packages/pip (python 3.12) Returns the parenthesised version (e.g. ``"3.12"``) or None. r7Nr8rz(python )r)r0r1r,endswithrsplitr IndexErrorAttributeError)r3r(r:tails r+_pip_python_versionrHs << %-.MBT QwcSS\\#. ::j!,Q/D9??$ $ N+  s'A//BBcrtjdxsdjj}|tvryt d}t d}|r t dnd}t}|r tdnd}tjddu}t|xr|xr|j| }|duxr|xr | xr| xs|}|ryg} |rd |} |s| d z } | j| n| jd |r||k7r| jd |n|s|r| jd |r/|r| jd|dn+|s)| jd|n|rn| jd|r| jd|r| jd| syddj| zdzS)uBuild the one-liner. Returns "" when nothing notable is detected. Emit only when SOMETHING is off — the goal is to save the model from hitting an avoidable wall, not to narrate a healthy environment. TERMINAL_ENVlocalrpython3pythonFuvNzpython3=z (no pip module)zpython3=missingzpython=zpython=missing (use python3)u pip→pythonz (mismatch)z pip=missingzPEP 668=yes (use venv or uv)z uv=installedzPython toolchain: z, .)osgetenvr lower_REMOTE_BACKENDSr4r;rHr?r0r1bool startswithappendjoin) backendpy3_verpy_ver py3_has_pip pip_bound_to py3_pep668has_uvmismatchsilent_conditionsbitspy3_bits r+_build_probe_linercsyy(3G::<BBDG"" +G  )F07/),UK&(L.5 *5J \\$ t +F LUWUW5G5G 5U1UVHt '  'L '^ %v  DWI& ) )G G %& &G# gfX&'  23  KK,|nK@ A KK,|n5 6   M" 23  N#  $))D/ 1C 77r5) force_refreshct|r2t5datjdat dz adadddtjr txsdStt rdnt}tj|s#t sdatjdtytxsdS#1swYxYw) uReturn the cached probe line (building it on first call). Returns "" when the environment is clean — the system prompt assembler should drop the section in that case rather than emit an empty heading. The probe itself always runs in a single background worker thread; this function waits on its completion event for at most ``_PROBE_WAIT_TIMEOUT`` seconds and then fails open with "". A wedged probe subprocess (#67964) therefore can never block system-prompt construction — at worst the toolchain line is absent from prompts built while the probe is stuck. ``force_refresh`` is for tests; real callers should never need it. NrBFrg?)rTzcenv_probe did not finish within %.0fs; building the system prompt without the Python toolchain line) _CACHE_LOCKr _PROBE_DONEclearr _PROBE_GEN_WAIT_ALREADY_TIMED_OUTis_set_ensure_probe_started_PROBE_WAIT_TIMEOUTwaitloggerwarning)rd wait_timeouts r+get_environment_probe_linerrs"  ,L     M !OJ&+ #  ,!r!248KL   L  1'&* # NN;#    21 , ,s $B..B7c t}t5|t k7r dddy|atjdddy#t$r"}tjd|d}Yd}~_d}~wwxYw#1swYyxYw)uDBody of the single probe thread — computes and publishes the line.zenv_probe failed: %srN) rc Exceptionrodebugrfrirrgset)genliner*s r+ _probe_workerry/sz "  *      +S1s' A A3A3 A0A++A03A<c*t5tjr dddyttj r dddyt j ttfddatjdddy#1swYyxYw)z?Start the probe worker if it isn't running and hasn't finished.Nz env-probeT)targetargsnamedaemon) rfrgrkris_alive threadingThreadryristartr5r+rlrl>s           $)?)?)A    "((      sB B  6B  Bcty)aKick off the probe in a background thread so the first system-prompt build doesn't pay the ~0.5s of subprocess calls (python3/pip/PEP-668 version checks) on the time-to-first-token critical path. Idempotent and fail-safe. The prompt-build call to ``get_environment_probe_line`` waits (bounded) on the same worker's completion event instead of recomputing. Called from agent init (all platforms); safe to call from anywhere. N)rlrr5r+warm_environment_probe_asyncrOs r5ct5datjdat dz adadddy#1swYyxYw)u8Test helper — clear the cache between probe scenarios.NrBF)rfrrgrhrrirjrr5r+_reset_cache_for_testsr]sA (  a "' (((s$4=)g@)r$z list[str]rfloatreturnztuple[int, str, str])r2strrr)r2rrrT)rr)rr)rdrTrr)rwintrNone)rr)&__doc__ __future__rloggingrPr0rsysrrtypingr getLogger__name__roLockrfr__annotations__Eventrgrrirmrj frozensetrSr,r4r;r?rHrcrrryrlrrrr5r+rs:#     8 $inn " m"ioo ,0 )0    ()V,$0I8X9>*Z " (r5