| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328 |
- """Prepare desktop terminal consent without running shells ahead of their turn.
- Workers keep execution middleware on its original stack. Only command approval
- runs ahead; the existing sequential executor releases each worker and persists
- its result before releasing the next. No terminal environment/cwd is acquired
- while preparing, and the real execution still runs every command guard.
- """
- from __future__ import annotations
- import contextvars
- import copy
- import threading
- import time
- from contextlib import contextmanager
- from typing import Any
- from tools.thread_context import propagate_context_to_thread
- _batch: contextvars.ContextVar[Any] = contextvars.ContextVar("terminal_approval_batch", default=None)
- _slot: contextvars.ContextVar[Any] = contextvars.ContextVar("terminal_approval_slot", default=None)
- class _CancelledPreparation(Exception):
- pass
- class _TerminalSlot:
- def __init__(self, batch, parsed, index):
- self.batch, self.parsed, self.index = batch, parsed, index
- self.ready = threading.Event()
- self.release = threading.Event()
- self.future: Any = None
- self.tids = []
- self.preparing = False
- self.args = None
- self.decision = None
- self.guard_key = None
- self.claimed = False
- def check_cancelled(self):
- if self.batch.cancelled.is_set() or self.batch.agent._interrupt_requested:
- raise _CancelledPreparation("Terminal approval preparation cancelled; command was not started")
- def prepare(self, ref):
- from tools import terminal_tool as tt
- self.check_cancelled()
- self.args = copy.deepcopy(ref.args)
- self.preparing = True
- try:
- # Read policy only. _plan_execution/_acquire_env resolve cwd and
- # shell state later, after the previous result has been persisted.
- config = tt._get_env_config()
- if isinstance(ref.args.get("command"), str):
- from tools.approval_context import set_current_observability_context, reset_current_observability_context
- tokens = set_current_observability_context(
- tool_call_id=ref.call_id, session_id=self.batch.agent.session_id or "",
- turn_id=getattr(self.batch.agent, "_current_turn_id", "") or "",
- )
- try:
- # Key on what will actually run: a foreground `cmd &` executes as `cmd`.
- command = ref.args["command"]
- if not ref.args.get("background"):
- command = tt.trailing_amp_background_command(command) or command
- self.guard_key = (command, config["env_type"], tt._docker_has_host_access(config))
- self.decision = tt._check_all_guards(*self.guard_key)
- finally:
- reset_current_observability_context(tokens)
- finally:
- self.preparing = False
- self.ready.set()
- while not self.release.wait(0.1):
- self.check_cancelled()
- self.check_cancelled()
- def run(self):
- from agent import tool_executor as te
- token = _slot.set(self)
- pc, batch = self.parsed, self.batch
- ref = pc.ref(batch.task_id)
- try:
- with te._registered_tool_worker(batch.agent) as tid:
- self.tids.append(tid)
- self.check_cancelled()
- dispatch = te._resolve_sequential_dispatch(batch.agent, ref, batch.messages)
- return te._run_agent_tool_execution_middleware(
- batch.agent, **ref.middleware_kwargs(), execute=dispatch.execute,
- scope_block=pc.scope_block, display_index=self.index + 1,
- authorization_gate=batch.authorization_gate,
- )
- finally:
- self.ready.set()
- _slot.reset(token)
- class _TerminalBatch:
- def __init__(self, agent, messages, task_id, parsed):
- from agent.tool_executor import _ConcurrentToolAuthorizationGate
- from tools.daemon_pool import DaemonThreadPoolExecutor
- self.agent, self.messages, self.task_id = agent, messages, task_id
- self.cancelled = threading.Event()
- self.pending_approvals = [] # guarded by tools.approval._lock
- self.authorization_gate = _ConcurrentToolAuthorizationGate()
- self.executor = DaemonThreadPoolExecutor(max_workers=len(parsed))
- self.slots = [_TerminalSlot(self, pc, i) for i, pc in enumerate(parsed)]
- # Set once ANY slot in the batch has published a failed result (or a
- # denied/blocked one). Informed consent is per the batch state the user
- # SAW: after a failure, a later slot's pre-collected approval no longer
- # describes the world its command will run in, so it must not be
- # consumed — the guard re-runs live instead (#113158).
- self.failure_seen = False
- def start(self):
- from agent.tool_executor import _resolve_sequential_tool_timeout
- for slot in self.slots:
- slot.check_cancelled()
- slot.future = self.executor.submit(propagate_context_to_thread(slot.run))
- timeout = _resolve_sequential_tool_timeout()
- started = time.monotonic()
- baseline = self.authorization_gate.excluded_seconds()
- # Proceed once the worker publishes a human request OR completes
- # preparation. A wedged plugin must not hold the batch forever.
- while not slot.ready.wait(0.1):
- slot.check_cancelled()
- elapsed = time.monotonic() - started - (self.authorization_gate.excluded_seconds() - baseline)
- if timeout is not None and elapsed >= timeout:
- raise TimeoutError("Terminal approval preparation timed out; commands were not started")
- def close(self):
- from agent.tool_executor import _interrupt_worker_tids
- from tools import approval
- # Withdraw only this batch's requests, including a worker wedged in
- # notify_cb. Thread interrupts alone leave those requests actionable.
- with approval._lock:
- self.cancelled.set()
- for session_key, entry in self.pending_approvals:
- queue = approval._gateway_queues.get(session_key, [])
- if entry in queue:
- queue.remove(entry)
- entry.result = "deny"
- entry.event.set()
- if not queue:
- approval._gateway_queues.pop(session_key, None)
- self.pending_approvals.clear()
- for slot in self.slots:
- slot.release.set()
- if slot.future is not None and not slot.future.done():
- _interrupt_worker_tids(self.agent, slot.tids)
- slot.future.cancel()
- self.executor.shutdown(wait=False, cancel_futures=True)
- def prepare_current_terminal(ref):
- slot = _slot.get()
- if slot is not None and ref.name == "terminal":
- slot.prepare(ref)
- def bind_prepared_dispatch(dispatch):
- """A middleware-owned thread must not lose the batch's execution barrier."""
- slot = _slot.get()
- if slot is None:
- return dispatch
- from agent.tool_executor import _registered_tool_worker
- owner_tid = threading.get_ident()
- def tracked(*args, **kwargs):
- if threading.get_ident() == owner_tid:
- return dispatch(*args, **kwargs)
- with _registered_tool_worker(slot.batch.agent) as tid:
- slot.tids.append(tid)
- slot.check_cancelled()
- return dispatch(*args, **kwargs)
- invoke = propagate_context_to_thread(tracked)
- # Each batch slot has exactly one dispatch. Reject concurrent/replayed
- # continuations before entering its captured Context on another thread.
- lock = threading.Lock()
- claimed = False
- def once(*args, **kwargs):
- nonlocal claimed
- with lock:
- if claimed:
- raise RuntimeError("Hermes tool execution callback invoked more than once")
- claimed = True
- return invoke(*args, **kwargs)
- return once
- def take_prepared_call(call_id):
- batch = _batch.get()
- if batch is None:
- return None
- for slot in batch.slots:
- if slot.parsed.ref(batch.task_id).call_id == call_id and not slot.claimed:
- slot.claimed = True
- slot.check_cancelled()
- slot.release.set()
- return slot
- return None
- def approval_published():
- slot = _slot.get()
- if slot is not None:
- slot.ready.set()
- def register_prepared_approval(session_key, entry):
- """Called under the approval queue lock, before enqueueing the request."""
- slot = _slot.get()
- if slot is not None:
- slot.check_cancelled()
- slot.batch.pending_approvals.append((session_key, entry))
- def consume_prepared_guard(command, env_type, has_host_access):
- slot = _slot.get()
- if slot is None or slot.preparing:
- return None
- slot.check_cancelled()
- # Re-gate after an earlier slot in the same batch failed (#113158): the
- # user approved a batch where every command was expected to run; once one
- # failed, that informed consent is stale for the commands after it, so
- # drop the pre-made decision and let the guard run its live flow
- # (allowlist, human approval). Nothing is auto-denied: an explicit
- # human answer still wins; the prepared (often auto/policy) decision is
- # simply not consumed.
- if slot.batch.failure_seen and slot.decision is not None:
- slot.decision = None
- return None
- from tools.approval_context import _approval_tool_call_id
- if (_approval_tool_call_id.get() != slot.parsed.ref(slot.batch.task_id).call_id
- or slot.guard_key != (command, env_type, has_host_access)):
- return None
- decision, slot.decision = slot.decision, None # single-use, even for identical calls
- # Batching exists to publish the human asks together. An approval nobody answered (/yolo,
- # approvals.mode off, the allowlist, a clean command) is policy, and the policy in force NOW
- # governs: switching YOLO or "Approvals: off" off mid-batch must stop the later commands.
- if decision is not None and decision.get("approved") and not decision.get("user_approved"):
- from tools.approval_context import _get_approval_mode
- if not (decision.get("smart_approved") and _get_approval_mode() == "smart"):
- return None
- return decision
- def preparing_terminal_approval():
- slot = _slot.get()
- return slot is not None and slot.preparing
- def mark_batch_outcome(failed: bool) -> None:
- """Record that the batch's current slot published a failed result.
- Called by the sequential publisher AFTER a result is committed, so the
- flag lands only for failures the model actually sees (a wedged worker's
- late result never publishes). Sticky for the batch: one failure re-gates
- every later prepared slot (#113158); successes leave it alone — a later
- success must not un-stale an approval after an even earlier failure.
- """
- batch = _batch.get()
- if batch is not None and failed:
- batch.failure_seen = True
- def validate_prepared_terminal(args):
- slot = _slot.get()
- if slot is not None:
- slot.check_cancelled()
- # Middleware/registry coercion must not turn a prepared consent into
- # authority for different arguments, even with identical display text.
- if args != slot.args:
- slot.decision = None
- raise RuntimeError("Terminal arguments changed after approval preparation; command was not started")
- def terminal_approval_runs(agent, calls):
- """Keep nonterminal barriers, but batch adjacent terminals in mixed segments."""
- from itertools import groupby
- from agent.tool_executor import _parse_tool_call
- def is_terminal(call):
- pc = _parse_tool_call(agent, call, flatten_probe=True)
- return pc.name == "terminal" and pc.parse_error is None
- for _, run in groupby(calls, key=is_terminal):
- yield list(run)
- @contextmanager
- def terminal_approval_batch(agent, calls, messages, task_id):
- from gateway.session_context import get_session_env
- from tools import approval
- from agent.tool_executor import _parse_tool_call
- if (len(calls) < 2 or get_session_env("HERMES_SESSION_SOURCE") != "desktop"
- or approval._gateway_notify_cb(approval.get_current_session_key()) is None):
- yield
- return
- parsed = [_parse_tool_call(agent, call, flatten_probe=True) for call in calls]
- # Never prepare across a nonterminal barrier; leave mixed segments and
- # malformed calls with the established sequential path.
- ids = [pc.ref(task_id).call_id for pc in parsed]
- if (any(pc.name != "terminal" or pc.parse_error is not None for pc in parsed)
- or not all(ids) or len(set(ids)) != len(ids)):
- yield
- return
- batch = _TerminalBatch(agent, messages, task_id, parsed)
- token = _batch.set(batch)
- try:
- if not agent._interrupt_requested and not getattr(agent, "_incremental_persistence_failed", False):
- try:
- batch.start()
- except (_CancelledPreparation, TimeoutError) as exc:
- batch.close()
- # A cancellation means a stop is already published (or our own
- # close() ran): re-interrupting would overwrite the user's queued
- # message/redirect. A timeout is a system stop: tool_reason only, no
- # message (callers re-queue _interrupt_message as the user's next turn).
- if isinstance(exc, TimeoutError):
- agent.interrupt(tool_reason="terminal batch preparation timeout")
- # The sequential path must still persist a result for every
- # assistant tool call, even if preparation never finished.
- yield
- finally:
- batch.close()
- _batch.reset(token)
|