mirror of
https://github.com/NousResearch/hermes-agent.git
synced 2026-11-20 18:50:12 +03:00
fix(cli): a slash command typed after /queue X runs after X's turn
/queue X then /new (or /undo, /retry) typed during a turn: on main both sat in _pending_input in that order. With X in the owner's FIFO, the input loop took /new first; X's turn is adopted only once the owner's message.start arrives, so /new could detach the session and X ran in a session this terminal had left. The input loop now holds a local item while this viewer's own /queue admission is at the head of the owner's queue (gateway_queue .OwnQueueHold). A turn the owner runs meanwhile (the adopted admission, a notification header) runs first; the held item runs once that admission was taken or left the queue. The wait is bounded: an unknown row (a paused FIFO) never starts a hold, an idle list beyond the one a settling turn publishes ends it, and OWN_QUEUE_HOLD_S (2 s) caps it. The admission itself is never touched. Refs #134889 (N5)
This commit is contained in:
@@ -30,15 +30,24 @@ class CLITuiRuntimeMixin:
|
||||
|
||||
def _tui_process_loop(self):
|
||||
"""REPL worker thread: drain ``_pending_input``, run idle housekeeping, dispatch each input."""
|
||||
held = None
|
||||
while not self._should_exit:
|
||||
try:
|
||||
if held is not None:
|
||||
held, user_input = self._tui_hold_step(held)
|
||||
if user_input is not None:
|
||||
self._tui_process_one_input(user_input)
|
||||
continue
|
||||
try:
|
||||
user_input = self._pending_input.get(timeout=0.1)
|
||||
except queue.Empty:
|
||||
if not self._agent_running:
|
||||
self._tui_idle_tick()
|
||||
continue
|
||||
self._tui_process_one_input(user_input)
|
||||
from hermes_cli.gateway_queue import OwnQueueHold
|
||||
held = OwnQueueHold.begin(self, user_input)
|
||||
if held is None:
|
||||
self._tui_process_one_input(user_input)
|
||||
except Exception as e:
|
||||
if isinstance(e, OSError) and e.errno == errno.EIO:
|
||||
self._mark_terminal_io_broken("process_loop")
|
||||
@@ -46,6 +55,20 @@ class CLITuiRuntimeMixin:
|
||||
continue
|
||||
logger.warning("process_loop unhandled error (msg may be lost): %s", e)
|
||||
|
||||
def _tui_hold_step(self, hold):
|
||||
"""One step of holding a local input behind this viewer's own ``/queue`` admission (#134889 N5):
|
||||
``(hold or None, input to run now or None)``. A turn the owner runs now goes first; the held
|
||||
input runs once that admission was taken, left the queue, or the bounded wait ran out."""
|
||||
with suppress(Exception):
|
||||
self._drain_process_notifications("cli-idle") # adopts the admission on its message.start
|
||||
item = hold.take_gateway_turn(self._pending_input)
|
||||
if item is not None:
|
||||
return hold, item
|
||||
if hold.done():
|
||||
return None, hold.item
|
||||
time.sleep(0.05)
|
||||
return hold, None
|
||||
|
||||
def _tui_idle_tick(self):
|
||||
"""Idle housekeeping between inputs (agent not running)."""
|
||||
self._check_config_mcp_changes() # auto-reload MCP on mcp_servers change
|
||||
|
||||
@@ -107,6 +107,95 @@ def published_queue(cli, store) -> list[str]:
|
||||
return [str(row.get("text") or "") for row in rows if row.get("status") == "queued"] + fresh
|
||||
|
||||
|
||||
# How long the input loop holds a local input behind this viewer's own ``/queue`` admission at most.
|
||||
OWN_QUEUE_HOLD_S = 2.0
|
||||
|
||||
|
||||
def _own_head(state):
|
||||
"""This viewer's ``/queue`` admission at the head of the owner's queue, not yet adopted; None when
|
||||
the head is someone else's, nothing is queued, or the FIFO is paused on an ``unknown`` row."""
|
||||
rows = [row for row in state.pending or () if isinstance(row, dict)]
|
||||
if any(row.get("status") == "unknown" for row in rows):
|
||||
return None # paused until the owner resolves that row: never hold typing behind it
|
||||
queued = sorted((row for row in rows if row.get("status") == "queued" and row.get("admission_id")),
|
||||
key=lambda row: int(row.get("sequence") or 0))
|
||||
if queued:
|
||||
head = queued[0]["admission_id"]
|
||||
else: # submitted after the last published list (``published_queue``'s fresh rows)
|
||||
listed = {row.get("admission_id") for row in rows}
|
||||
head = next((a for a in state.queued_inputs
|
||||
if a not in listed and state.queued_at.get(a, -1) >= state.pending_seq), None)
|
||||
return head if head in state.queued_inputs and head not in state.adopted else None
|
||||
|
||||
|
||||
class OwnQueueHold:
|
||||
"""A local input (a slash command, a typed turn) taken while this viewer's own ``/queue`` admission
|
||||
is the owner's next turn. On main both sat in ``_pending_input`` in entry order; now the admission
|
||||
is in the owner's FIFO and its turn is adopted only when the owner's ``message.start`` arrives, so
|
||||
the input loop holds the local item until that admission was taken (or left the queue).
|
||||
|
||||
Bounded: an ``unknown`` row (a paused FIFO) never starts a hold; an owner that publishes an idle
|
||||
list still queuing it (beyond the one a just-settled turn publishes before its claim) releases it;
|
||||
and ``OWN_QUEUE_HOLD_S`` caps the wait. The admission itself is never touched.
|
||||
"""
|
||||
|
||||
def __init__(self, item, state, admission):
|
||||
import time
|
||||
self.item, self.state, self.admission = item, state, admission
|
||||
self.seq = state.pending_seq
|
||||
# A turn the owner reports running settles with one idle list (still queuing this admission)
|
||||
# before its drain claims it: that list is expected, a further one means the FIFO is paused.
|
||||
self.allowed_idle_lists = 1 if state.info.get("running") else 0
|
||||
self.idle_lists = 0
|
||||
self.deadline = time.monotonic() + OWN_QUEUE_HOLD_S
|
||||
self.taken = False
|
||||
|
||||
@classmethod
|
||||
def begin(cls, cli, item):
|
||||
from cli import _SeededQueryMessage
|
||||
from hermes_cli.gateway_tools_notify import gateway_store
|
||||
from tools.process_registry_notifications import TimelineNotification
|
||||
if getattr(cli, "_agent_running", False) or isinstance(item, (_SeededQueryMessage, TimelineNotification)):
|
||||
return None # a turn the owner already runs (or a seeded prompt) is never held
|
||||
store = gateway_store(cli) if getattr(cli, "session_id", None) else None
|
||||
if store is None:
|
||||
return None
|
||||
state = _state(cli, store)
|
||||
admission = _own_head(state)
|
||||
return cls(item, state, admission) if admission else None
|
||||
|
||||
def take_gateway_turn(self, pending):
|
||||
"""Pop a turn the owner is running now (an adopted admission, a notification header) from the
|
||||
head of ``_pending_input``: those run before the held item, typed items stay behind it."""
|
||||
from tools.process_registry_notifications import TimelineNotification
|
||||
with pending.mutex:
|
||||
if not pending.queue:
|
||||
return None
|
||||
head = pending.queue[0]
|
||||
if not (getattr(head, "admission_id", None) or isinstance(head, TimelineNotification)):
|
||||
return None
|
||||
pending.queue.popleft()
|
||||
pending.unfinished_tasks = max(0, pending.unfinished_tasks - 1)
|
||||
if getattr(head, "admission_id", None) == self.admission:
|
||||
self.taken = True
|
||||
return head
|
||||
|
||||
def done(self) -> bool:
|
||||
import time
|
||||
if self.taken or time.monotonic() >= self.deadline:
|
||||
return True
|
||||
state = self.state
|
||||
if _own_head(state) != self.admission:
|
||||
# Adopted: its item is at the head of ``_pending_input``, taken on the next step. Otherwise
|
||||
# it started unseen (the idle tick recovers it), was cancelled, or is no longer next.
|
||||
return self.admission not in state.adopted
|
||||
if state.pending_seq != self.seq:
|
||||
self.seq = state.pending_seq
|
||||
if not state.info.get("running"):
|
||||
self.idle_lists += 1
|
||||
return self.idle_lists > self.allowed_idle_lists # idle and still not claiming it: stop waiting
|
||||
|
||||
|
||||
STARTED_REFUSALS = frozenset({"stale_generation", "admission_started"})
|
||||
|
||||
|
||||
|
||||
@@ -590,3 +590,94 @@ def test_a_steer_that_falls_back_to_queue_is_a_gateway_admission_and_images_stay
|
||||
_busy_enter(local, "queue", "plain")
|
||||
assert local._pending_input.get_nowait() == "plain"
|
||||
|
||||
|
||||
|
||||
def _run_loop(cli, until):
|
||||
"""Run main's ``_tui_process_loop`` in a thread; returns ``(processed, stop)``."""
|
||||
import threading
|
||||
import time
|
||||
processed = []
|
||||
|
||||
def one(item):
|
||||
processed.append((time.monotonic(), item))
|
||||
if len(processed) >= until:
|
||||
cli._should_exit = True
|
||||
cli._should_exit = False
|
||||
cli._tui_process_one_input = one
|
||||
cli._tui_idle_tick = lambda: cli._drain_process_notifications("cli-idle")
|
||||
thread = threading.Thread(target=cli._tui_process_loop, daemon=True)
|
||||
thread.start()
|
||||
|
||||
def stop(timeout):
|
||||
thread.join(timeout)
|
||||
cli._should_exit = True
|
||||
thread.join(2)
|
||||
return processed, stop
|
||||
|
||||
|
||||
def test_probe_slash_command_typed_after_queue_runs_after_it():
|
||||
"""Review round 2, major 2: ``/queue X`` then ``/new`` typed while busy. On main both sat in
|
||||
``_pending_input`` in that order; with X in the owner's FIFO the input loop must still run X first,
|
||||
not let ``/new`` detach the session before the owner claims X."""
|
||||
from tests.waiting import wait_until
|
||||
from tests.hermes_cli.test_gateway_agent import SID, frame
|
||||
from tests.hermes_cli.test_gateway_tools_notify import _connected, _idle_cli
|
||||
conn, client = _connected()
|
||||
try:
|
||||
cli = _idle_cli(conn)
|
||||
state = conn.state(SID)
|
||||
state.queued_inputs["adm-q"] = TEXT
|
||||
state.apply_event("session.info", {"running": True, "pending": [
|
||||
{"admission_id": "adm-1", "status": "started", "sequence": 1, "text": "turn"},
|
||||
{"admission_id": "adm-q", "status": "queued", "sequence": 2, "text": TEXT}]})
|
||||
cli._pending_input.put("/new") # typed while the CLI's turn ran; that turn just returned
|
||||
processed, stop = _run_loop(cli, 2)
|
||||
wait_until(lambda: cli._pending_input.empty(), timeout=5) # the loop took /new and holds it
|
||||
# The owner settles the turn, then claims X.
|
||||
frames = [frame("session.info", {"running": False, "pending": [
|
||||
{"admission_id": "adm-q", "status": "queued", "sequence": 2, "text": TEXT}]}, admission=None),
|
||||
frame("message.start", {}, admission="adm-q")]
|
||||
|
||||
async def put(): # not _play: the held loop consumes the frames as they land
|
||||
for item in frames:
|
||||
await client.events.put(item)
|
||||
asyncio.run_coroutine_threadsafe(put(), conn.loop).result(5)
|
||||
stop(5)
|
||||
order = [str(item) for _, item in processed]
|
||||
assert order == [TEXT, "/new"], f"input loop runs {order[0]!r} before the /queue prompt"
|
||||
assert getattr(processed[0][1], "admission_id", None) == "adm-q"
|
||||
finally:
|
||||
conn.close()
|
||||
|
||||
|
||||
@pytest.mark.parametrize("pending, running", [
|
||||
([{"admission_id": "adm-0", "status": "unknown", "sequence": 1, "text": "lost"},
|
||||
{"admission_id": "adm-q", "status": "queued", "sequence": 2, "text": TEXT}], False),
|
||||
([{"admission_id": "adm-q", "status": "queued", "sequence": 2, "text": TEXT}], False),
|
||||
([{"admission_id": "adm-q", "status": "queued", "sequence": 2, "text": TEXT}], True),
|
||||
])
|
||||
def test_typing_stays_responsive_when_the_owner_queue_is_paused(pending, running):
|
||||
"""The hold is bounded: a FIFO paused on an ``unknown`` row runs a typed command at once, and an owner
|
||||
that never claims this viewer's admission (idle, or busy with someone else's turn) delays it by at
|
||||
most ``OWN_QUEUE_HOLD_S``; the admission stays queued, never dropped."""
|
||||
import time
|
||||
from hermes_cli.gateway_queue import OWN_QUEUE_HOLD_S
|
||||
from tests.hermes_cli.test_gateway_agent import SID
|
||||
from tests.hermes_cli.test_gateway_tools_notify import _connected, _idle_cli
|
||||
assert OWN_QUEUE_HOLD_S >= 2.0
|
||||
conn, _client = _connected()
|
||||
try:
|
||||
cli = _idle_cli(conn)
|
||||
state = conn.state(SID)
|
||||
state.queued_inputs["adm-q"] = TEXT
|
||||
state.apply_event("session.info", {"running": running, "pending": pending})
|
||||
started = time.monotonic()
|
||||
cli._pending_input.put("/help")
|
||||
processed, stop = _run_loop(cli, 1)
|
||||
stop(OWN_QUEUE_HOLD_S + 2)
|
||||
assert [str(item) for _, item in processed] == ["/help"]
|
||||
waited = processed[0][0] - started
|
||||
assert waited < (0.5 if pending[0]["status"] == "unknown" else OWN_QUEUE_HOLD_S + 1.0), waited
|
||||
assert state.queued_inputs == {"adm-q": TEXT}
|
||||
finally:
|
||||
conn.close()
|
||||
|
||||
Reference in New Issue
Block a user