Files
openworker/tests/test_agent_tasks.py
Rohit Prasad 6daa7816d0 Subagents keep a full record, plus observability fixes (#852)
* subagents: durable child transcripts and audit rows

Each child's full message log persists beside the run record (last 50,
purged with the session, served on demand); child tool calls land in the
session audit log stamped with the task id.

* observability: fixes from the review of the recorder feature

Live-step batches retry a failed flush and stay bounded; the Issues checks
run outside the recorder lock and only the ended turn is re-sequenced;
same-millisecond ordering is causal (two flaky tests fixed at the root);
remote automations load their routing before resolving an unknown id.
2026-11-07 14:26:17 -08:00

312 lines
14 KiB
Python

"""Async subagents (OPE-254/255/258): spawn in the background, report back, and keep
the human the only approver — an expired approval wait resolves as declined and SAYS so
in the child's tool result.
"""
from __future__ import annotations
import asyncio
import time
import aisuite as ai
import pytest
from coworker.engine import TurnEngine
from coworker.permissions import Mode, PermissionEngine
from coworker.providers import AssistantTurn, ModelCapabilities, ProviderClient, ToolCall
from coworker.providers.base import TokenUsage
from coworker.sessions import usage_totals
from coworker.tools import ToolRegistry
from coworker.tools.agent_tasks import INHERIT_INSTRUCTIONS, agent_task_tools
class DualRoleProvider(ProviderClient):
"""Scripts BOTH the parent and its children, told apart by the system prompt:
a child carries the inherit/explorer instructions, the parent does not."""
def __init__(self, spawn_args: dict):
self.spawn_args = spawn_args
def _is_child(self, messages) -> bool:
head = messages[0] if messages else {}
content = str(head.get("content", ""))
return head.get("role") == "system" and (
"background subagent" in content or "read-only code explorer" in content
)
def complete(self, *, model, messages, tools=None, **settings):
if self._is_child(messages):
if any(m.get("role") == "tool" for m in messages):
return AssistantTurn(text="child report: finished without the blocked step")
tool_names = [t["function"]["name"] for t in (tools or [])]
if "write_marker" in tool_names:
return AssistantTurn(
text="",
tool_calls=[ToolCall(id="c1", name="write_marker", arguments={})],
)
return AssistantTurn(
text="child report: all clear",
usage=TokenUsage(input=100, output=20, cache_read=0, cache_write=0),
)
# Parent: one spawn, then a plain reply.
if not any(m.get("role") == "tool" for m in messages):
return AssistantTurn(
text="", tool_calls=[ToolCall(id="p1", name="spawn_agent", arguments=self.spawn_args)]
)
return AssistantTurn(text="spawned, moving on")
def capabilities(self, model):
return ModelCapabilities(tools=True)
def _parent(tmp_path, provider, extra_tools=None):
tools, registry = agent_task_tools(
workspace=tmp_path, provider=provider, model="m"
)
reg = ToolRegistry()
reg.register_all(tools)
for t in extra_tools or []:
reg.register(t)
engine = TurnEngine(
provider=provider,
registry=reg,
permissions=PermissionEngine(workspace_root=tmp_path, mode=Mode.INTERACTIVE),
model="m",
)
registry.bind(engine)
engine.agent_tasks = registry
return engine, registry
async def _wait_for(predicate, timeout=10.0):
deadline = time.time() + timeout
while time.time() < deadline:
if predicate():
return True
await asyncio.sleep(0.05)
return False
@pytest.mark.asyncio
async def test_read_only_spawn_reports_back_and_counts_tokens(tmp_path):
provider = DualRoleProvider({"task": "map the repo", "label": "repo map"})
engine, registry = _parent(tmp_path, provider)
events = [e async for e in engine.run("go research")]
assert any(e.data.get("text") == "spawned, moving on" for e in events if e.data)
assert await _wait_for(lambda: registry.snapshot() and registry.snapshot()[0]["status"] == "done")
snap = registry.snapshot()[0]
assert snap["label"] == "repo map"
assert snap["usage"]["m"]["input"] == 100 and snap["usage"]["m"]["turns"] == 1
# No manager wired: the report reaches the parent as steering — consumed into the
# transcript when the child beat the turn's end, queued otherwise. The usage
# notice lands in the transcript where usage_totals folds it (OPE-258).
delivered = [s[0] for s in engine._steering] + [
str(m.get("content", "")) for m in engine.messages if m.get("role") == "user"
]
assert any("child report: all clear" in d for d in delivered)
totals = usage_totals(engine.messages)
assert totals["m"]["input"] >= 100 # the child's spend is visible now
# agent_task_output can still peek at the finished run.
out = engine.registry.execute("agent_task_output", {"task_id": snap["id"]})
assert out["status"] == "done" and "all clear" in out["report"]
@pytest.mark.asyncio
async def test_expired_approval_is_declined_and_says_so(tmp_path, monkeypatch):
"""OPE-255 ruling: expiry = declined, never approved, and the child's tool result
must say the request expired — the honest-fallback contract."""
from coworker.tools import agent_tasks as module
monkeypatch.setattr(module, "_MIN_APPROVAL_TIMEOUT", 0.2)
def write_marker() -> dict:
"""Writes a marker file (needs approval)."""
return {"ok": True}
marker_tool = ai.tool(
write_marker,
metadata=ai.ToolMetadata(
category="files", risk_level="high", capabilities=["write"], requires_approval=True
),
)
provider = DualRoleProvider(
{"task": "write the marker", "label": "marker run", "mode": "inherit", "approval_timeout": 0.2}
)
engine, registry = _parent(tmp_path, provider, extra_tools=[marker_tool])
registry.loop = asyncio.get_running_loop()
asked, expired_ids = asyncio.Event(), []
async def never_answers(req):
# The card carries the subagent's name and a prefixed id (no Inbox collision).
assert req.reason and req.reason.startswith("[subagent: marker run]")
assert req.tool_call_id.startswith("agent-")
asked.set()
await asyncio.Event().wait() # the human never responds
engine.approver = never_answers
registry.resolve_expired = expired_ids.append
[e async for e in engine.run("go")]
assert await _wait_for(lambda: registry.snapshot() and registry.snapshot()[0]["status"] == "done")
assert asked.is_set()
task = registry.get(registry.snapshot()[0]["id"])
tool_msgs = [m for m in task.engine.messages if m.get("role") == "tool"]
assert tool_msgs, "the denied call must leave an honest tool result"
assert "expired" in str(tool_msgs[0].get("content", ""))
assert "NOT approved" in str(tool_msgs[0].get("content", ""))
assert expired_ids and expired_ids[0].startswith(task.id + ":")
assert "without the blocked step" in task.report
@pytest.mark.asyncio
async def test_delivery_fires_through_the_server_hooks(tmp_path):
"""The production path the first live run broke: registry.loop SET (the manager
wires it) and a deliver hook — the notice must land and the hook must fire."""
provider = DualRoleProvider({"task": "map the repo", "label": "hooked run"})
engine, registry = _parent(tmp_path, provider)
registry.loop = asyncio.get_running_loop()
delivered: list[tuple[str, dict]] = []
registry.deliver = lambda text, source: delivered.append((text, source))
[e async for e in engine.run("go")]
assert await _wait_for(lambda: bool(delivered))
text, source = delivered[0]
assert "child report: all clear" in text and source["title"] == "hooked run"
# The usage notice went through the loop (scheduled, so give it a beat).
assert await _wait_for(
lambda: any(m.get("role") == "notice" and m.get("kind") == "agent_task" for m in engine.messages)
)
def test_store_marks_live_runs_lost_truncates_and_caps(tmp_path):
from coworker.tools.agent_tasks import AgentTaskStore, _KEEP_FINISHED
path = tmp_path / "agent_tasks.json"
store = AgentTaskStore(path)
rows = [
{"id": "agent-1", "label": "live one", "status": "running", "created": 1},
{"id": "agent-2", "label": "big report", "status": "done", "created": 2, "finished": 99_999, "report": "x" * 20_000},
] + [
{"id": f"agent-{i}", "status": "done", "created": i, "finished": i}
for i in range(3, 3 + _KEEP_FINISHED + 10)
]
store.put("s1", rows)
# A fresh store (the restart) reads the same file: the live run is honestly lost,
# the oversized report is truncated, and the finished list is capped at N.
reopened = AgentTaskStore(path)
out = reopened.load("s1")
lost = next(r for r in out if r["id"] == "agent-1")
assert lost["status"] == "error" and "restart" in lost["note"]
big = next(r for r in out if r["id"] == "agent-2")
assert len(big["report"]) < 9_000 and "truncated" in big["report"]
assert sum(1 for r in out if r["status"] == "done") <= _KEEP_FINISHED
reopened.drop("s1")
assert AgentTaskStore(path).load("s1") == []
@pytest.mark.asyncio
async def test_registry_persists_runs_and_rehydrates_without_id_collisions(tmp_path):
from coworker.tools.agent_tasks import AgentTaskStore
store = AgentTaskStore(tmp_path / "agent_tasks.json")
provider = DualRoleProvider({"task": "map the repo", "label": "first run"})
engine, registry = _parent(tmp_path, provider)
registry.attach_store(store, "sess-1")
[e async for e in engine.run("go")]
assert await _wait_for(lambda: store.load("sess-1") and store.load("sess-1")[0]["status"] == "done")
# A new registry (the rebuilt engine) rehydrates the history and keeps counting
# ABOVE it, so a fresh spawn never reuses agent-1.
_, registry2 = _parent(tmp_path, provider)
registry2.attach_store(store, "sess-1")
snap = registry2.snapshot()
assert snap and snap[0]["label"] == "first run" and snap[0]["status"] == "done"
t = registry2.new_task("second", "t", "read_only", None)
assert t.id != snap[0]["id"]
@pytest.mark.asyncio
async def test_child_tool_calls_are_audited_under_the_parent_with_the_task_id(tmp_path):
"""OPE-262: a child's reads land in the SESSION's audit log, stamped with its task id."""
from coworker.audit import AuditStore
store = AuditStore(tmp_path / "audit.db")
provider = DualRoleProvider({"task": "map the repo", "label": "audited run"})
engine, registry = _parent(tmp_path, provider)
engine.audit_sink = store.append
engine.audit_context = {"session_id": "sess-audit", "agent": "security", "workspace": str(tmp_path)}
(tmp_path / "notes.txt").write_text("x", encoding="utf-8")
[e async for e in engine.run("go")]
assert await _wait_for(lambda: registry.snapshot() and registry.snapshot()[0]["status"] == "done")
rows = store.list(session_id="sess-audit", limit=200)
child_rows = [r for r in rows if r.get("subagent")]
assert child_rows, "the child's calls must reach the parent session's audit log"
assert {r["subagent"] for r in child_rows} == {registry.snapshot()[0]["id"]}
assert all(r["session_id"] == "sess-audit" for r in child_rows)
# The parent's own spawn_agent row stays unstamped: it is the parent acting.
assert any(r["tool"] == "spawn_agent" and not r.get("subagent") for r in rows)
@pytest.mark.asyncio
async def test_child_transcript_is_persisted_pruned_and_purged(tmp_path):
"""OPE-262: the child's full message log lives beside the run record, on demand."""
from coworker.tools.agent_tasks import AgentTaskStore, _KEEP_FINISHED
store = AgentTaskStore(tmp_path / "agent_tasks.json")
provider = DualRoleProvider({"task": "map the repo", "label": "kept run"})
engine, registry = _parent(tmp_path, provider)
registry.attach_store(store, "sess-t")
[e async for e in engine.run("go")]
assert await _wait_for(lambda: registry.snapshot() and registry.snapshot()[0]["status"] == "done")
task_id = registry.snapshot()[0]["id"]
transcript = store.read_transcript("sess-t", task_id)
assert transcript, "the finished child's transcript must be on disk"
assert transcript[0]["role"] == "system" # the explorer's own instructions
assert any(m.get("role") == "assistant" and "all clear" in str(m.get("content")) for m in transcript)
assert store.read_transcript("sess-t", "agent-999") is None
# Retention: a run pruned past the finished cap loses its transcript file too.
rows = store.load("sess-t")
newer = time.time() + 60 # all NEWER than the real run, so the real run is what gets pruned
for i in range(_KEEP_FINISHED + 1):
rows.append({"id": f"agent-{100 + i}", "status": "done", "created": newer + i, "finished": newer + i})
store.put("sess-t", rows)
assert store.read_transcript("sess-t", task_id) is None
# Deleting the session purges whatever is left.
store.write_transcript("sess-t", "agent-150", [{"role": "user", "content": "x"}])
store.drop("sess-t")
assert store.read_transcript("sess-t", "agent-150") is None
@pytest.mark.asyncio
async def test_cancel_stops_a_running_child(tmp_path):
class SlowChildProvider(DualRoleProvider):
def complete(self, *, model, messages, tools=None, **settings):
if self._is_child(messages):
time.sleep(0.3)
return AssistantTurn(
text="", tool_calls=[ToolCall(id="l1", name="grep", arguments={"pattern": "x"})]
)
return super().complete(model=model, messages=messages, tools=tools, **settings)
provider = SlowChildProvider({"task": "loop forever", "label": "loopy"})
engine, registry = _parent(tmp_path, provider)
[e async for e in engine.run("go")]
assert await _wait_for(lambda: bool(registry.snapshot()))
task_id = registry.snapshot()[0]["id"]
engine.registry.execute("agent_task_cancel", {"task_id": task_id})
assert await _wait_for(lambda: registry.snapshot()[0]["status"] in ("canceled", "done"))