Build and run agents you can see, understand and trust.
Python agentchatbotlarge-language-modelsllmllm-agentmcpmulti-agentmulti-modalreact-agentrealtime-agentvoice-agentvoice-assistant
fix(console): preserve pending replies across agent switches (#3317)
Zhiheng Feng976e2ffc9c28
diff --git a/src/agentscope/console/_console.py b/src/agentscope/console/_console.pyindex 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()+ raisetask = asyncio.ensure_future(consume())loop = asyncio.get_running_loop()diff --git a/src/agentscope/console/_renderer.py b/src/agentscope/console/_renderer.pyindex 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:: pythonrenderer = 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()+ raiseThe renderer prints text/thinking deltas as they arrive, buffers theconcurrently-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.pyindex 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 StringIOfrom unittest import TestCase+from unittest.mock import patch+from weakref import reffrom 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.pyindex 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 asynciofrom collections.abc import AsyncGenerator+from io import StringIOfrom typing import castfrom unittest import IsolatedAsyncioTestCasefrom unittest.mock import patch+from rich.console import Console+from agentscope.agent import Agentfrom agentscope.console import ConsoleRendererfrom 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, UserMsgclass _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 eventclass 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, {})