mirror of
https://github.com/andrewyng/openworker.git
synced 2026-11-20 20:37:44 +00:00
* 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.
80 lines
3.0 KiB
Python
80 lines
3.0 KiB
Python
"""OPE-261: the live-step batch forwarder must never stall a session for good.
|
|
|
|
The old logic scheduled a flush only when a batch went from empty to one event; if that
|
|
one scheduling call failed (a closed or stale loop), the batch stayed non-empty forever
|
|
and no later event ever scheduled again. Now one flush is tracked explicitly per session
|
|
and a failure is retried by the next event; the batch is bounded too.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import asyncio
|
|
import threading
|
|
from types import SimpleNamespace
|
|
|
|
from coworker.server.manager import SessionManager
|
|
|
|
|
|
class _DeadLoop:
|
|
def call_soon_threadsafe(self, *a, **k):
|
|
raise RuntimeError("Event loop is closed")
|
|
|
|
def call_later(self, *a, **k): # pragma: no cover - never reached on the dead loop
|
|
raise AssertionError
|
|
|
|
|
|
class _LiveLoop:
|
|
def __init__(self):
|
|
self.scheduled = []
|
|
|
|
def call_soon_threadsafe(self, fn, *args):
|
|
# The forwarder hands over `loop.call_later` plus its arguments; record the intent.
|
|
self.scheduled.append((fn, args))
|
|
|
|
def call_later(self, *a, **k): # pragma: no cover - the stub never runs the timer
|
|
raise AssertionError("call_later is scheduled through call_soon_threadsafe, not called directly")
|
|
|
|
|
|
def _forwarder(loop):
|
|
"""The forwarder with just the state it touches (SessionManager is heavy to build)."""
|
|
me = SimpleNamespace(
|
|
_loop=loop,
|
|
_live_loop=None,
|
|
_live_steps={},
|
|
_live_steps_lock=threading.Lock(),
|
|
LIVE_STEP_BATCH_S=SessionManager.LIVE_STEP_BATCH_S,
|
|
LIVE_STEP_BATCH_MAX=SessionManager.LIVE_STEP_BATCH_MAX,
|
|
sent=[],
|
|
)
|
|
me._send_live_steps = lambda sid: SessionManager._send_live_steps(me, sid)
|
|
me.has_session_clients = lambda sid: False # pop-and-drop path in _send_live_steps
|
|
me.forward = lambda ev: SessionManager._forward_recording_event(me, ev)
|
|
return me
|
|
|
|
|
|
def test_a_failed_schedule_is_retried_by_the_next_event():
|
|
dead, live = _DeadLoop(), _LiveLoop()
|
|
me = _forwarder(dead)
|
|
me.forward({"session_id": "s1", "type": "step_started"})
|
|
assert me._live_steps["s1"] and "s1" not in me._live_flush_pending # retry allowed
|
|
|
|
me._loop = live # the next event arrives on a live loop
|
|
me.forward({"session_id": "s1", "type": "step_ended"})
|
|
assert len(live.scheduled) == 1, "the second event must schedule the flush the first could not"
|
|
assert "s1" in me._live_flush_pending
|
|
|
|
|
|
def test_one_flush_in_flight_per_session_and_the_batch_is_bounded():
|
|
live = _LiveLoop()
|
|
me = _forwarder(live)
|
|
for i in range(SessionManager.LIVE_STEP_BATCH_MAX + 50):
|
|
me.forward({"session_id": "s1", "type": "step_started", "i": i})
|
|
assert len(live.scheduled) == 1 # not one per event
|
|
assert len(me._live_steps["s1"]) == SessionManager.LIVE_STEP_BATCH_MAX
|
|
|
|
# The flush clears the pending flag so a later burst schedules again.
|
|
me._send_live_steps("s1")
|
|
assert "s1" not in me._live_flush_pending and "s1" not in me._live_steps
|
|
me.forward({"session_id": "s1", "type": "step_started"})
|
|
assert len(live.scheduled) == 2
|