fix: use textual batch update for llm chunks

Author: cristipufu

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "uipath-dev"
-version = "0.0.9"
+version = "0.0.10"
 description = "UiPath Developer Console"
 readme = { file = "README.md", content-type = "text/markdown" }
 requires-python = ">=3.11"

src/uipath/dev/ui/panels/chat_panel.py

@@ -12,6 +12,10 @@
 
 from uipath.dev.models import ChatMessage, ExecutionRun
 
+# Tunables for streaming performance
+STREAM_MIN_INTERVAL = 0.08  # seconds between updates while streaming
+STREAM_MIN_DELTA_CHARS = 8  # min new chars before we bother updating
+
 
 class Prompt(Markdown):
     """User prompt message bubble."""
@@ -36,12 +40,14 @@ class ChatPanel(Container):
 
     _chat_widgets: dict[str, Markdown]
     _last_update_time: dict[str, float]
+    _last_content: dict[str, str]
 
     def __init__(self, **kwargs):
         """Initialize the chat panel."""
         super().__init__(**kwargs)
         self._chat_widgets = {}
         self._last_update_time = {}
+        self._last_content = {}
 
     def compose(self) -> ComposeResult:
         """Compose the UI layout."""
@@ -52,19 +58,21 @@ def compose(self) -> ComposeResult:
                 id="chat-input",
             )
 
-    def update_messages(self, run: ExecutionRun) -> None:
+    def refresh_messages(self, run: ExecutionRun) -> None:
         """Update the chat panel with messages from the given execution run."""
-        chat_view = self.query_one("#chat-view")
+        chat_view = self.query_one("#chat-view", VerticalScroll)
         chat_view.remove_children()
         self._chat_widgets.clear()
         self._last_update_time.clear()
+        self._last_content.clear()
 
         for chat_msg in run.messages:
             self.add_chat_message(
                 ChatMessage(message=chat_msg, event=None, run_id=run.id),
                 auto_scroll=False,
             )
 
+        # For a fresh run, always show the latest messages
         chat_view.scroll_end(animate=False)
 
     def add_chat_message(
@@ -73,10 +81,11 @@ def add_chat_message(
         auto_scroll: bool = True,
     ) -> None:
         """Add or update a chat message bubble."""
-        chat_view = self.query_one("#chat-view")
+        chat_view = self.query_one("#chat-view", VerticalScroll)
 
-        message = chat_msg.message
+        should_autoscroll = auto_scroll and not chat_view.is_vertical_scrollbar_grabbed
 
+        message = chat_msg.message
         if message is None:
             return
 
@@ -114,27 +123,67 @@ def add_chat_message(
 
         content = "\n\n".join(content_lines)
 
+        prev_content = self._last_content.get(message.message_id)
+        if prev_content is not None and content == prev_content:
+            # We already rendered this exact content, no need to touch the UI.
+            return
+
         existing = self._chat_widgets.get(message.message_id)
         now = time.monotonic()
         last_update = self._last_update_time.get(message.message_id, 0.0)
+        prev_content_len = len(prev_content) if prev_content is not None else 0
+        delta_len = len(content) - prev_content_len
 
-        if existing:
+        def should_update() -> bool:
             event = chat_msg.event
-            should_update = (
+            finished = (
                 event
                 and event.exchange
                 and event.exchange.message
                 and event.exchange.message.end is not None
             )
-            if should_update or now - last_update > 0.15:
+
+            if finished:
+                # Always paint the final state immediately.
+                return True
+
+            # Throttle streaming: require both some time and a minimum delta size.
+            if now - last_update < STREAM_MIN_INTERVAL:
+                return False
+
+            if delta_len < STREAM_MIN_DELTA_CHARS:
+                return False
+
+            return True
+
+        if existing:
+            if not should_update():
+                return
+
+            # Fast path: message is growing by appending new text.
+            if (
+                isinstance(existing, Markdown)
+                and prev_content is not None
+                and content.startswith(prev_content)
+            ):
+                delta = content[len(prev_content) :]
+                if delta:
+                    # Streaming update: only append the new portion.
+                    existing.append(delta)
+            else:
+                # Fallback for non-monotonic changes: full update.
                 existing.update(content)
-                self._last_update_time[message.message_id] = now
-                if auto_scroll:
-                    chat_view.scroll_end(animate=False)
+
+            self._last_content[message.message_id] = content
+            self._last_update_time[message.message_id] = now
         else:
+            # First time we see this message: create a new widget.
             widget_instance = widget_cls(content)
             chat_view.mount(widget_instance)
             self._chat_widgets[message.message_id] = widget_instance
             self._last_update_time[message.message_id] = now
-            if auto_scroll:
-                chat_view.scroll_end(animate=False)
+            self._last_content[message.message_id] = content
+
+        # Only auto-scroll if we were at the bottom *before* the update
+        if should_autoscroll:
+            chat_view.scroll_end(animate=False)

src/uipath/dev/ui/panels/run_details_panel.py

@@ -307,7 +307,7 @@ def _show_run_details(self, run: ExecutionRun):
 
     def _show_run_chat(self, run: ExecutionRun) -> None:
         chat_panel = self.query_one("#chat-panel", ChatPanel)
-        chat_panel.update_messages(run)
+        chat_panel.refresh_messages(run)
 
     def _rebuild_spans_tree(self):
         """Rebuild the spans tree from current run's traces."""