yj<9^UdZddlmZddlZddlZddlZddlZddlZddlZddl m Z ddl m Z ej eZejZdaded<ejZdaded <dad Zd aehd Zd'd(dZd)dZd*dZd*dZd+dZ d,dZ!d dd-dZ"d.d#Z#d/d$Z$d/d%Z%d/d&Z&dS)0uWLocal-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)windows_hide_flags Optional[str] _CACHED_LINEzOptional[threading.Thread] _PROBE_THREADg$@F>sshmodaldockerdaytona singularity managed_modalvercel_sandbox@cmd list[str]timeoutfloatreturntuple[int, str, str]c 2 tj5}tj5} tj||||dtjt }n,#tj$rYdddddddSwxYw|d|d| dd }| dd }|j ||fcdddcdddS#1swxYwYddddS#1swxYwYdS#t$rYdSt$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)stdoutstderrrcheckstdin creationflagsN)rrzutf-8replace)rrz not foundrrz oserror: )tempfile TemporaryFile subprocessrunDEVNULLrTimeoutExpiredseekreaddecodestrip returncodeFileNotFoundErrorOSError)rrout_ferr_fresultouterrexcs 5/home/ragecks/.hermes/hermes-agent/tools/env_probe.py_runr4Qs&)  # % % /0F0H0H /E )#  #$, #5"6"6   , ) ) )(! / / / / / / / / / / / / / / ) JJqMMM JJqMMM**,,%%gy99??AAC**,,%%gy99??AAC$c3.+ / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / /, ###""" )))2(3((((((((()sE.E!E 1AE B,E - E!8 E.BB*E 0 E!< E. E E!E E! E.!E%%E.(E%)E.. F; FF FFbinarystrcrtj|sdSt|ddg\}}}|dkr|r|SdS)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}')rshutilwhichr4)r5rcr0r1s r3_python_version_ofr=sW <  t(JKLLLBS Qww3w 4boolchtj|sdSt|dddg\}}}|dkS)z/True if `` -m pip --version`` succeeds.Fz-mpip --versionrr9)r5r<_out_errs r3_has_pip_modulerEs> <  u64 <==NBd 7Nr>ctj|sdSd}t|d|g\}}}|dko|dkS)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')r8ryes)r:r;r4r))r5coder<r0rDs r3_detect_pep668rIs] <  u ; &$-..MBT 7 +syy{{e++r>cDtjdsdStddg\}}}|dks|sdSd|vrf|drQ |ddd}|ddS#t tf$rYdSwxYwdS) 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. rANrBrz(python )r)r:r;r4endswithrsplitr) IndexErrorAttributeError)r<r0rDtails r3_pip_python_versionrRs <  t%-..MBT QwwcwtSS\\#.. ::j!,,Q/D9??$$ $N+   44  4s7BBBctjdpd}|tvrdSt d}t d}|rt dnd}t}|rtdnd}tj ddu}t|o|o| | }|duo |o| o| p|}|rdSg} |r"d |} |s| d z } | | n| d |r||kr| d |n|s|r| d |r7|r| d|dn3|s| d|n|rn| d|r| d|r| d| sdSdd| 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_BACKENDSr=rErRrIr:r;r? startswithappendjoin) backendpy3_verpy_ver py3_has_pip pip_bound_to py3_pep668has_uvmismatchsilent_conditionsbitspy3_bits r3_build_probe_linerlsy((3G::<<BBDDG"""r ++G  ) )F07B/),,,UK&((L.5@ ***5J\$  t +F LUWUW5G5G 5U5U1UVVHt '  'L '^ %v  rD'&W&& * ) )G G %&&& 4&G## &f&&'''' 44 2333 #  7 KK@|@@@ A A A A 7 KK5|55 6 6 6 #  M"""4 2333 $ N### r $))D// 1C 77r>) force_refreshrmc|rHt5datdat dz adadddn #1swxYwYtr tpdStt rdnt}t |s+t s"dat dtdStpdS) 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. NrLFrg?)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)rm wait_timeouts r3get_environment_probe_liner{s'",  , ,L       M !OJ&+ #  , , , , , , , , , , , , , , ,"!r!2K448KL   L  1 1 ' &* # NN;#    r  2s*AAAgenintNonec6 t}n4#t$r'}td|d}Yd}~nd}~wwxYwt5|t kr ddddS|atddddS#1swxYwYdS)uDBody of the single probe thread — computes and publishes the line.zenv_probe failed: %srN) rl Exceptionrxdebugrorrrrpset)r|liner2s r3 _probe_workerr<s ""  +S111  *     s* A=A B&BBBcht5tr ddddSt'tr ddddSt jttfddat ddddS#1swxYwYdS)z?Start the probe worker if it isn't running and hasn't finished.Nz env-probeT)targetargsnamedaemon) rorprtris_alive threadingThreadrrrstartr>r3ruruKs,                    $)?)?)A)A $          "(                       sB'!B'r3warm_environment_probe_asyncr\sr>ct5datdat dz adaddddS#1swxYwYdS)u8Test helper — clear the cache between probe scenarios.NrLF)rorrprqrrrrsrr>r3_reset_cache_for_testsrjs ((  a "' ((((((((((((((((((s*?AA)r)rrrrrr)r5r6rr)r5r6rr?)rr)rr6)rmr?rr6)r|r}rr~)rr~)'__doc__ __future__rloggingrZr:r"r rtypingrhermes_cli._subprocess_compatr getLogger__name__rxLockror__annotations__Eventrprrrrvrs frozensetr]r4r=rErIrRrlr{rrurrrr>r3rs:#""""" <<<<<<  8 $ $in " """"io ,0 0000   9 -)-)-)-)-)`,,,,$0O8O8O8O8d9>******Z    "    ((((((r>