Skip to content

Your lightweight open-source personal agent.

perf: reduce streaming text processing and classic CLI redraws (#5728)

chengyongruaa257a705ed1
diff --git a/nanobot/cli/stream.py b/nanobot/cli/stream.py
index 90bf064bb..4bb9fe474 100644
--- a/nanobot/cli/stream.py
+++ b/nanobot/cli/stream.py
@@ -9,7 +9,9 @@ that plagued earlier approaches.
from __future__ import annotations
+import asyncio
import sys
+import time
from contextlib import contextmanager, nullcontext
from typing import Literal
@@ -18,6 +20,8 @@ from rich.live import Live
from rich.markdown import Markdown
from rich.text import Text
+_STREAM_REFRESH_INTERVAL = 0.05
+
def _clear_current_line(console: Console) -> None:
"""Erase a transient status line before printing persistent output."""
@@ -107,6 +111,8 @@ class StreamRenderer:
self.streamed = False
self._console = _make_console()
self._live: Live | None = None
+ self._refresh_handle: asyncio.TimerHandle | None = None
+ self._next_refresh_at = 0.0
self._spinner: ThinkingSpinner | None = None
self._header_printed = False
self._start_spinner()
@@ -160,6 +166,7 @@ class StreamRenderer:
"""Context manager: temporarily stop transient output for clean trace lines."""
@contextmanager
def _pause():
+ self._cancel_refresh()
live_was_active = self._live is not None
if self._live:
# Trace/reasoning can arrive after answer streaming has started.
@@ -191,11 +198,33 @@ class StreamRenderer:
transient=True,
)
self._live.start()
- else:
- self._live.update(self._renderable())
+ self._live.refresh()
+ self._next_refresh_at = time.monotonic() + _STREAM_REFRESH_INTERVAL
+ elif self._refresh_handle is None:
+ delay = max(0.0, self._next_refresh_at - time.monotonic())
+ if delay == 0:
+ self._refresh_stream()
+ else:
+ self._refresh_handle = asyncio.get_running_loop().call_later(
+ delay, self._refresh_stream,
+ )
+
+ def _refresh_stream(self) -> None:
+ self._refresh_handle = None
+ if self._live is None:
+ return
+ self._live.update(self._renderable())
self._live.refresh()
+ # Leave a quiet interval even when rendering itself exceeds the frame budget.
+ self._next_refresh_at = time.monotonic() + _STREAM_REFRESH_INTERVAL
+
+ def _cancel_refresh(self) -> None:
+ if self._refresh_handle is not None:
+ self._refresh_handle.cancel()
+ self._refresh_handle = None
async def on_end(self, *, resuming: bool = False) -> None:
+ self._cancel_refresh()
if self._live:
# Double-refresh to sync _shape before stop() calls refresh().
self._live.refresh()
@@ -225,6 +254,7 @@ class StreamRenderer:
async def close(self) -> None:
"""Stop spinner/live without rendering a final streamed round."""
+ self._cancel_refresh()
if self._live:
self._live.stop()
self._live = None
diff --git a/nanobot/utils/helpers.py b/nanobot/utils/helpers.py
index f964437d4..b2bd9509a 100644
--- a/nanobot/utils/helpers.py
+++ b/nanobot/utils/helpers.py
@@ -191,6 +191,9 @@ def strip_think(text: str) -> str:
tokens mid-text would silently rewrite any message where a user or the
assistant discusses the tokens themselves.
"""
+ # Every supported control tag contains '<'; ordinary text only needs trimming.
+ if "<" not in text:
+ return text.strip()
# Well-formed blocks first.
text = re.sub(rf"<(?P<tag>{_THINKING_TAG})>[\s\S]*?</(?P=tag)>", "", text)
text = re.sub(rf"^\s*<{_THINKING_TAG}>[\s\S]*$", "", text)
@@ -224,6 +227,8 @@ def strip_reasoning_tags(text: object) -> str:
"""Remove wrapper tags from text that is already known to be reasoning."""
if not isinstance(text, str):
return ""
+ if "<" not in text:
+ return text.strip()
text = re.sub(rf"^\s*<{_THINKING_TAG}/>\s*", "", text)
text = re.sub(rf"\s*<{_THINKING_TAG}/>\s*$", "", text)
text = re.sub(rf"^\s*<{_THINKING_TAG}>\s*", "", text)
@@ -239,6 +244,8 @@ def extract_think(text: str) -> tuple[str | None, str]:
extracted; unclosed streaming prefixes are stripped from the cleaned
text but not surfaced — :func:`strip_think` handles that case.
"""
+ if "<" not in text:
+ return None, text.strip()
parts: list[str] = []
for m in re.finditer(rf"<(?P<tag>{_THINKING_TAG})>([\s\S]*?)</(?P=tag)>", text):
parts.append(m.group(2).strip())
diff --git a/tests/cli/test_stream_refresh.py b/tests/cli/test_stream_refresh.py
new file mode 100644
index 000000000..52135bfc7
--- /dev/null
+++ b/tests/cli/test_stream_refresh.py
@@ -0,0 +1,75 @@
+import asyncio
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from nanobot.cli import stream
+
+
[email protected](autouse=True)
+def fixed_arrival_time():
+ # Keep a burst inside one refresh window without changing asyncio's timer clock.
+ with patch.object(stream, "time") as clock:
+ clock.monotonic.return_value = 0.0
+ yield
+
+
+async def test_stream_coalesces_burst_and_flushes_during_provider_pause():
+ with patch.object(stream, "Live") as live_class, patch.object(stream, "_make_console"):
+ live = live_class.return_value
+ renderer = stream.StreamRenderer(show_spinner=False)
+ await renderer.on_delta("first")
+ live.refresh.assert_called_once()
+ for _ in range(100):
+ await renderer.on_delta(" token")
+ live.update.assert_not_called()
+ await asyncio.sleep(stream._STREAM_REFRESH_INTERVAL * 2)
+ live.update.assert_called_once()
+ assert live.update.call_args.args[0].markup == "first" + " token" * 100
+ assert live.refresh.call_count == 2
+ await renderer.close()
+
+
[email protected]("finish", ["end", "close", "pause"])
+async def test_pending_refresh_cannot_write_after_stream_teardown(finish):
+ with patch.object(stream, "Live") as live_class, patch.object(stream, "_make_console"):
+ live = live_class.return_value
+ renderer = stream.StreamRenderer(show_spinner=False)
+ await renderer.on_delta("first")
+ await renderer.on_delta(" last")
+ handle = renderer._refresh_handle
+ assert handle is not None
+ if finish == "end":
+ with patch.object(renderer, "_render_str", return_value="first last\n"), \
+ patch.object(stream.sys, "stdout") as output:
+ await renderer.on_end(resuming=True)
+ output.write.assert_called_once_with("first last\n")
+ assert renderer._buf == ""
+ elif finish == "close":
+ await renderer.close()
+ else:
+ with renderer.pause_spinner():
+ pass
+ assert renderer._buf == "first last"
+ assert handle.cancelled()
+ live.reset_mock()
+ await asyncio.sleep(stream._STREAM_REFRESH_INTERVAL * 2)
+ live.update.assert_not_called()
+ live.refresh.assert_not_called()
+ await renderer.close()
+
+
+async def test_resuming_after_trace_renders_the_buffered_tail():
+ with patch.object(stream, "Live") as live_class, patch.object(stream, "_make_console"):
+ live_class.side_effect = [MagicMock(), MagicMock()]
+ renderer = stream.StreamRenderer(show_spinner=False)
+ await renderer.on_delta("before")
+ await renderer.on_delta(" trace")
+ with renderer.pause_spinner():
+ pass
+ await renderer.on_delta(" after")
+ assert live_class.call_args.args[0].markup == "before trace after"
+ await renderer.close()