ei"UdZddlmZddlmZeZeed<edeZeed<edeZ eed <ed eZ eed <ed eZ eed <edeZ eed<edeZ eed<edeZeed<edeZeed<edeZeed<edeZeed<ee e e e e eeeed Z d+dedededed ed!ed"ed#efd$Zd%ed#d&fd'Zd,d(ed)ed#efd*Zd&S)-a Session-scoped context variables for the Hermes gateway. Replaces the previous ``os.environ``-based session state (``HERMES_SESSION_PLATFORM``, ``HERMES_SESSION_CHAT_ID``, etc.) with Python's ``contextvars.ContextVar``. **Why this matters** The gateway processes messages concurrently via ``asyncio``. When two messages arrive at the same time the old code did: os.environ["HERMES_SESSION_THREAD_ID"] = str(context.source.thread_id) Because ``os.environ`` is *process-global*, Message A's value was silently overwritten by Message B before Message A's agent finished running. Background-task notifications and tool calls therefore routed to the wrong thread. ``contextvars.ContextVar`` values are *task-local*: each ``asyncio`` task (and any ``run_in_executor`` thread it spawns) gets its own copy, so concurrent messages never interfere. **Backward compatibility** The public helper ``get_session_env(name, default="")`` mirrors the old ``os.getenv("HERMES_SESSION_*", ...)`` calls. Existing tool code only needs to replace the import + call site: # before import os platform = os.getenv("HERMES_SESSION_PLATFORM", "") # after from gateway.session_context import get_session_env platform = get_session_env("HERMES_SESSION_PLATFORM", "") ) ContextVar)Any_UNSETHERMES_SESSION_PLATFORM)default_SESSION_PLATFORMHERMES_SESSION_CHAT_ID_SESSION_CHAT_IDHERMES_SESSION_CHAT_NAME_SESSION_CHAT_NAMEHERMES_SESSION_THREAD_ID_SESSION_THREAD_IDHERMES_SESSION_USER_ID_SESSION_USER_IDHERMES_SESSION_USER_NAME_SESSION_USER_NAMEHERMES_SESSION_KEY _SESSION_KEY!HERMES_CRON_AUTO_DELIVER_PLATFORM_CRON_AUTO_DELIVER_PLATFORM HERMES_CRON_AUTO_DELIVER_CHAT_ID_CRON_AUTO_DELIVER_CHAT_ID"HERMES_CRON_AUTO_DELIVER_THREAD_ID_CRON_AUTO_DELIVER_THREAD_ID) rr r r rrrrrrplatformchat_id chat_name thread_iduser_id user_name session_keyreturnc ht|t|t|t|t |t |t|g}|S)a(Set all session context variables and return reset tokens. Call ``clear_session_vars(tokens)`` in a ``finally`` block to restore the previous values when the handler exits. Returns a list of ``Token`` objects (one per variable) that can be passed to ``clear_session_vars``. )rsetr r rrrr)rrrrr r!r"tokenss 9/home/div/.hermes/hermes-agent/gateway/session_context.pyset_session_varsr(Os$ h''W%%y))y))W%%y))%%F Mr&Nctttttt t fD]}|ddS)a+Mark session context variables as explicitly cleared. Sets all variables to ``""`` so that ``get_session_env`` returns an empty string instead of falling back to (potentially stale) ``os.environ`` values. The *tokens* argument is accepted for API compatibility with callers that saved the return value of ``set_session_vars``, but the actual clearing uses ``var.set("")`` rather than ``var.reset(token)`` to ensure the "explicitly cleared" state is distinguishable from "never set" (which holds the ``_UNSET`` sentinel). rN)rr r rrrrr%)r&vars r'clear_session_varsr,lsG       r)namercddl}t|}||}|tur|S|||S)uRead a session context variable by its legacy ``HERMES_SESSION_*`` name. Drop-in replacement for ``os.getenv("HERMES_SESSION_*", default)``. Resolution order: 1. Context variable (set by the gateway for concurrency-safe access). If the variable was explicitly set (even to ``""``) via ``set_session_vars`` or ``clear_session_vars``, that value is returned — **no fallback to os.environ**. 2. ``os.environ`` (only when the context variable was never set in this context — i.e. CLI, cron scheduler, and test processes that don't use ``set_session_vars`` at all). 3. *default* rN)os_VAR_MAPgetrgetenv)r-rr/r+values r'get_session_envr4sTIII ,,t  C     L 99T7 # ##r))rrrrrrr)r)__doc__ contextvarsrtypingrobjectr__annotations__rr r rrrrrrrr0strlistr(r,r4r)r'r=s$$$L#""""" fhh !+ +Df U U U:UUU)z*BFSSS*SSS!+,FPV!W!W!WJWWW!+,FPV!W!W!WJWWW)z*BFSSS*SSS!+,FPV!W!W!WJWWW%:&:FKKK jKKK+5*5Xbh*i*i*iZiii)34V`f)g)g)gJggg+5:6Zdj+k+k+kjkkk 1. 2 2. 2&)D(B*F         :t.$$#$$S$$$$$$r)