Skip to content

The agent that grows with you

13.6 KB
Raw Blame
"""A notification turn the gateway admits while the classic CLI is idle reaches main's screen.

On main the CLI drained ``tools.process_registry`` itself and ran the ``[IMPORTANT: Background
process ...]`` turn. Over the session authority the process (and its completion) live in the
gateway, which admits and runs that turn on its own; the CLI viewer must paint main's
``◈ Background Process Finished: ...`` header and stream the turn's reply through the same callbacks.
"""
import asyncio
import queue
from types import SimpleNamespace
from unittest.mock import Mock

from hermes_cli.gateway_agent import GatewayAgent
from hermes_cli.gateway_connection import GatewayConnection
from hermes_cli.gateway_session_store import GatewaySessionStore
from tests.hermes_cli.test_gateway_agent import SID, FakeClient, connect_with, frame
from tests.waiting import wait_until

DISPLAY = "Background Process Finished: sleep 6; echo BGDONE"
MODEL_TEXT = "[IMPORTANT: Background process proc_1 completed (exit 0).\nOutput:\nBGDONE]"


def _gateway_frames():
    """What the authority publishes for one admitted local automation turn (admission adm-9)."""
    return [
        # _admitted -> _publish_pending: the queued row (its public input text) before any claim.
        {"jsonrpc": "2.0", "method": "event", "params": {
            "type": "session.info", "session_id": SID, "payload": {
                "running": False, "pending": [{"admission_id": "adm-9", "status": "queued", "input_id": "x", "text": MODEL_TEXT}]}}},
        frame("message.start", {"display_kind": "process_complete", "display_text": DISPLAY, "text": MODEL_TEXT},
              generation=9, admission="adm-9"),
        frame("message.delta", {"text": "STEP13 notified "}, generation=9, admission="adm-9"),
        frame("message.delta", {"text": "reply."}, generation=9, admission="adm-9"),
        frame("message.complete", {"text": "STEP13 notified reply.", "status": "complete"},
              generation=9, admission="adm-9"),
    ]


def _connected():
    client = FakeClient([])
    conn = GatewayConnection(connect=connect_with(client))
    conn.start(5)
    conn.state(SID)
    return conn, client


def _play(conn, client, frames):
    async def put():
        for item in frames:
            await client.events.put(item)
    asyncio.run_coroutine_threadsafe(put(), conn.loop).result(5)
    wait_until(lambda: conn.events.qsize() >= len(frames), timeout=5)


def _idle_cli(conn):
    from cli import HermesCLI
    cli = HermesCLI.__new__(HermesCLI)
    cli.session_id = SID
    cli._pending_input = queue.Queue()
    cli._session_db = GatewaySessionStore(connection=conn)
    cli._agent_running = False
    return cli


def test_idle_cli_paints_header_and_streams_the_gateway_admitted_turn(monkeypatch, capsys):
    conn, client = _connected()
    try:
        # The CLI process never owns the registry over the gateway: draining it is a bug.
        monkeypatch.setattr("tools.process_registry.process_registry", SimpleNamespace(
            drain_notifications=Mock(side_effect=AssertionError("CLI drained the process registry"))))
        cli = _idle_cli(conn)
        _play(conn, client, _gateway_frames())
        cli._drain_process_notifications("cli-idle")
        queued = cli._pending_input.get_nowait()
        assert cli._pending_input.empty()
        assert queued.display_kind == "process_complete" and queued.display_text == DISPLAY
        assert str(queued) == MODEL_TEXT

        # Main's input path renders the header exactly as for a local completion.
        for attr, value in {"_pending_resume_sessions": [], "_typed_voice_stop": lambda t: False,
                            "handle_bang_shell": lambda t: False, "_turn_summary_begin": lambda: None,
                            "_tui_after_turn": lambda: None, "_app": SimpleNamespace(invalidate=lambda: None),
                            "chat": Mock()}.items():
            setattr(cli, attr, value)
        cli._tui_process_one_input(queued)
        assert f"◈ {DISPLAY}" in capsys.readouterr().out
        message = cli.chat.call_args.args[0]
        assert message is queued

        # chat(): stage the row, then run_conversation pumps the ALREADY-admitted turn.
        deltas = []
        agent = GatewayAgent(connection=conn, session_id=SID, stream_delta_callback=deltas.append)
        cli.conversation_history = []
        cli._chat_stage_user_message(agent, message)
        result = agent.run_conversation(str(message), conversation_history=[])
        assert "prompt.submit" not in [method for method, _ in client.calls]
        assert deltas == ["STEP13 notified ", "reply."]
        assert result["final_response"] == "STEP13 notified reply."
        assert result["failed"] is False and result["interrupted"] is False
        assert ("prompt.receipt", {"session_id": SID, "admission_id": "adm-9", "include_result": True}) in client.calls
        assert result["messages"][0]["display_kind"] == "process_complete"
    finally:
        conn.close()


