Make your computer a home for your AI partner. Avibe is the local-first Agent OS: Vibey, its built-in AI partner, works out of the box, and Claude Code, Codex & OpenCode run unchanged beside it — reach them from your browser, phone, or any chat app.
Python agentagent-osaiai-agentsai-partnerchatopsclaudeclaude-codecodexdevtoolsdiscord-botlark-botllmlocal-firstlong-term-memoryopencodeslack-botvibe-codingvibeywechat
fix(turns): commit the runner's fallback before Hub finalization and publish turn.end after its write (#2735) (#2752)
Call White6b544a3ba3bc
diff --git a/core/session_turns.py b/core/session_turns.pyindex f9ea68361..c5a6b331b 100644--- a/core/session_turns.py+++ b/core/session_turns.py@@ -7835,6 +7835,33 @@ class SessionTurnManager:settled_by = (getattr(turn, "cancel_settled_by", None) if turn is not None else None) or SETTLED_BY_NO_TERMINAL_RESULT+ terminal_commit = (context.platform_specific or {}).pop(+ TERMINAL_COMMIT_KEY, None+ )+ reconciled = False++ def reconcile_release() -> dict[str, Any]:+ return self._reconcile_durable_runner_release(+ logical_turn_id,+ cancelled=cancelled,+ failed=failed,+ prewrite_refused=prewrite_refused,+ definitive_prewrite_exit=definitive_prewrite_exit,+ settled_by=settled_by,+ terminal_is_error=terminal_is_error,+ cancel_defers_queue_resume=cancel_defers_queue_resume,+ failure_evidence=prewrite_failure_evidence(context),+ terminal_commit=terminal_commit,+ )++ if terminal_commit is not None and logical_turn_id and durable_turn_registered:+ # The emit's own Turn write failed (#2714); this write stands in+ # for it, so it lands where that one would have: before Hub+ # finalization, which relies on the row being terminal (#2735).+ durable_terminal_result = reconcile_release()+ # A write that failed again carries no ``changed``; it gets the+ # attempt after finalization that it would have had on its own.+ reconciled = "changed" in durable_terminal_resultcompletion = self._settle_model_hub_turn(context, settled_by)if inspect.isawaitable(completion):from core.handlers.model_hub.async_owner import await_owned_task@@ -7846,27 +7873,18 @@ class SessionTurnManager:# Durable output may already have marked the old row terminal.# _start_persisted_turn still fences its successor on this live# runner, so release the projection only after Hub finalization.- if turn is not None and self.in_flight.get(session_id) is turn:+ released_projection = turn is not None and self.in_flight.get(session_id) is turn+ if released_projection:self.in_flight.pop(session_id, None)+ if not reconciled and logical_turn_id and durable_turn_registered:+ durable_terminal_result = reconcile_release()+ if released_projection:+ # After the terminal write, so its session.status precedes+ # turn.end as it does when the emit's own write lands (#2735).bus.publish("turn.end",_turn_event_payload(session_id, logical_turn_id),)- if logical_turn_id and durable_turn_registered:- durable_terminal_result = self._reconcile_durable_runner_release(- logical_turn_id,- cancelled=cancelled,- failed=failed,- prewrite_refused=prewrite_refused,- definitive_prewrite_exit=definitive_prewrite_exit,- settled_by=settled_by,- terminal_is_error=terminal_is_error,- cancel_defers_queue_resume=cancel_defers_queue_resume,- failure_evidence=prewrite_failure_evidence(context),- terminal_commit=(context.platform_specific or {}).pop(- TERMINAL_COMMIT_KEY, None- ),- )# Only definitive pre-write failure may synthesize an empty# terminal result. Once native work may have produced output, a# persistence failure leaves the durable Turn unresolved for@@ -9357,11 +9375,6 @@ class SessionTurnManager:)if turn is not None:self.in_flight.pop(session_id, None)- if turn is not None:- bus.publish(- "turn.end",- _turn_event_payload(session_id, turn_token),- )if durable_turn_registered:try:durable_terminal_result = self._terminalize_durable_turn(@@ -9398,6 +9411,13 @@ class SessionTurnManager:turn_token,)durable_terminal_result = {"defer_queue_resume": True}+ if turn is not None:+ # After the terminal write, so its session.status precedes+ # turn.end (#2735).+ bus.publish(+ "turn.end",+ _turn_event_payload(session_id, turn_token),+ )should_flush = not (queue_resume_deferredor bool(durable_terminal_result.get("defer_queue_resume"))diff --git a/tests/test_terminal_emit_commit.py b/tests/test_terminal_emit_commit.pyindex c9a0469f9..f36ee6c42 100644--- a/tests/test_terminal_emit_commit.py+++ b/tests/test_terminal_emit_commit.py@@ -19,13 +19,17 @@ from core.message_dispatcher import ActivityOutputDeliveryError, ConsolidatedMesfrom core.message_output import MessageOutputfrom core.native_dispatch_phase import DISPATCH_PHASE_ATTEMPTING, set_dispatch_phasefrom core.session_turns import SessionTurnManager+from sqlalchemy import update+from storage import message_deliveries as delivery_store+from storage.models import agent_sessionsfrom tests.test_message_dispatcher_result_fallback import (_StubIMClient,_StubSessionHandler,_StubSettingsManager,)from core.session_turns import DeliveryRequest+from core.message_context import resolve_turn_sink_keyfrom tests.test_session_delivery_fsm import ( # noqa: F401 - pytest fixtures_activate,_context,@@ -283,15 +287,15 @@ def test_a_durable_step_failure_keeps_the_turn_owner_live(managers, monkeypatch)harness.controller.agent_service.release_runtime_turn.assert_called_once()-def _fail_first_turn_write(manager, monkeypatch) -> list[str]:- """Make the first evidence-carrying Turn write raise, as a busy database would."""+def _fail_first_turn_write(manager, monkeypatch, *, failures: int = 1) -> list[str]:+ """Make the first evidence-carrying Turn writes raise, as a busy database would."""original = manager._terminalize_durable_turncalls: list[str] = []def terminalize(turn_id, outcome, **kwargs):calls.append(str(kwargs.get("evidence_kind")))- if calls == ["terminal_result"]:+ if len(calls) <= failures and calls[-1] == "terminal_result":raise RuntimeError("database is locked")return original(turn_id, outcome, **kwargs)@@ -421,3 +425,119 @@ def test_a_stop_while_the_turn_write_fails_still_commits_the_evidence(managers,async def _no_wait(_context) -> None:return None+++def _record_turn_boundary_events(engine, session_id: str) -> tuple[list[str], int]:+ """Subscribe to the Session's terminal events, with the Session projected running."""++ from core.inbox_events import bus++ with engine.begin() as conn:+ conn.execute(update(agent_sessions).where(agent_sessions.c.id == session_id).values(agent_status="running"))++ events: list[str] = []++ def record(event_type, data):+ if isinstance(data, dict) and data.get("session_id") == session_id and event_type in {+ "session.status",+ "turn.end",+ }:+ events.append(event_type)++ return events, bus.subscribe_callback(record)+++def test_the_runner_fallback_commits_before_hub_finalization_and_turn_end(managers, monkeypatch) -> None:+ """#2735: when the emit's own Turn write fails, the runner's write stands in for+ it, so it lands where that one would have. The Turn is terminal before Model Hub+ finalization, which the Hub's successor fence relies on, and its session.status+ goes out before turn.end."""++ from core.inbox_events import bus++ manager, _other, engine, _engine_b, _starts = managers+ harness = _Harness(manager, engine, monkeypatch)+ _fail_first_turn_write(manager, monkeypatch)+ states_at_hub_finalization: list[str] = []++ def settle_model_hub_turn(context, _settled_by):+ states_at_hub_finalization.append(harness.turn(context.platform_specific["turn_token"])["state"])++ monkeypatch.setattr(manager, "_settle_model_hub_turn", settle_model_hub_turn)+ events, subscription = _record_turn_boundary_events(engine, "ses_fsm")++ async def run() -> str:+ turn_id, context = await _activate(manager, text="prompt")+ runner = await harness.start(turn_id, context)+ await asyncio.wait_for(runner, WAIT_S)+ await asyncio.wait_for(asyncio.gather(*harness.receivers), WAIT_S)+ return turn_id++ try:+ turn_id = asyncio.run(run())+ finally:+ bus.unsubscribe(subscription)++ assert harness.turn(turn_id)["terminal_evidence_kind"] == "terminal_result"+ assert states_at_hub_finalization == ["terminal"]+ assert events == ["session.status", "turn.end"]+++def test_the_agent_initiated_holder_publishes_turn_end_after_its_terminal_write(managers) -> None:+ """#2735: the agent-initiated holder's own terminal write publishes the Turn's+ session.status; turn.end follows it, as it does after the emit's write."""++ from core.inbox_events import bus+ from core.run_settlement import SETTLED_BY_TERMINAL_RESULT++ manager, _other, engine, _engine_b, _starts = managers+ events, subscription = _record_turn_boundary_events(engine, "ses_fsm")++ async def run() -> str:+ context = _context()+ assert manager.register_agent_initiated_turn(context) is True+ await asyncio.sleep(0)+ turn_id = str(context.platform_specific["turn_token"])+ holder = manager.in_flight["ses_fsm"].task+ sink = manager.get_turn_sink(resolve_turn_sink_key(manager.controller, context))+ sink["settled_by"] = SETTLED_BY_TERMINAL_RESULT+ sink["done_event"].set()+ await asyncio.wait_for(asyncio.gather(holder, return_exceptions=True), WAIT_S)+ return turn_id++ try:+ turn_id = asyncio.run(run())+ finally:+ bus.unsubscribe(subscription)++ assert harness_state(engine, turn_id) == "terminal"+ assert events[-2:] == ["session.status", "turn.end"]+++def harness_state(engine, turn_id: str) -> str:+ with engine.connect() as conn:+ return str(delivery_store.get_turn(conn, turn_id)["state"])+++def test_a_fallback_write_that_fails_again_is_retried_after_hub_finalization(managers, monkeypatch) -> None:+ """When the runner's early fallback write meets the same busy database, it still+ gets the attempt after Model Hub finalization that it had on master, and the+ Turn ends with its evidence instead of staying active with its queue held."""++ manager, _other, engine, _engine_b, _starts = managers+ harness = _Harness(manager, engine, monkeypatch)+ calls = _fail_first_turn_write(manager, monkeypatch, failures=2)++ async def run() -> str:+ turn_id, context = await _activate(manager, text="prompt")+ runner = await harness.start(turn_id, context)+ await asyncio.wait_for(runner, WAIT_S)+ await asyncio.wait_for(asyncio.gather(*harness.receivers), WAIT_S)+ return turn_id++ turn_id = asyncio.run(run())++ assert calls == ["terminal_result", "terminal_result", "terminal_result"]+ turn = harness.turn(turn_id)+ assert turn["state"] == "terminal"+ assert turn["terminal_evidence_kind"] == "terminal_result"