The agent that grows with you
Python aiai-agentai-agentsanthropicchatgptclaudeclaude-codecodexhermeshermes-agentllmnous-researchopenai
"""Session ``/yolo``: the one toggle / restore / carry contract every surface calls.
The bypass itself is ``tools.approval``'s in-memory per-key set, so every process starts with it empty.
Each surface persists it where its session identity lives: CLI, TUI and Desktop on the session row
(``model_config.yolo_mode``), the messaging gateway on the routing entry, whose key outlives compression
rotations; sessions the gateway owns for CLI/TUI/Desktop clients (``config.set key=yolo``) and their managed
workers use that same routing entry. The surface hands its writer in as ``persist(enabled)``; everything else
is decided here, so the CLI ``/yolo``, the TUI Shift+Tab, the Desktop zap and a Telegram ``/yolo`` behave the same.
"""
import logging
from typing import Any, Callable, Optional
from tools import approval
logger = logging.getLogger(__name__)
Persist = Optional[Callable[[bool], Any]]
def _persist(persist: Persist, enabled: bool, session_key: str) -> None:
# Best-effort: the live flag is authoritative for this process; a failed write only costs the restore.
if persist is None:
return
try:
persist(enabled)
except Exception:
logger.warning("failed to persist session yolo=%s for %s", enabled, session_key, exc_info=True)
def toggle_session_yolo(session_key: str, enabled: Optional[bool] = None, *, persisted: bool = False,
persist: Persist = None) -> bool:
"""Flip (``enabled=None``) or set the bypass for *session_key*; returns the new state.
*persisted* is the stored flag: after a restart only it is set and the user still sees ON, so a toggle
turns it OFF. The write runs BEFORE the live flip, so a turn restoring in between never revives a
bypass that is being switched off.
"""
if enabled is None:
enabled = not (persisted or approval.is_session_yolo_enabled(session_key))
_persist(persist, enabled, session_key)
(approval.enable_session_yolo if enabled else approval.disable_session_yolo)(session_key)
return enabled
def restore_session_yolo(session_key: str, persisted: bool) -> bool:
"""Re-arm a persisted bypass in a fresh process; True when this call turned it on.
Key it on the id approvals are checked under (the stored session id / routing key), never a
transport-local id. Skipped under the frozen process ``--yolo``, which already bypasses everything.
"""
if (not session_key or not persisted or approval._YOLO_MODE_FROZEN
or approval.is_session_yolo_enabled(session_key)):
return False
approval.enable_session_yolo(session_key)
return True
def apply_launch_yolo(session_key: str) -> None:
"""Seed a gateway-owned session's launch ``--yolo`` policy once per session boundary.
Called every turn of such a route; only the first call (or the first after ``clear_session``) arms it,
so a later ``/yolo`` off sticks instead of lasting one turn. Skipped under the frozen process ``--yolo``.
"""
if not session_key or approval._YOLO_MODE_FROZEN:
return
with approval._lock:
if session_key in approval._launch_yolo_applied:
return
approval._launch_yolo_applied.add(session_key)
approval.enable_session_yolo(session_key)
def restore_gateway_yolo(session_key: str, persisted: Optional[bool], *, launch: bool = False) -> None:
"""Restore the authoritative routing value, including OFF, before frozen launch seeding.
``persisted`` None means nobody toggled this route: the ``--yolo`` launch policy (*launch*) is seeded
once per boundary instead, so an untouched entry never reads as a revocation.
"""
if not session_key:
return
if persisted is None:
if launch:
apply_launch_yolo(session_key)
return
with approval._lock:
if session_key in approval._launch_yolo_applied:
return # after restoration, the live toggle remains authoritative in this process
approval._launch_yolo_applied.add(session_key)
(approval._session_yolo.add if persisted else approval._session_yolo.discard)(session_key)
def transfer_session_yolo(old_key: str, new_key: str) -> None:
"""Move the live bypass when the conversation continues under a new id (compression rotation, /branch).
The new row records it at creation (``with_session_yolo``), so nothing is written here. Every
continuation site calls this, so it also moves the chat's MCP spend total: a rotation must not hand a
chat that spent its limit a fresh budget."""
from tools.mcp_tool_costs import transfer_session
transfer_session(old_key, new_key)
if not old_key or not new_key or old_key == new_key or not approval.is_session_yolo_enabled(old_key):
return
approval.enable_session_yolo(new_key)
approval.disable_session_yolo(old_key)
def with_session_yolo(model_config: Optional[dict], session_key: str) -> Optional[dict]:
"""``model_config`` for a session row being created, carrying a live bypass. Rows are created lazily on
the first turn, so this is where a toggle made before the row existed gets recorded."""
if not approval.is_session_yolo_enabled(session_key):
return model_config
return {**(model_config or {}), "yolo_mode": True}