Skip to content

Build and run agents you can see, understand and trust.

fix(console): preserve pending replies across agent switches (#3317)

Zhiheng Feng976e2ffc9c28
diff --git a/src/agentscope/console/_console.py b/src/agentscope/console/_console.py
index daa9219c4..9e120684a 100644
--- a/src/agentscope/console/_console.py
+++ b/src/agentscope/console/_console.py
@@ -36,10 +36,16 @@ async def _run_reply(
async def consume() -> None:
nonlocal pending
- async for event in agent.reply_stream(inputs):
- renderer.render(event)
- if isinstance(event, RequireUserConfirmEvent):
- pending = event
+ try:
+ async for event in agent.reply_stream(inputs):
+ renderer.render(event)
+ if isinstance(event, RequireUserConfirmEvent):
+ pending = event
+ except BaseException:
+ # Failed streams may omit REPLY_END for several participants.
+ pending = None
+ renderer.reset()
+ raise
task = asyncio.ensure_future(consume())
loop = asyncio.get_running_loop()
diff --git a/src/agentscope/console/_renderer.py b/src/agentscope/console/_renderer.py
index ddf68d023..5530f1aa1 100644
--- a/src/agentscope/console/_renderer.py
+++ b/src/agentscope/console/_renderer.py
@@ -77,14 +77,18 @@ def _format_tool_input(raw: str) -> str:
class ConsoleRenderer:
"""Render :class:`~agentscope.event.AgentEvent` streams as line-based
- terminal output, so that consuming :meth:`Agent.reply_stream` in the
- terminal becomes a one-liner:
+ terminal output. Consume :meth:`Agent.reply_stream` and reset the
+ renderer if the stream fails:
.. code-block:: python
renderer = ConsoleRenderer()
- async for event in agent.reply_stream(msg):
- renderer.render(event)
+ try:
+ async for event in agent.reply_stream(msg):
+ renderer.render(event)
+ except BaseException:
+ renderer.reset()
+ raise
The renderer prints text/thinking deltas as they arrive, buffers the
concurrently-streamed tool calls/results via
@@ -120,6 +124,7 @@ class ConsoleRenderer:
self.console = console or Console(highlight=False)
self._msg: Msg | None = None
+ self._active_msgs: dict[str, Msg] = {}
self._mid_stream = False
@property
@@ -127,6 +132,17 @@ class ConsoleRenderer:
"""The reply message accumulated from the rendered events."""
return self._msg
+ def reset(self) -> None:
+ """Release all accumulated messages and end any streamed line.
+
+ Call this when abandoning a stream or when it raises without a
+ ``ReplyEndEvent``. ``last_msg`` becomes ``None``. Do not reset on a
+ normal HITL pause: its pending replies are needed when resuming.
+ """
+ self._active_msgs.clear()
+ self._msg = None
+ self._break_line(quiet_ok=True)
+
def render(self, event: AgentEvent) -> None:
"""Render the given agent event to the console.
@@ -194,12 +210,22 @@ class ConsoleRenderer:
reply_id = getattr(event, "reply_id", None)
if reply_id is None:
return
+ msg = self._active_msgs.get(reply_id)
+ if msg is None:
+ if self._msg is not None and self._msg.id == reply_id:
+ msg = self._msg
+ else:
+ msg = AssistantMsg(name="agent", content=[], id=reply_id)
if isinstance(event, ReplyStartEvent):
- self._msg = AssistantMsg(name=event.name, content=[], id=reply_id)
- elif self._msg is None or self._msg.id != reply_id:
- # A continuation (e.g. after HITL) without a ReplyStartEvent
- self._msg = AssistantMsg(name="agent", content=[], id=reply_id)
- self._msg.append_event(event)
+ msg.name = event.name
+ self._msg = msg
+ msg.append_event(event)
+ # Keep paused replies across member events, without retaining every
+ # completed reply for the lifetime of the interactive console.
+ if msg.finished_at is None:
+ self._active_msgs[reply_id] = msg
+ else:
+ self._active_msgs.pop(reply_id, None)
def _show(self, level: int) -> bool:
"""Whether the current verbosity covers the given level."""
diff --git a/tests/console_renderer_test.py b/tests/console_renderer_test.py
index 69bf84117..114048506 100644
--- a/tests/console_renderer_test.py
+++ b/tests/console_renderer_test.py
@@ -2,6 +2,8 @@
"""Console renderer test cases."""
from io import StringIO
from unittest import TestCase
+from unittest.mock import patch
+from weakref import ref
from rich.console import Console
@@ -82,6 +84,146 @@ class ConsoleRendererTest(TestCase):
self.assertIn("Friday", self.output())
self.assertIn("hello world", self.output())
+ def test_interleaved_replies_preserve_tool_results(self) -> None:
+ """A member reply must not discard its leader's pending result."""
+ events = [
+ ReplyStartEvent(session_id="s", reply_id="leader", name="Leader"),
+ ToolResultStartEvent(
+ reply_id="leader",
+ tool_call_id="c1",
+ tool_call_name="TeamAssign",
+ ),
+ ReplyStartEvent(session_id="s", reply_id="member", name="Member"),
+ ToolResultStartEvent(
+ reply_id="member",
+ tool_call_id="c1",
+ tool_call_name="lookup",
+ ),
+ ToolResultTextDeltaEvent(
+ reply_id="member",
+ tool_call_id="c1",
+ delta="member result",
+ ),
+ ToolResultTextDeltaEvent(
+ reply_id="leader",
+ tool_call_id="c1",
+ delta="assigned result",
+ ),
+ ToolResultEndEvent(
+ reply_id="member",
+ tool_call_id="c1",
+ state=ToolResultState.SUCCESS,
+ ),
+ ReplyEndEvent(session_id="s", reply_id="member"),
+ ToolResultEndEvent(
+ reply_id="leader",
+ tool_call_id="c1",
+ state=ToolResultState.SUCCESS,
+ ),
+ ReplyEndEvent(session_id="s", reply_id="leader"),
+ ]
+ with patch("agentscope.message._base.logger.warning") as warning:
+ self.render_all(events)
+ warning.assert_not_called()
+ self.assertIn("✓ lookup", self.output())
+ self.assertIn("member result", self.output())
+ self.assertIn("✓ TeamAssign", self.output())
+ self.assertIn("assigned result", self.output())
+ self.assertEqual(self.renderer.last_msg.id, "leader")
+ self.assertEqual(self.renderer.last_msg.name, "Leader")
+
+ def test_repeated_reply_start_preserves_existing_content(self) -> None:
+ """A resumed reply keeps text collected before an agent switch."""
+ self.render_all(
+ [
+ ReplyStartEvent(
+ session_id="s",
+ reply_id=REPLY_ID,
+ name="Friday",
+ ),
+ *self.text_events("first part"),
+ ReplyStartEvent(
+ session_id="s",
+ reply_id="other",
+ name="Other",
+ ),
+ ReplyEndEvent(session_id="s", reply_id="other"),
+ ReplyStartEvent(
+ session_id="s",
+ reply_id=REPLY_ID,
+ name="Friday",
+ ),
+ *self.text_events("second part", block_id="t2"),
+ ],
+ )
+ self.assertEqual(
+ self.renderer.last_msg.get_text_content(),
+ "first part\nsecond part",
+ )
+
+ def test_completed_replies_are_not_retained(self) -> None:
+ """Retain the latest reply, but release earlier completed messages."""
+ self.render_all(
+ [
+ ReplyStartEvent(
+ session_id="s",
+ reply_id=REPLY_ID,
+ name="Friday",
+ ),
+ ReplyEndEvent(session_id="s", reply_id=REPLY_ID),
+ ],
+ )
+ previous = ref(self.renderer.last_msg)
+ self.assertIsNotNone(previous())
+ self.render_all(
+ [
+ ReplyStartEvent(
+ session_id="s",
+ reply_id="next",
+ name="Friday",
+ ),
+ ReplyEndEvent(session_id="s", reply_id="next"),
+ ],
+ )
+ self.assertIsNone(previous())
+
+ def test_reset_releases_unfinished_replies(self) -> None:
+ """Discard abandoned replies and allow the renderer to be reused."""
+ self.renderer.verbosity = "quiet"
+ messages = []
+ for reply_id in (REPLY_ID, "member"):
+ self.renderer.render(
+ ReplyStartEvent(
+ session_id="s",
+ reply_id=reply_id,
+ name="Friday",
+ ),
+ )
+ messages.append(ref(self.renderer.last_msg))
+
+ self.render_all(self.text_events("partial")[:-1])
+ self.renderer.reset()
+ self.renderer.reset()
+
+ self.assertIsNone(self.renderer.last_msg)
+ self.assertEqual([message() for message in messages], [None, None])
+ self.assertEqual(self.output(), "partial\n")
+ self.render_all(
+ [
+ ReplyStartEvent(
+ session_id="s",
+ reply_id=REPLY_ID,
+ name="Friday",
+ ),
+ *self.text_events("recovered"),
+ ],
+ )
+ self.assertEqual(
+ self.renderer.last_msg.get_text_content(),
+ "recovered",
+ )
+ self.assertEqual(self.output(), "partial\nrecovered\n")
+
def test_quiet_hides_everything_but_text(self) -> None:
"""Quiet verbosity only prints the streamed reply text."""
self.renderer.verbosity = "quiet"
diff --git a/tests/console_test.py b/tests/console_test.py
index d8dc4fad6..90401933c 100644
--- a/tests/console_test.py
+++ b/tests/console_test.py
@@ -1,16 +1,32 @@
# -*- coding: utf-8 -*-
+# pylint: disable=protected-access
"""Tests for the interactive console cancellation boundary."""
import asyncio
from collections.abc import AsyncGenerator
+from io import StringIO
from typing import cast
from unittest import IsolatedAsyncioTestCase
from unittest.mock import patch
+from rich.console import Console
+
from agentscope.agent import Agent
from agentscope.console import ConsoleRenderer
from agentscope.console._console import _run_reply
-from agentscope.message import UserMsg
+from agentscope.event import (
+ AgentEvent,
+ ReplyEndEvent,
+ ReplyStartEvent,
+ RequireUserConfirmEvent,
+ TextBlockDeltaEvent,
+ TextBlockStartEvent,
+ ToolResultEndEvent,
+ ToolResultStartEvent,
+ ToolResultTextDeltaEvent,
+ UserConfirmResultEvent,
+)
+from agentscope.message import ToolResultState, UserMsg
class _BlockingAgent:
@@ -22,23 +38,41 @@ class _BlockingAgent:
async def reply_stream(
self,
_inputs: object,
- ) -> AsyncGenerator[None, None]:
+ ) -> AsyncGenerator[AgentEvent, None]:
"""Wait indefinitely so the test can choose who cancels it."""
+ yield ReplyStartEvent(
+ session_id="s",
+ reply_id="blocked",
+ name="Agent",
+ )
+ yield RequireUserConfirmEvent(reply_id="blocked", tool_calls=[])
self.started.set()
- while True:
- await asyncio.Event().wait()
- yield None
+ await asyncio.Event().wait()
+
+class _EventAgent:
+ """Emit a scripted stream, optionally failing before the reply ends."""
-class _Renderer:
- """Renderer stub for a reply stream that never yields an event."""
+ def __init__(self, events: list[AgentEvent | Exception]) -> None:
+ self.events = events
- def render(self, _event: object) -> None:
- """Accept an event without producing terminal output."""
+ async def reply_stream(
+ self,
+ _inputs: object,
+ ) -> AsyncGenerator[AgentEvent, None]:
+ """Emit events until the script ends or raises an exception."""
+ for event in self.events:
+ if isinstance(event, Exception):
+ raise event
+ yield event
class ConsoleCancellationTest(IsolatedAsyncioTestCase):
- """Distinguish caller cancellation from the SIGINT reply interrupt."""
+ """Check cleanup on failure without changing cancellation or HITL."""
+
+ def setUp(self) -> None:
+ """Create a real renderer with captured terminal output."""
+ self.renderer = ConsoleRenderer(console=Console(file=StringIO()))
async def test_run_reply_propagates_caller_cancellation(self) -> None:
"""Cancelling the console task must remain visible to its caller."""
@@ -46,7 +80,7 @@ class ConsoleCancellationTest(IsolatedAsyncioTestCase):
task = asyncio.create_task(
_run_reply(
cast(Agent, agent),
- cast(ConsoleRenderer, _Renderer()),
+ self.renderer,
UserMsg(name="user", content="hello"),
),
)
@@ -56,6 +90,8 @@ class ConsoleCancellationTest(IsolatedAsyncioTestCase):
with self.assertRaises(asyncio.CancelledError):
await task
+ self.assertIsNone(self.renderer.last_msg)
+ self.assertEqual(self.renderer._active_msgs, {})
async def test_run_reply_swallows_sigint_consumer_cancellation(
self,
@@ -78,7 +114,7 @@ class ConsoleCancellationTest(IsolatedAsyncioTestCase):
task = asyncio.create_task(
_run_reply(
cast(Agent, agent),
- cast(ConsoleRenderer, _Renderer()),
+ self.renderer,
UserMsg(name="user", content="hello"),
),
)
@@ -86,3 +122,125 @@ class ConsoleCancellationTest(IsolatedAsyncioTestCase):
signal_callbacks[0]()
self.assertIsNone(await task)
+ self.assertIsNone(self.renderer.last_msg)
+ self.assertEqual(self.renderer._active_msgs, {})
+
+ async def test_failed_replies_are_released_before_reuse(self) -> None:
+ """Failed streams release every participant and preserve the error."""
+ failure = RuntimeError("model stream failed")
+ for index in range(3):
+ agent = _EventAgent(
+ [
+ ReplyStartEvent(
+ session_id="s",
+ reply_id=f"leader-{index}",
+ name="Leader",
+ ),
+ ReplyStartEvent(
+ session_id="s",
+ reply_id=f"member-{index}",
+ name="Member",
+ ),
+ TextBlockStartEvent(
+ reply_id=f"member-{index}",
+ block_id="t1",
+ ),
+ TextBlockDeltaEvent(
+ reply_id=f"member-{index}",
+ block_id="t1",
+ delta="partial response",
+ ),
+ failure,
+ ],
+ )
+ with self.assertRaises(RuntimeError) as caught:
+ await _run_reply(
+ cast(Agent, agent),
+ self.renderer,
+ UserMsg(name="user", content="hello"),
+ )
+ self.assertIs(caught.exception, failure)
+ self.assertIsNone(self.renderer.last_msg)
+ self.assertEqual(self.renderer._active_msgs, {})
+
+ agent.events = [
+ ReplyStartEvent(session_id="s", reply_id="next", name="Leader"),
+ ReplyEndEvent(session_id="s", reply_id="next"),
+ ]
+ await _run_reply(
+ cast(Agent, agent),
+ self.renderer,
+ UserMsg(name="user", content="retry"),
+ )
+ self.assertEqual(self.renderer._active_msgs, {})
+ self.assertEqual(self.renderer.last_msg.id, "next")
+
+ async def test_hitl_keeps_pending_replies_across_streams(self) -> None:
+ """A normal HITL pause retains both leader and member content."""
+ pending = RequireUserConfirmEvent(reply_id="member", tool_calls=[])
+ agent = _EventAgent(
+ [
+ ReplyStartEvent(
+ session_id="s",
+ reply_id="leader",
+ name="Leader",
+ ),
+ ToolResultStartEvent(
+ reply_id="leader",
+ tool_call_id="c1",
+ tool_call_name="TeamAssign",
+ ),
+ ReplyStartEvent(
+ session_id="s",
+ reply_id="member",
+ name="Member",
+ ),
+ TextBlockStartEvent(reply_id="member", block_id="t1"),
+ TextBlockDeltaEvent(
+ reply_id="member",
+ block_id="t1",
+ delta="before",
+ ),
+ pending,
+ ],
+ )
+ result = await _run_reply(
+ cast(Agent, agent),
+ self.renderer,
+ UserMsg(name="user", content="hello"),
+ )
+ self.assertIs(result, pending)
+ member_msg = self.renderer.last_msg
+ agent.events = [
+ TextBlockDeltaEvent(
+ reply_id="member",
+ block_id="t1",
+ delta=" after",
+ ),
+ ReplyEndEvent(session_id="s", reply_id="member"),
+ ToolResultTextDeltaEvent(
+ reply_id="leader",
+ tool_call_id="c1",
+ delta="done",
+ ),
+ ToolResultEndEvent(
+ reply_id="leader",
+ tool_call_id="c1",
+ state=ToolResultState.SUCCESS,
+ ),
+ ReplyEndEvent(session_id="s", reply_id="leader"),
+ ]
+ with patch("agentscope.message._base.logger.warning") as warning:
+ result = await _run_reply(
+ cast(Agent, agent),
+ self.renderer,
+ UserConfirmResultEvent(
+ reply_id="member",
+ confirm_results=[],
+ ),
+ )
+ warning.assert_not_called()
+ self.assertIsNone(result)
+ self.assertEqual(member_msg.get_text_content(), "before after")
+ self.assertEqual(self.renderer.last_msg.id, "leader")
+ self.assertEqual(self.renderer._active_msgs, {})