def test_adoption_is_one_shot_and_never_hijacks_a_typed_turn():
    conn, client = _connected()
    try:
        cli = _idle_cli(conn)
        _play(conn, client, _gateway_frames()[:2])
        cli._drain_process_notifications("cli-idle")
        assert not cli._pending_input.empty()
        # The user's own turn runs instead (e.g. chat() bailed before run_conversation): it submits.
        client.script = [frame("message.complete", {"text": "typed", "outcome": "completed"})]
        agent = GatewayAgent(connection=conn, session_id=SID)
        agent._pending_cli_user_message = {"role": "user", "content": "hello"}
        result = agent.run_conversation("hello")
        assert "prompt.submit" in [method for method, _ in client.calls]
        assert result["final_response"] == "typed"
        assert getattr(conn.state(SID), "admitted_turn", None) is None
    finally:
        conn.close()


def test_post_turn_adoption_runs_before_inputs_queued_behind_the_running_turn():
    conn, client = _connected()
    try:
        cli = _idle_cli(conn)
        cli._pending_input.put("typed while the last turn ran")
        _play(conn, client, _gateway_frames()[:2])
        cli._drain_process_notifications("cli-post-turn")
        first = cli._pending_input.get_nowait()
        assert getattr(first, "display_text", None) == DISPLAY
        assert cli._pending_input.get_nowait() == "typed while the last turn ran"
    finally:
        conn.close()


def test_idle_tick_without_an_admitted_turn_queues_nothing():
    conn, client = _connected()
    try:
        cli = _idle_cli(conn)
        _play(conn, client, [frame("session.usage", {"usage": {"api_calls": 1}}),
                             frame("message.complete", {"text": "late"}, admission="adm-old")])
        cli._drain_process_notifications("cli-idle")
        assert cli._pending_input.empty()
    finally:
        conn.close()


def test_stamp_claim_publishes_the_card_and_an_ordinary_claim_stays_empty():
    from gateway.session_authority import SessionAuthority
    from gateway.session_contract import SessionRef
    from gateway.session_events import SessionEvents
    published = []
    stream = SessionEvents()
    stream.publish = lambda sid, payload, *, event_type: published.append((event_type, payload))
    authority = SimpleNamespace(epoch=3, executing={}, _publish_pending=lambda ref: None)
    live = SimpleNamespace(event_stream=stream)
    ref = SessionRef("p", SID)
    automation = {"text": MODEL_TEXT, "local_automation_v1": {
        "identity": "i", "owner": SID, "route": "r", "target": SID,
        "display_kind": "process_complete", "display_text": DISPLAY}}
    SessionAuthority._stamp_claim(authority, ref, live, {"generation": 9, "admission_id": "adm-9", "payload": automation})
    SessionAuthority._stamp_claim(authority, ref, live, {"generation": 10, "admission_id": "adm-10",
                                                         "payload": {"text": "typed"}})
    assert published == [("message.start", {"display_kind": "process_complete", "display_text": DISPLAY,
                                            "text": MODEL_TEXT}), ("message.start", {})]


def test_claim_stamp_carries_the_automation_card_on_message_start():
    from gateway.session_automation import admission_display
    local = {"text": MODEL_TEXT, "local_automation_v1": {
        "identity": "i", "owner": SID, "route": "r", "target": SID,
        "display_kind": "process_complete", "display_text": DISPLAY}}
    assert admission_display(local) == {"display_kind": "process_complete", "display_text": DISPLAY,
                                        "text": MODEL_TEXT}
    diagnostic = {"text": "x", "native_text_v1": {"automation": {
        "display_kind": "process_complete", "display_text": DISPLAY, "notification_category": "diagnostic"}}}
    assert admission_display(diagnostic)["notification_category"] == "diagnostic"
    assert admission_display({"text": "typed by the user"}) == {}
    assert admission_display({"text": "x", "local_automation_v1": {"identity": "i"}}) == {}


