| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153 |
- """LSP diagnostics for a write, delivered after the write's tool result instead of inside it.
- ``write_file`` / ``patch`` return as soon as the bytes are on disk and verified; the language server
- check runs on the LSP loop (``agent.lsp.edit_check``). Its verdict is queued here under the session
- that made the edit (bound by ``tools.file_tools`` around the write) and handed to that session's agent
- at its next tool result, or its next user turn when no tool runs again
- (``agent.plugin_live_notes``: a new row not yet flushed, so no cached byte moves).
- A later edit of the same file takes over an undelivered verdict: the newer check diffs against the
- older baseline, so an error the first edit introduced is still reported unless the second fixed it.
- A verdict must not be lost when the edit was the turn's last tool call (a one-shot ``-q`` run has no
- next turn): checks still running are tracked per session (:func:`track_pending`), and before the turn's
- final answer is accepted :func:`settle_for_agent` waits for them (bounded) and returns every verdict
- still undelivered, which ``agent.turn_stop_gates`` hands to the model as a new message.
- """
- from __future__ import annotations
- import contextlib
- import threading
- from collections import OrderedDict
- from contextvars import ContextVar
- from dataclasses import dataclass
- from typing import Any, Iterator, Optional
- _OWNER: ContextVar[Optional[str]] = ContextVar("hermes_lsp_deferred_owner", default=None)
- _MAX_OWNERS = 64 # sessions that never drain (a one-shot caller) must not grow this forever
- _MAX_PER_OWNER = 32
- _LOCK = threading.Lock()
- _SETTLED = threading.Condition(_LOCK)
- # A turn-end wait longer than this hands the verdict to the next user turn instead.
- TURN_END_WAIT = 5.0
- @dataclass(frozen=True)
- class _Note:
- text: str
- baseline_text: Optional[str] # pre-edit content the verdict was diffed against
- # owner -> {abs path -> note}, oldest owner first
- _QUEUED: OrderedDict[str, OrderedDict[str, _Note]] = OrderedDict()
- # owner -> tokens of its checks still running (their verdict lands in _QUEUED or nowhere)
- _PENDING: dict[str, set[object]] = {}
- @contextlib.contextmanager
- def bind_owner(owner: Optional[str]) -> Iterator[None]:
- """Attribute writes in this block to ``owner`` (the session id, else the task id)."""
- token = _OWNER.set(owner or None)
- try:
- yield
- finally:
- _OWNER.reset(token)
- def current_owner() -> Optional[str]:
- return _OWNER.get()
- def post(owner: str, path: str, text: str, baseline_text: Optional[str]) -> None:
- """Queue ``text`` (a formatted diagnostics block) for ``owner``. A note still queued for ``path``
- (an older check finished while a newer one was starting) is kept in front, with its baseline."""
- with _LOCK:
- notes = _QUEUED.pop(owner, None) or OrderedDict()
- older = notes.pop(path, None)
- if older is not None and older.text != text:
- text, baseline_text = f"{older.text}\n\n{text}", older.baseline_text
- notes[path] = _Note(text, baseline_text)
- while len(notes) > _MAX_PER_OWNER:
- notes.popitem(last=False)
- _QUEUED[owner] = notes
- while len(_QUEUED) > _MAX_OWNERS:
- _QUEUED.popitem(last=False)
- def take(owner: Optional[str], path: str) -> Optional[_Note]:
- """Withdraw ``owner``'s undelivered note for ``path``: a newer edit of the file supersedes it and
- diffs against its ``baseline_text``. The newer check carries it and hands it back to
- :func:`restore` only if it ends with no verdict, so the older errors are not lost."""
- if not owner:
- return None
- with _LOCK:
- notes = _QUEUED.get(owner)
- return notes.pop(path, None) if notes else None
- def restore(owner: Optional[str], path: str, notes) -> None:
- """Queue ``notes`` (oldest first) withdrawn by :func:`take` again."""
- if owner:
- for note in notes:
- post(owner, path, note.text, note.baseline_text)
- def pop_notes(*owners: Optional[str]) -> list[tuple[str, str]]:
- """Every queued ``(path, text)`` for ``owners``, oldest first, and clear them."""
- out: list[tuple[str, str]] = []
- with _LOCK:
- for owner in dict.fromkeys(o for o in owners if o):
- notes = _QUEUED.pop(owner, None)
- if notes:
- out.extend((path, note.text) for path, note in notes.items())
- return out
- def track_pending(owner: str) -> object:
- """Record a check of ``owner``'s still running; pass the token to :func:`settled` once its verdict
- has been posted (or dropped)."""
- token = object()
- with _LOCK:
- _PENDING.setdefault(owner, set()).add(token)
- return token
- def settled(owner: str, token: object) -> None:
- with _SETTLED:
- tokens = _PENDING.get(owner)
- if tokens is not None:
- tokens.discard(token)
- if not tokens:
- del _PENDING[owner]
- _SETTLED.notify_all()
- def _owners(agent: Any) -> tuple[Optional[str], ...]:
- owners = (getattr(agent, "session_id", None), getattr(agent, "_current_task_id", None))
- return tuple(o if isinstance(o, str) else None for o in owners)
- def settle_for_agent(agent: Any, timeout: float = TURN_END_WAIT) -> list[tuple[str, str]]:
- """Turn end: wait up to ``timeout`` for ``agent``'s running checks, then pop every undelivered
- ``(path, text)`` verdict. Returns at once when nothing is running."""
- owners = [o for o in dict.fromkeys(_owners(agent)) if o]
- if not owners:
- return []
- with _SETTLED:
- _SETTLED.wait_for(lambda: not any(_PENDING.get(o) for o in owners), timeout=timeout)
- return pop_notes(*owners)
- def forward_to_agent(agent: Any) -> None:
- """Move ``agent``'s finished verdicts onto its live-notes queue, which rides the next tool result
- (or the next user turn). Called right before that tool result is built."""
- notes = pop_notes(*_owners(agent))
- if not notes:
- return
- from agent.plugin_live_notes import queue_plugin_notice
- for path, text in notes:
- queue_plugin_notice(agent, f"lsp:{path}", text)
- __all__ = ["TURN_END_WAIT", "bind_owner", "current_owner", "forward_to_agent", "pop_notes", "post", "restore",
- "settle_for_agent", "settled", "take", "track_pending"]
|