Skip to content

Your lightweight open-source personal agent.

fix(agent): run explicit recovery continuations

chengyongru078e35f31709
diff --git a/nanobot/agent/loop.py b/nanobot/agent/loop.py
index 92045c66a..6443344a0 100644
--- a/nanobot/agent/loop.py
+++ b/nanobot/agent/loop.py
@@ -1493,7 +1493,7 @@ class AgentLoop:
async with lock, gate:
# A preceding user turn may have completed or blocked the goal
# while its older continuation was still waiting in the inbox.
- if turn_continuation.internal_continuation_inbound(msg.metadata) and not (
+ if turn_continuation.sustained_goal_continuation_inbound(msg.metadata) and not (
sustained_goal_active(self.sessions.get_or_create(session_key).metadata)
):
return
diff --git a/nanobot/session/turn_continuation.py b/nanobot/session/turn_continuation.py
index 3b4736bc7..83a9f7d82 100644
--- a/nanobot/session/turn_continuation.py
+++ b/nanobot/session/turn_continuation.py
@@ -43,6 +43,15 @@ def internal_continuation_inbound(metadata: Mapping[str, Any] | None) -> bool:
return bool(metadata and metadata.get(INTERNAL_CONTINUATION_META) is True)
+def sustained_goal_continuation_inbound(metadata: Mapping[str, Any] | None) -> bool:
+ """True only for an internal continuation owned by sustained-goal policy."""
+ return bool(
+ internal_continuation_inbound(metadata)
+ and metadata
+ and metadata.get(INTERNAL_CONTINUATION_KIND_META) == _GOAL_CONTINUATION_KIND
+ )
+
+
def internal_continuation_pending(metadata: Mapping[str, Any] | None) -> bool:
"""True when the current turn scheduled an invisible continuation slice."""
return bool(metadata and metadata.get(INTERNAL_CONTINUATION_PENDING_META) is True)
diff --git a/tests/agent/test_loop_recovery.py b/tests/agent/test_loop_recovery.py
new file mode 100644
index 000000000..79dd000fb
--- /dev/null
+++ b/tests/agent/test_loop_recovery.py
@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+import asyncio
+from pathlib import Path
+from unittest.mock import AsyncMock
+
+import pytest
+
+from nanobot.agent.loop import AgentLoop
+from nanobot.agent.turn_delivery import TurnDeliveryFactory
+from nanobot.bus.events import OutboundMessage
+from nanobot.bus.queue import MessageBus
+from nanobot.session.manager import SessionManager
+from nanobot.session.recovery import RECOVERY_METADATA_KEY, RecoveryCoordinator
+from nanobot.session.turn_continuation import INTERNAL_CONTINUATION_META
+
+
+async def test_recovery_continuation_runs_without_a_sustained_goal(
+ tmp_path: Path,
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ bus = MessageBus()
+ sessions = SessionManager(tmp_path)
+ session = sessions.get_or_create("websocket:chat")
+ session.metadata.update({
+ "webui": True,
+ RECOVERY_METADATA_KEY: {
+ "status": "awaiting_user",
+ "recovery_id": "recovery-1",
+ "attempts": 0,
+ },
+ })
+ sessions.save(session)
+ recovery = RecoveryCoordinator(sessions, bus)
+
+ loop = AgentLoop.__new__(AgentLoop)
+ loop.sessions = sessions
+ loop._unified_session = False
+ loop._recovery_admission = recovery
+ loop._session_locks = {}
+ loop._concurrency_gate = None
+ loop._automation_turn_coordinators = []
+ loop._discarding_sessions = set()
+ loop._preserve_inflight_turns_on_shutdown = False
+ loop.turn_delivery_factory = TurnDeliveryFactory(bus)
+ process_message = AsyncMock(return_value=OutboundMessage(
+ channel="websocket",
+ chat_id="chat",
+ content="done",
+ ))
+ monkeypatch.setattr(loop, "_process_message", process_message)
+
+ await recovery.handle_action(
+ "continue",
+ {"chat_id": "chat", "recovery_id": "recovery-1"},
+ )
+ continuation = bus.inbound.get_nowait()
+
+ assert continuation.metadata[INTERNAL_CONTINUATION_META] is True
+ await loop._dispatch_one(continuation, asyncio.Queue())
+
+ process_message.assert_awaited_once()
diff --git a/tests/session/test_turn_continuation.py b/tests/session/test_turn_continuation.py
index 090275e3d..b33b81bb5 100644
--- a/tests/session/test_turn_continuation.py
+++ b/tests/session/test_turn_continuation.py
@@ -24,6 +24,7 @@ from nanobot.session.turn_continuation import (
maybe_continue_turn,
should_finalize_on_max_iterations,
should_stream_budget_response,
+ sustained_goal_continuation_inbound,
)
@@ -73,6 +74,7 @@ async def test_maybe_continue_turn_queues_internal_message():
assert queued.sender_id == "system:continuation"
assert queued.metadata[INTERNAL_CONTINUATION_META] is True
assert queued.metadata[INTERNAL_CONTINUATION_KIND_META] == "sustained_goal"
+ assert sustained_goal_continuation_inbound(queued.metadata) is True
assert queued.metadata[INTERNAL_CONTINUATION_RUN_STARTED_AT_META] == 1234.5
assert internal_continuation_run_started_at(queued.metadata) == 1234.5
assert internal_continuation_pending(ctx.msg.metadata)
@@ -90,6 +92,10 @@ async def test_maybe_continue_turn_queues_internal_message():
assert meta["_sustained_goal_continuation_rounds"] == 1
+def test_generic_internal_continuation_is_not_a_sustained_goal_continuation() -> None:
+ assert sustained_goal_continuation_inbound({INTERNAL_CONTINUATION_META: True}) is False
+
+
@pytest.mark.asyncio
async def test_internal_continuation_respects_round_limit():
meta = {