mirror of
https://github.com/NousResearch/hermes-agent.git
synced 2026-07-27 17:58:07 +00:00
314 lines
12 KiB
Python
314 lines
12 KiB
Python
"""Tests for the subagent_stop hook event.
|
|
|
|
Covers wire-up from tools.delegate_tool.delegate_task:
|
|
* fires once per child in both single-task and batch modes
|
|
* runs on the parent thread (no re-entrancy for hook authors)
|
|
* carries child_role when the agent exposes _delegate_role
|
|
* carries child_role=None when _delegate_role is not set (pre-M3)
|
|
* exposes a detached, metadata-only tool_call_history
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import json
|
|
import threading
|
|
from unittest.mock import MagicMock, patch
|
|
|
|
import pytest
|
|
|
|
from tools.delegate_tool import _summarize_tool_arguments, delegate_task
|
|
from hermes_cli import plugins
|
|
|
|
|
|
def _make_parent(depth: int = 0, session_id: str = "parent-1"):
|
|
parent = MagicMock()
|
|
parent.base_url = "https://openrouter.ai/api/v1"
|
|
parent.api_key = "***"
|
|
parent.provider = "openrouter"
|
|
parent.api_mode = "chat_completions"
|
|
parent.model = "anthropic/claude-sonnet-4"
|
|
parent.platform = "cli"
|
|
parent.providers_allowed = None
|
|
parent.providers_ignored = None
|
|
parent.providers_order = None
|
|
parent.provider_sort = None
|
|
parent._session_db = None
|
|
parent._delegate_depth = depth
|
|
parent._active_children = []
|
|
parent._active_children_lock = threading.Lock()
|
|
parent._print_fn = None
|
|
parent.tool_progress_callback = None
|
|
parent.thinking_callback = None
|
|
parent._memory_manager = None
|
|
parent.session_id = session_id
|
|
return parent
|
|
|
|
|
|
@pytest.fixture(autouse=True)
|
|
def _fresh_plugin_manager():
|
|
"""Each test gets a fresh PluginManager so hook callbacks don't
|
|
leak between tests."""
|
|
original = plugins._plugin_manager
|
|
plugins._plugin_manager = plugins.PluginManager()
|
|
yield
|
|
plugins._plugin_manager = original
|
|
|
|
|
|
@pytest.fixture(autouse=True)
|
|
def _stub_child_builder(monkeypatch):
|
|
"""Replace _build_child_agent with a MagicMock factory so delegate_task
|
|
never transitively imports run_agent / openai. Keeps the test runnable
|
|
in environments without heavyweight runtime deps installed."""
|
|
def _fake_build_child(task_index, **kwargs):
|
|
child = MagicMock()
|
|
child._delegate_saved_tool_names = []
|
|
child._credential_pool = None
|
|
return child
|
|
|
|
monkeypatch.setattr(
|
|
"tools.delegate_tool._build_child_agent", _fake_build_child,
|
|
)
|
|
|
|
|
|
def _register_capturing_hook():
|
|
captured = []
|
|
|
|
def _cb(**kwargs):
|
|
kwargs["_thread"] = threading.current_thread()
|
|
captured.append(kwargs)
|
|
|
|
mgr = plugins.get_plugin_manager()
|
|
mgr._hooks.setdefault("subagent_stop", []).append(_cb)
|
|
return captured
|
|
|
|
|
|
# ── single-task mode ──────────────────────────────────────────────────────
|
|
|
|
|
|
class TestSingleTask:
|
|
def test_fires_once(self):
|
|
captured = _register_capturing_hook()
|
|
|
|
with patch("tools.delegate_tool._run_single_child") as mock_run:
|
|
mock_run.return_value = {
|
|
"task_index": 0,
|
|
"status": "completed",
|
|
"summary": "Done!",
|
|
"api_calls": 3,
|
|
"duration_seconds": 5.0,
|
|
"_child_role": "analyst",
|
|
}
|
|
delegate_task(goal="do X", parent_agent=_make_parent())
|
|
|
|
assert len(captured) == 1
|
|
payload = captured[0]
|
|
assert payload["child_role"] == "analyst"
|
|
assert payload["child_status"] == "completed"
|
|
assert payload["child_summary"] == "Done!"
|
|
assert payload["duration_ms"] == 5000
|
|
|
|
def test_fires_on_parent_thread(self):
|
|
captured = _register_capturing_hook()
|
|
main_thread = threading.current_thread()
|
|
|
|
with patch("tools.delegate_tool._run_single_child") as mock_run:
|
|
mock_run.return_value = {
|
|
"task_index": 0, "status": "completed",
|
|
"summary": "x", "api_calls": 1, "duration_seconds": 0.1,
|
|
"_child_role": None,
|
|
}
|
|
delegate_task(goal="go", parent_agent=_make_parent())
|
|
|
|
assert captured[0]["_thread"] is main_thread
|
|
|
|
def test_payload_includes_parent_session_id(self):
|
|
captured = _register_capturing_hook()
|
|
|
|
with patch("tools.delegate_tool._run_single_child") as mock_run:
|
|
mock_run.return_value = {
|
|
"task_index": 0, "status": "completed",
|
|
"summary": "x", "api_calls": 1, "duration_seconds": 0.1,
|
|
"_child_role": None,
|
|
}
|
|
delegate_task(
|
|
goal="go",
|
|
parent_agent=_make_parent(session_id="sess-xyz"),
|
|
)
|
|
|
|
assert captured[0]["parent_session_id"] == "sess-xyz"
|
|
|
|
|
|
# ── batch mode ────────────────────────────────────────────────────────────
|
|
|
|
|
|
class TestBatchMode:
|
|
def test_fires_per_child(self):
|
|
captured = _register_capturing_hook()
|
|
|
|
with patch("tools.delegate_tool._run_single_child") as mock_run:
|
|
mock_run.side_effect = [
|
|
{"task_index": 0, "status": "completed",
|
|
"summary": "A", "api_calls": 1, "duration_seconds": 1.0,
|
|
"_child_role": "role-a"},
|
|
{"task_index": 1, "status": "completed",
|
|
"summary": "B", "api_calls": 2, "duration_seconds": 2.0,
|
|
"_child_role": "role-b"},
|
|
{"task_index": 2, "status": "completed",
|
|
"summary": "C", "api_calls": 3, "duration_seconds": 3.0,
|
|
"_child_role": "role-c"},
|
|
]
|
|
delegate_task(
|
|
tasks=[
|
|
{"goal": "A"}, {"goal": "B"}, {"goal": "C"},
|
|
],
|
|
parent_agent=_make_parent(),
|
|
)
|
|
|
|
assert len(captured) == 3
|
|
roles = sorted(c["child_role"] for c in captured)
|
|
assert roles == ["role-a", "role-b", "role-c"]
|
|
|
|
def test_all_fires_on_parent_thread(self):
|
|
captured = _register_capturing_hook()
|
|
main_thread = threading.current_thread()
|
|
|
|
with patch("tools.delegate_tool._run_single_child") as mock_run:
|
|
mock_run.side_effect = [
|
|
{"task_index": 0, "status": "completed",
|
|
"summary": "A", "api_calls": 1, "duration_seconds": 1.0,
|
|
"_child_role": None},
|
|
{"task_index": 1, "status": "completed",
|
|
"summary": "B", "api_calls": 2, "duration_seconds": 2.0,
|
|
"_child_role": None},
|
|
]
|
|
delegate_task(
|
|
tasks=[{"goal": "A"}, {"goal": "B"}],
|
|
parent_agent=_make_parent(),
|
|
)
|
|
|
|
for payload in captured:
|
|
assert payload["_thread"] is main_thread
|
|
|
|
|
|
# ── payload shape ─────────────────────────────────────────────────────────
|
|
|
|
|
|
class TestPayloadShape:
|
|
def test_includes_redacted_tool_call_history(self):
|
|
captured = _register_capturing_hook()
|
|
|
|
with patch("tools.delegate_tool._run_single_child") as mock_run:
|
|
mock_run.return_value = {
|
|
"task_index": 0,
|
|
"status": "completed",
|
|
"summary": "wrote the report",
|
|
"api_calls": 1,
|
|
"duration_seconds": 0.1,
|
|
"tool_trace": [{
|
|
"tool": "write_file",
|
|
"args_bytes": 128,
|
|
"result_bytes": 32,
|
|
"status": "ok",
|
|
"input_summary": {
|
|
"argument_keys": ["content", "path", "token"],
|
|
"targets": {
|
|
"path": "/private/report.json",
|
|
"url": "https://user:password@example.test:8443/upload?token=secret",
|
|
"token": "must-not-leak",
|
|
},
|
|
},
|
|
"args": {"path": "/private/report.json"},
|
|
"result": "secret output",
|
|
}],
|
|
}
|
|
delegate_task(goal="do X", parent_agent=_make_parent())
|
|
|
|
assert captured[0]["tool_call_history"] == [{
|
|
"tool_name": "write_file",
|
|
"tool_input": {
|
|
"argument_keys": ["content", "path", "token"],
|
|
"targets": {
|
|
"path": "/private/report.json",
|
|
"url": "https://example.test:8443/upload",
|
|
},
|
|
},
|
|
"input_bytes": 128,
|
|
"output_bytes": 32,
|
|
"status": "ok",
|
|
}]
|
|
|
|
def test_tool_input_summary_keeps_targets_not_payloads(self):
|
|
summary = _summarize_tool_arguments(json.dumps({
|
|
"path": "/workspace/report.json",
|
|
"content": "private report contents",
|
|
"url": "https://user:password@example.test:8443/upload?token=secret#fragment",
|
|
"command": "curl -H 'Authorization: secret' example.test",
|
|
}))
|
|
|
|
assert summary == {
|
|
"argument_keys": ["command", "content", "path", "url"],
|
|
"targets": {
|
|
"path": "/workspace/report.json",
|
|
"url": "https://example.test:8443/upload",
|
|
},
|
|
}
|
|
|
|
def test_tool_call_history_is_detached_from_delegate_result(self):
|
|
def _mutating_hook(**kwargs):
|
|
kwargs["tool_call_history"][0]["status"] = "hook-mutated"
|
|
|
|
plugins.get_plugin_manager()._hooks.setdefault(
|
|
"subagent_stop", []
|
|
).append(_mutating_hook)
|
|
|
|
with patch("tools.delegate_tool._run_single_child") as mock_run:
|
|
mock_run.return_value = {
|
|
"task_index": 0,
|
|
"status": "completed",
|
|
"summary": "done",
|
|
"api_calls": 1,
|
|
"duration_seconds": 0.1,
|
|
"tool_trace": [{
|
|
"tool": "terminal",
|
|
"args_bytes": 10,
|
|
"result_bytes": 20,
|
|
"status": "ok",
|
|
"input_summary": {
|
|
"argument_keys": ["command"],
|
|
"targets": {},
|
|
},
|
|
}],
|
|
}
|
|
raw = delegate_task(goal="do X", parent_agent=_make_parent())
|
|
|
|
assert json.loads(raw)["results"][0]["tool_trace"][0]["status"] == "ok"
|
|
|
|
def test_role_absent_becomes_none(self):
|
|
captured = _register_capturing_hook()
|
|
|
|
with patch("tools.delegate_tool._run_single_child") as mock_run:
|
|
mock_run.return_value = {
|
|
"task_index": 0, "status": "completed",
|
|
"summary": "x", "api_calls": 1, "duration_seconds": 0.1,
|
|
# Deliberately omit _child_role — pre-M3 shape.
|
|
}
|
|
delegate_task(goal="do X", parent_agent=_make_parent())
|
|
|
|
assert captured[0]["child_role"] is None
|
|
|
|
def test_result_does_not_leak_child_role_field(self):
|
|
"""The internal _child_role key must be stripped before the
|
|
result dict is serialised to JSON."""
|
|
_register_capturing_hook()
|
|
|
|
with patch("tools.delegate_tool._run_single_child") as mock_run:
|
|
mock_run.return_value = {
|
|
"task_index": 0, "status": "completed",
|
|
"summary": "x", "api_calls": 1, "duration_seconds": 0.1,
|
|
"_child_role": "leaf",
|
|
}
|
|
raw = delegate_task(goal="do X", parent_agent=_make_parent())
|
|
|
|
parsed = json.loads(raw)
|
|
assert "results" in parsed
|
|
assert "_child_role" not in parsed["results"][0]
|