def _delegation_completion(goal):
    return {"type": "async_delegation", "delegation_id": "deleg_1", "parent_session_id": SID,
            "goals": [goal], "results": [{"task_index": 0, "status": "completed", "summary": "Two nits.",
                                           "api_calls": 3, "duration_seconds": 12}]}


def _claim_card(evt, text):
    """The ``message.start`` card the gateway publishes for this LOCAL completion's admission: the
    producer's metadata, validated as ``snapshot_local_automation`` does, read back at the claim."""
    from gateway.config import Platform
    from gateway.run_notifications import _watch_notification_metadata
    from gateway.session import SessionSource
    from gateway.session_automation import admission_display, automation_display_metadata
    metadata = _watch_notification_metadata(evt, SessionSource(platform=Platform.LOCAL, chat_id=SID))
    descriptor = {"identity": "i", "owner": SID, "route": "r", "target": SID,
                  **automation_display_metadata(metadata)}
    return admission_display({"text": text, "local_automation_v1": descriptor})


def test_idle_cli_shows_a_gateway_review_subagents_completion(capsys):
    """``/review`` runs its reviewer as a gateway-side async delegation (#134889 M4/CLI-6). Its
    completion turn must reach an idle classic CLI as main's ``◈ Subagent Task ...`` header plus the
    streamed reply; a claim without the card was skipped and the result never shown."""
    from tools.process_registry_notifications import format_process_notification
    evt = _delegation_completion("Review the work just discussed")
    text = format_process_notification(evt)
    card = _claim_card(evt, text)
    conn, client = _connected()
    try:
        cli = _idle_cli(conn)
        _play(conn, client, [frame("message.start", card, generation=9, admission="adm-9"),
                             frame("message.delta", {"text": "Review: two nits."}, generation=9, admission="adm-9"),
                             frame("message.complete", {"text": "Review: two nits.", "status": "complete"},
                                   generation=9, admission="adm-9")])
        cli._drain_process_notifications("cli-idle")
        queued = cli._pending_input.get_nowait()
        assert queued.display_kind == "async_delegation_complete"
        assert queued.display_text == "Subagent Task Completed: Review the work just discussed"
        assert str(queued) == text
        for attr, value in {"_pending_resume_sessions": [], "_typed_voice_stop": lambda t: False,
                            "handle_bang_shell": lambda t: False, "_turn_summary_begin": lambda: None,
                            "_tui_after_turn": lambda: None, "_app": SimpleNamespace(invalidate=lambda: None),
                            "chat": Mock()}.items():
            setattr(cli, attr, value)
        cli._tui_process_one_input(queued)
        assert f"◈ {queued.display_text}" in capsys.readouterr().out
        deltas = []
        agent = GatewayAgent(connection=conn, session_id=SID, stream_delta_callback=deltas.append)
        cli.conversation_history = []
        cli._chat_stage_user_message(agent, queued)
        result = agent.run_conversation(str(queued), conversation_history=[])
        assert "prompt.submit" not in [method for method, _ in client.calls]
        assert deltas == ["Review: two nits."] and result["final_response"] == "Review: two nits."
    finally:
        conn.close()


def test_a_long_subagent_goal_still_admits_its_completion_card():
    """The card's title is bounded by the admission's display-text limit: an over-long goal must not
    turn the completion into an ``invalid_params`` refusal (a delivery that never lands)."""
    card = _claim_card(_delegation_completion("audit " * 1000), "model text")
    assert card["display_kind"] == "async_delegation_complete"
    assert card["display_text"].startswith("Subagent Task Completed: audit")


def test_idle_cli_prints_the_gateway_background_review_summary(capsys):
    """``/refine`` promises "any memory/skill updates will be reported when done" (#134889 M3): the
    gateway publishes the review's summary to the local session as ``review.summary`` after the turn
    settled. An idle classic CLI prints it (main's ``display.review.summary_cli`` line) instead of
    discarding it with the between-turn leftovers."""
    conn, client = _connected()
    try:
        cli = _idle_cli(conn)
        _play(conn, client, [frame("review.summary", {"text": "💾 Self-improvement review: Memory updated"},
                                   admission=None)])
        cli._drain_process_notifications("cli-idle")
        assert "  💾 Self-improvement review: Memory updated" in capsys.readouterr().out
        assert cli._pending_input.empty()  # a report, not a turn
    finally:
        conn.close()