"""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}